Python HttpClient.receive方法代码示例

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_model_sub(self):
        # define consumers
        routes = ModelSubscribeConsumers.as_routes(model=User)
        # create client
        client = HttpClient()

        # create object
        user = User.objects.create_user(username='test', email='[email protected]')

        with apply_routes([routes]):
            # subscribe for Models changes
            client.send_and_consume(u'websocket.connect')

            # change object
            user.username = 'new username'
            user.save()

            res = json.loads(client.receive()['text'])
            self.assertEqual(res['action'], 'updated')
            self.assertEqual(res['data']['username'], 'new username')
            self.assertEqual(res['data']['email'], '[email protected]')

            # create new one
            to_del = User.objects.create_user(username='test2', email='[email protected]')
            res = json.loads(client.receive()['text'])
            self.assertEqual(res['action'], 'created')
            self.assertEqual(res['data']['username'], 'test2')
            self.assertEqual(res['data']['email'], '[email protected]')

            # delete
            to_del.delete()
            res = json.loads(client.receive()['text'])
            self.assertEqual(res['action'], 'deleted')
            self.assertEqual(res['data']['username'], 'test2')
            self.assertEqual(res['data']['email'], '[email protected]')

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_simple_as_route_method(self):

        class WebsocketConsumer(websockets.WebsocketConsumer):

            def connect(self, message, **kwargs):
                self.message.reply_channel.send({'accept': True})
                self.send(text=message.get('order'))

        routes = [
            WebsocketConsumer.as_route(attrs={"strict_ordering": True}, path='^/path$'),
            WebsocketConsumer.as_route(path='^/path/2$'),
        ]

        self.assertIsNot(routes[0].consumer, WebsocketConsumer)
        self.assertIs(routes[1].consumer, WebsocketConsumer)

        with apply_routes(routes):
            client = HttpClient()

            client.send('websocket.connect', {'path': '/path', 'order': 1})
            client.send('websocket.connect', {'path': '/path', 'order': 0})
            client.consume('websocket.connect', check_accept=False)
            client.consume('websocket.connect')
            self.assertEqual(client.receive(json=False), 0)
            client.consume('websocket.connect')
            self.assertEqual(client.receive(json=False), 1)

            client.send_and_consume('websocket.connect', {'path': '/path/2', 'order': 'next'})
            self.assertEqual(client.receive(json=False), 'next')

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_trigger_outbound_delete(self):
        class TestBinding(WebsocketBinding):
            model = User
            stream = 'test'
            fields = ['username']

            def group_names(self, instance, action):
                return ["users3"]

            def has_permission(self, user, action, pk):
                return True

        user = User.objects.create(username='test', email='[email protected]')

        with apply_routes([route('test', TestBinding.consumer)]):
            client = HttpClient()
            client.join_group('users3')

            user.delete()

            received = client.receive()
            self.assertTrue('payload' in received)
            self.assertTrue('action' in received['payload'])
            self.assertTrue('data' in received['payload'])
            self.assertTrue('username' in received['payload']['data'])
            self.assertTrue('model' in received['payload'])
            self.assertTrue('pk' in received['payload'])

            self.assertEqual(received['payload']['action'], 'delete')
            self.assertEqual(received['payload']['model'], 'auth.user')
            self.assertEqual(received['payload']['pk'], 1)
            self.assertEqual(received['payload']['data']['username'], 'test')

            received = client.receive()
            self.assertIsNone(received)

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_object_sub_with_fields(self):
        # create object for subscribe
        sub_object = User.objects.create_user(username='test', email='[email protected]')

        # define consumers
        routes = ObjectSubscribeConsumers.as_routes(path='/(?P<pk>\d+)/?', model=User,
                                                    serializer_kwargs={'fields': ['username', 'is_active']})

        # create client
        client = HttpClient()
        with apply_routes([routes]):
            # subscribe for object changes
            client.send_and_consume(u'websocket.connect', content={'path': '/{}'.format(sub_object.pk)})

            # change sub object
            sub_object.username = 'sub_object'
            sub_object.email = '[email protected]'
            sub_object.save()

            res = json.loads(client.receive()['text'])['data']
            self.assertEqual(res['username'], 'sub_object')
            self.assertEqual(res['is_active'], True)
            self.assertNotIn('email', res)
            self.assertNotIn('is_staff', res)

            sub_object.username = 'test'
            sub_object.is_active = False
            sub_object.save()

            res = json.loads(client.receive()['text'])
            self.assertEqual(res['action'], 'updated')
            self.assertNotIn('email', res['data'])
            self.assertNotIn('is_staff', res['data'])

            self.assertEqual(res['data']['username'], 'test')
            self.assertEqual(res['data']['is_active'], False)

            sub_object.username = 'test_new'
            sub_object.save(update_fields=['username'])

            res = json.loads(client.receive()['text'])
            self.assertEqual(res['action'], 'updated')
            self.assertEqual(res['data']['username'], 'test_new')
            self.assertNotIn('is_active', res['data'])
            self.assertNotIn('is_staff', res['data'])

            sub_object.email = '[email protected]'
            sub_object.save(update_fields=['email'])

            # check that nothing happened
            self.assertIsNone(client.receive())

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_crud_consumers(self):
        # create object
        for i in range(20):
            User.objects.create_user(username='test' + str(i), email='[email protected]')
        # create client
        client = HttpClient()

        with apply_routes([CRUDConsumers.as_routes(model=User, path='/', channel_name='test', paginate_by=10)]):
            client.send_and_consume(u'websocket.connect', {'path': '/'})
            client.send_and_consume(u'websocket.receive', {'path': '/', 'action': 'list', 'page': 2})
            client.consume('test')
            rec = client.receive()
            res = json.loads(json.loads(rec['text'])['response'])

            self.assertEqual(len(res), 10)
            self.assertEqual(res[0]['username'], 'test10')
            self.assertEqual(res[0]['email'], '[email protected]')
            self.assertEqual(res[0]['is_active'], True)

            client.send_and_consume(u'websocket.connect', {'path': '/{}'.format(10)})
            client.send_and_consume(u'websocket.receive', {'path': '/{}'.format(10), 'action': 'delete'})
            client.consume('test')

            self.assertFalse(User.objects.filter(pk=10).exists())

            data = {'username': 'new_name'}
            client.send_and_consume('websocket.connect', {'path': '/{}'.format(11)})
            client.send_and_consume('websocket.receive', {'path': '/{}'.format(11), 'action': 'update',
                                                          'data': json.dumps(data)})
            client.consume('test')

            user = User.objects.filter(pk=11).first()
            self.assertTrue(user)
            self.assertEqual(user.username, 'new_name')

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_inbound_delete(self):
        user = User.objects.create(username='test', email='[email protected]')

        class Demultiplexer(WebsocketDemultiplexer):
            mapping = {
                'users': 'binding.users',
            }

            groups = ['inbound']

        class UserBinding(WebsocketBinding):
            model = User
            stream = 'users'
            fields = ['username', ]

            @classmethod
            def group_names(cls, instance, action):
                return ['users_outbound']

            def has_permission(self, user, action, pk):
                return True

        with apply_routes([Demultiplexer.as_route(path='/'), route('binding.users', UserBinding.consumer)]):
            client = HttpClient()
            client.send_and_consume('websocket.connect', path='/')
            client.send_and_consume('websocket.receive', path='/', text={
                'stream': 'users',
                'payload': {'action': DELETE, 'pk': user.pk}
            })
            # our Demultiplexer route message to the inbound consumer, so call Demultiplexer consumer
            client.consume('binding.users')

        self.assertIsNone(User.objects.filter(pk=user.pk).first())
        self.assertIsNone(client.receive())

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_trigger_outbound_update(self):
        class TestBinding(WebsocketBinding):
            model = User
            stream = 'test'
            fields = ['__all__']

            @classmethod
            def group_names(cls, instance, action):
                return ["users2"]

            def has_permission(self, user, action, pk):
                return True

        # Make model and clear out pending sends
        user = User.objects.create(username='test', email='[email protected]')
        consumer_finished.send(sender=None)

        with apply_routes([route('test', TestBinding.consumer)]):
            client = HttpClient()
            client.join_group('users2')

            user.username = 'test_new'
            user.save()

            consumer_finished.send(sender=None)
            received = client.receive()
            self.assertTrue('payload' in received)
            self.assertTrue('action' in received['payload'])
            self.assertTrue('data' in received['payload'])
            self.assertTrue('username' in received['payload']['data'])
            self.assertTrue('email' in received['payload']['data'])
            self.assertTrue('password' in received['payload']['data'])
            self.assertTrue('last_name' in received['payload']['data'])
            self.assertTrue('model' in received['payload'])
            self.assertTrue('pk' in received['payload'])

            self.assertEqual(received['payload']['action'], 'update')
            self.assertEqual(received['payload']['model'], 'auth.user')
            self.assertEqual(received['payload']['pk'], user.pk)

            self.assertEqual(received['payload']['data']['email'], '[email protected]')
            self.assertEqual(received['payload']['data']['username'], 'test_new')
            self.assertEqual(received['payload']['data']['password'], '')
            self.assertEqual(received['payload']['data']['last_name'], '')

            received = client.receive()
            self.assertIsNone(received)

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_object_sub(self):

        # create object for subscribe
        sub_object = User.objects.create_user(username='test', email='[email protected]')

        # create object without subscribers
        just_object = User.objects.create_user(username='test2', email='[email protected]')

        # define consumers
        routes = ObjectSubscribeConsumers.as_routes(path='/(?P<pk>\d+)/?', model=User)

        # create client
        client = HttpClient()
        with apply_routes([routes]):
            # subscribe for object changes
            client.send_and_consume(u'websocket.connect', content={'path': '/{}'.format(sub_object.pk)})

            # change sub object
            sub_object.username = 'sub_object'
            sub_object.email = '[email protected]'
            sub_object.save()
            res = json.loads(client.receive()['text'])
            self.assertEqual(res['action'], 'updated')
            self.assertEqual(res['data']['username'], 'sub_object')
            self.assertEqual(res['data']['email'], '[email protected]')
            self.assertEqual(res['data']['is_staff'], False)

            # change second object
            just_object.email = '[email protected]'
            just_object.save()

            # check that nothing happened
            self.assertIsNone(client.receive())

            # delete
            sub_object.delete()
            just_object.delete()
            res = json.loads(client.receive()['text'])
            self.assertEqual(res['action'], 'deleted')
            self.assertEqual(res['data']['username'], 'sub_object')
            self.assertEqual(res['data']['email'], '[email protected]')
            self.assertEqual(res['data']['is_staff'], False)

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_websockets_demultiplexer(self):

        class MyWebsocketConsumer(websockets.JsonWebsocketConsumer):
            def connect(self, message, multiplexer=None, **kwargs):
                multiplexer.send(kwargs)

            def disconnect(self, message, multiplexer=None, **kwargs):
                multiplexer.send(kwargs)

            def receive(self, content, multiplexer=None, **kwargs):
                multiplexer.send(content)

        class Demultiplexer(websockets.WebsocketDemultiplexer):

            consumers = {
                "mystream": MyWebsocketConsumer
            }

        with apply_routes([route_class(Demultiplexer, path='/path/(?P<id>\d+)')]):
            client = HttpClient()

            client.send_and_consume('websocket.connect', path='/path/1')
            self.assertEqual(client.receive(), {
                "stream": "mystream",
                "payload": {"id": "1"},
            })

            client.send_and_consume('websocket.receive', text={
                "stream": "mystream",
                "payload": {"text_field": "mytext"},
            }, path='/path/1')
            self.assertEqual(client.receive(), {
                "stream": "mystream",
                "payload": {"text_field": "mytext"},
            })

            client.send_and_consume('websocket.disconnect', path='/path/1')
            self.assertEqual(client.receive(), {
                "stream": "mystream",
                "payload": {"id": "1"},
            })

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_filters_and_routing(self):
        class Test(Consumers):
            channel_name = 'test'
            mark = 'default'

            @consumer(tag='test')
            def test(this, message):
                this.reply_channel.send({'status': 'ok'})

            @consumer('test2', tag='test')
            def test2(this, message):
                this.reply_channel.send({'status': 'ok', 'mark': this.mark})

        with apply_routes([Test.as_routes(), Test.as_routes(channel_name='test3', mark='new')]):
            client = HttpClient()
            self.assertIsNone(client.send_and_consume(u'test', content={'tag': 'tag'}, fail_on_none=False))

            client.send_and_consume(u'test', content={'tag': 'test'})

            self.assertDictEqual(client.receive(), {'status': 'ok'})
            client.consume('test', fail_on_none=False)
            self.assertIsNone(client.receive())

            client.send_and_consume(u'test3', content={'tag': 'test'})

            self.assertDictEqual(client.receive(), {'status': 'ok'})
            client.consume('test3', fail_on_none=False)
            self.assertIsNone(client.receive())

            client.send_and_consume(u'test2', content={'tag': 'test'})
            self.assertDictEqual(client.receive(), {'status': 'ok', 'mark': 'default'})
            client.consume('test2', fail_on_none=False)
            self.assertIsNone(client.receive())

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_websocket_demultiplexer_send(self):

        class MyWebsocketConsumer(websockets.JsonWebsocketConsumer):
            def receive(self, content, multiplexer=None, **kwargs):
                self.send(content)

        class Demultiplexer(websockets.WebsocketDemultiplexer):

            consumers = {
                "mystream": MyWebsocketConsumer
            }

        with apply_routes([route_class(Demultiplexer, path='/path/(?P<id>\d+)')]):
            client = HttpClient()

            with self.assertRaises(SendNotAvailableOnDemultiplexer):
                client.send_and_consume('websocket.receive', path='/path/1', text={
                    "stream": "mystream",
                    "payload": {"text_field": "mytext"},
                })

                client.receive()

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_object_sub_with_subs_first(self):
        # define consumers
        routes = ObjectSubscribeConsumers.as_routes(path='/(?P<pk>\d+)/?', model=User)
        # create client
        client = HttpClient()
        with apply_routes([routes]):
            # subscribe for object changes
            client.send_and_consume(u'websocket.connect', content={'path': '/{}'.format('1')})

            # create object
            User.objects.create_user(username='test', email='[email protected]')
            res = json.loads(client.receive()['text'])
            self.assertTrue('data' in res.keys())
            self.assertTrue('action' in res.keys())
            self.assertTrue(res['action'] == 'created')
            data = res['data']
            self.assertEqual(data['username'], 'test')
            self.assertEqual(data['is_active'], True)
            self.assertEqual(data['email'], '[email protected]')
            self.assertEqual(data['is_staff'], False)

            # check that nothing happened
            self.assertIsNone(client.receive())

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_get_mixin(self):
        # create object
        obj = User.objects.create_user(username='test', email='[email protected]')
        # create client
        client = HttpClient()

        with apply_routes([ReadOnlyConsumers.as_routes(model=User, path='/(?P<pk>\d+)/?', channel_name='test')]):

            client.send_and_consume(u'websocket.connect', {'path': '/{}'.format(obj.pk)})
            client.send_and_consume(u'websocket.receive', {'path': '/{}'.format(obj.pk), 'action': 'get'})
            client.consume('test')
            res = json.loads(json.loads(client.receive()['text'])['response'])

            self.assertEqual(res['username'], 'test')
            self.assertEqual(res['email'], '[email protected]')
            self.assertEqual(res['is_active'], True)

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_list_consumers(self):
        # create object
        for i in range(20):
            User.objects.create_user(username='test' + str(i), email='[email protected]')
        # create client
        client = HttpClient()

        with apply_routes([ListConsumers.as_routes(model=User, path='/', channel_name='test', paginate_by=10)]):
            client.send_and_consume(u'websocket.connect', {'path': '/'})
            client.send_and_consume(u'websocket.receive', {'path': '/', 'action': 'list', 'page': 2})
            client.consume('test')
            rec = client.receive()
            res = json.loads(json.loads(rec['text'])['response'])

        self.assertEqual(len(res), 10)
        self.assertEqual(res[0]['username'], 'test10')
        self.assertEqual(res[0]['email'], '[email protected]')
        self.assertEqual(res[0]['is_active'], True)

# 需要导入模块: from channels.tests import HttpClient [as 别名]
# 或者: from channels.tests.HttpClient import receive [as 别名]
    def test_passing_kwargs_and_reply_channel(self):

        class Test(Consumers):
            path = '^/(?P<slug>[^/]+)/(?P<pk>\d+)/?'
            channel_name = 'test'

            @consumer(tag='(?P<test>[^/]+)')
            def test(this, message, test):
                this.reply_channel.send({'test': test, 'kwargs': message.content['_kwargs']['slug'],
                                         'slug': this.kwargs.get('slug', None)})

        with apply_routes([Test.as_routes()]):
            client = HttpClient()
            client.send_and_consume(u'websocket.connect', content={'path': '/name/123/'})
            client.send_and_consume(u'websocket.receive', content={'path': '/name/123', 'tag': 'tag'})
            client.consume(u'test')
            content = client.receive()

            self.assertDictEqual(content, {'test': 'tag', 'slug': 'name', 'kwargs': 'name'})