Esempio n. 1
0
    def test_websockets_consumers_handlers(self):
        class WebsocketConsumer(websockets.WebsocketConsumer):
            def connect(self, message, **kwargs):
                self.called = 'connect'
                self.id = kwargs['id']

            def disconnect(self, message, **kwargs):
                self.called = 'disconnect'

            def receive(self, text=None, bytes=None, **kwargs):
                self.text = text

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

            consumer = client.send_and_consume('websocket.connect',
                                               {'path': '/path/1'})
            self.assertEqual(consumer.called, 'connect')
            self.assertEqual(consumer.id, '1')

            consumer = client.send_and_consume('websocket.receive', {
                'path': '/path/1',
                'text': 'text'
            })
            self.assertEqual(consumer.text, 'text')

            consumer = client.send_and_consume('websocket.disconnect',
                                               {'path': '/path/1'})
            self.assertEqual(consumer.called, 'disconnect')
Esempio n. 2
0
class TestStreamConsumerReceive(ChannelTestCase):
    @classmethod
    def setUpTestData(cls):
        super(TestStreamConsumerReceive, cls).setUpTestData()
        cls.content = ContentFactory()

    def setUp(self):
        super(TestStreamConsumerReceive, self).setUp()
        self.client = Client()

    def test_receive_sends_reply_content(self):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path":
                "/ch/streams/public/",
                "text":
                '{"action": "load_content", "ids": [%s]}' % self.content.id,
            },
        )
        receive = self.client.receive()
        text = json.loads(receive["text"])
        self.assertEqual(text["event"], "content")
        self.assertEqual(text["contents"], [{
            "id": self.content.id,
            "author": self.content.author.id,
            "rendered": self.content.rendered,
        }])
Esempio n. 3
0
    def test_websockets_consumers_handlers(self):

        class WebsocketConsumer(websockets.WebsocketConsumer):

            def connect(self, message, **kwargs):
                self.called = 'connect'
                self.id = kwargs['id']

            def disconnect(self, message, **kwargs):
                self.called = 'disconnect'

            def receive(self, text=None, bytes=None, **kwargs):
                self.text = text

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

            consumer = client.send_and_consume('websocket.connect', {'path': '/path/1'})
            self.assertEqual(consumer.called, 'connect')
            self.assertEqual(consumer.id, '1')

            consumer = client.send_and_consume('websocket.receive', {'path': '/path/1', 'text': 'text'})
            self.assertEqual(consumer.text, 'text')

            consumer = client.send_and_consume('websocket.disconnect', {'path': '/path/1'})
            self.assertEqual(consumer.called, 'disconnect')
Esempio n. 4
0
    def test_base_consumer(self):
        class Consumers(BaseConsumer):

            method_mapping = {
                'test.create': 'create',
                'test.test': 'test',
            }

            def create(self, message, **kwargs):
                self.called = 'create'

            def test(self, message, **kwargs):
                self.called = 'test'

        with apply_routes([route_class(Consumers)]):
            client = Client()

            #  check that methods for certain channels routes successfully
            self.assertEqual(
                client.send_and_consume('test.create').called, 'create')
            self.assertEqual(
                client.send_and_consume('test.test').called, 'test')

            #  send to the channels without routes
            client.send('test.wrong')
            message = self.get_next_message('test.wrong')
            self.assertEqual(client.channel_layer.router.match(message), None)

            client.send('test')
            message = self.get_next_message('test')
            self.assertEqual(client.channel_layer.router.match(message), None)
Esempio n. 5
0
    def test_as_route_method(self):
        class WebsocketConsumer(BaseConsumer):
            trigger = 'new'

            def test(self, message, **kwargs):
                self.message.reply_channel.send({'trigger': self.trigger})

        method_mapping = {'mychannel': 'test'}

        with apply_routes([WebsocketConsumer.as_route(
                {'method_mapping': method_mapping, 'trigger': 'from_as_route'},
                name='filter')]):
            client = Client()

            client.send_and_consume('mychannel', {'name': 'filter'})
            self.assertEqual(client.receive(), {'trigger': 'from_as_route'})
Esempio n. 6
0
    def test_consumer(self):
        client = Client()
        with apply_routes([MyConsumer.as_route()]):
            spy.reset_mock()
            client.send_and_consume(u'websocket.connect', {'path': '/'})
            client.send_and_consume(
                u'websocket.receive', {
                    'path':
                    '/',
                    'text':
                    json.dumps({
                        'type': 'INCREMENT_COUNTER',
                        'payload': 2,
                    }),
                })

            self.assertEqual(spy.call_count, 1)
            self.assertEqual(
                client.receive(), {
                    'text':
                    json.dumps({
                        'type': 'INCREMENTED_COUNTER',
                        'payload': 2,
                    }),
                })
Esempio n. 7
0
    def test_base_consumer(self):

        class Consumers(BaseConsumer):

            method_mapping = {
                'test.create': 'create',
                'test.test': 'test',
            }

            def create(self, message, **kwargs):
                self.called = 'create'

            def test(self, message, **kwargs):
                self.called = 'test'

        with apply_routes([route_class(Consumers)]):
            client = Client()

            #  check that methods for certain channels routes successfully
            self.assertEqual(client.send_and_consume('test.create').called, 'create')
            self.assertEqual(client.send_and_consume('test.test').called, 'test')

            #  send to the channels without routes
            client.send('test.wrong')
            message = self.get_next_message('test.wrong')
            self.assertEqual(client.channel_layer.router.match(message), None)

            client.send('test')
            message = self.get_next_message('test')
            self.assertEqual(client.channel_layer.router.match(message), None)
Esempio n. 8
0
    def test_as_route_method(self):
        class WebsocketConsumer(BaseConsumer):
            trigger = 'new'

            def test(self, message, **kwargs):
                self.message.reply_channel.send({'trigger': self.trigger})

        method_mapping = {'mychannel': 'test'}

        with apply_routes([
                WebsocketConsumer.as_route(
                    {
                        'method_mapping': method_mapping,
                        'trigger': 'from_as_route'
                    },
                    name='filter')
        ]):
            client = Client()

            client.send_and_consume('mychannel', {'name': 'filter'})
            self.assertEqual(client.receive(), {'trigger': 'from_as_route'})
Esempio n. 9
0
    def test_websocket_demultiplexer_send(self):
        class MyWebsocketConsumer(websockets.JsonWebsocketConsumer):
            def receive(self, content, multiplexer=None, **kwargs):
                import pdb
                pdb.set_trace()  # breakpoint 69f2473b //

                self.send(content)

        class Demultiplexer(websockets.WebsocketDemultiplexer):

            consumers = {"mystream": MyWebsocketConsumer}

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

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

                client.receive()
Esempio n. 10
0
    def test_websockets_decorators(self):
        class WebsocketConsumer(websockets.WebsocketConsumer):
            slight_ordering = True

            def connect(self, message, **kwargs):
                self.order = message['order']

        with apply_routes([route_class(WebsocketConsumer, path='/path')]):
            client = Client()

            client.send('websocket.connect', {'path': '/path', 'order': 1})
            client.send('websocket.connect', {'path': '/path', 'order': 0})
            client.consume('websocket.connect')
            self.assertEqual(client.consume('websocket.connect').order, 0)
            self.assertEqual(client.consume('websocket.connect').order, 1)
Esempio n. 11
0
    def test_websockets_decorators(self):
        class WebsocketConsumer(websockets.WebsocketConsumer):
            strict_ordering = True

            def connect(self, message, **kwargs):
                self.order = message['order']

        with apply_routes([route_class(WebsocketConsumer, path='/path')]):
            client = Client()

            client.send('websocket.connect', {'path': '/path', 'order': 1})
            client.send('websocket.connect', {'path': '/path', 'order': 0})
            client.consume('websocket.connect')
            self.assertEqual(client.consume('websocket.connect').order, 0)
            self.assertEqual(client.consume('websocket.connect').order, 1)
Esempio n. 12
0
 def setUp(self):
     super(ResourceBindingTestCase, self).setUp()
     self.client = Client()
Esempio n. 13
0
class ResourceBindingTestCase(ChannelTestCase):
    def setUp(self):
        super(ResourceBindingTestCase, self).setUp()
        self.client = Client()

    def _send_and_consume(self, channel, data):
        """Helper that sends and consumes message and returns the next message."""
        self.client.send_and_consume(force_text(channel), data)
        return self._get_next_message()

    def _get_next_message(self):
        msg = self.client.get_next_message(self.client.reply_channel)
        return json.loads(msg['text'])

    def _build_message(self, stream, payload):
        return {
            "text": json.dumps({
                "stream": stream,
                "payload": payload
            }),
            "path": "/"
        }

    def test_create(self):
        """Integration that asserts routing a message to the create channel.

        Asserts response is correct and an object is created.
        """
        json_content = self._send_and_consume(
            "websocket.receive",
            self._build_message(
                "testmodel", {
                    'action': 'create',
                    'pk': None,
                    'request_id': 'client-request-id',
                    'data': {
                        'name': 'some-thing'
                    }
                }))
        # it should create an object
        self.assertEqual(TestModel.objects.count(), 1)

        expected = {
            'action': 'create',
            'data': TestModelSerializer(TestModel.objects.first()).data,
            'errors': [],
            'request_id': 'client-request-id',
            'response_status': 201
        }
        # it should respond with the serializer.data
        self.assertEqual(json_content['payload'], expected)

    def test_create_failure(self):
        """Integration that asserts error handling of a message to the create channel."""

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                "testmodel", {
                    'action': 'create',
                    'pk': None,
                    'request_id': 'client-request-id',
                    'data': {},
                }))
        # it should not create an object
        self.assertEqual(TestModel.objects.count(), 0)

        expected = {
            'action': 'create',
            'data': None,
            'request_id': 'client-request-id',
            'errors': [{
                'name': ['This field is required.']
            }],
            'response_status': 400
        }
        # it should respond with an error
        self.assertEqual(json_content['payload'], expected)

    def test_delete(self):
        instance = TestModel.objects.create(name='test-name')

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'delete',
                    'pk': instance.id,
                    'request_id': 'client-request-id',
                }))

        expected = {
            'action': 'delete',
            'errors': [],
            'data': {},
            'request_id': 'client-request-id',
            'response_status': 200
        }
        self.assertEqual(json_content['payload'], expected)
        self.assertEqual(TestModel.objects.count(), 0)

    def test_delete_failure(self):
        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message('testmodel', {
                'action': 'delete',
                'pk': -1,
                'request_id': 'client-request-id'
            }))

        expected = {
            'action': 'delete',
            'errors': ['Not found.'],
            'data': None,
            'request_id': 'client-request-id',
            'response_status': 404
        }

        self.assertEqual(json_content['payload'], expected)

    def test_list(self):
        for n in range(api_settings.DEFAULT_PAGE_SIZE + 1):
            TestModel.objects.create(name='Name-{}'.format(str(n)))

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'list',
                    'request_id': 'client-request-id',
                    'data': None,
                }))

        self.assertEqual(len(json_content['payload']['data']),
                         api_settings.DEFAULT_PAGE_SIZE)

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'list',
                    'request_id': 'client-request-id',
                    'data': {
                        'page': 2
                    }
                }))

        self.assertEqual(len(json_content['payload']['data']), 1)
        self.assertEqual('client-request-id',
                         json_content['payload']['request_id'])

    def test_retrieve(self):

        instance = TestModel.objects.create(name="Test")

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'retrieve',
                    'pk': instance.id,
                    'request_id': 'client-request-id'
                }))
        expected = {
            'action': 'retrieve',
            'data': TestModelSerializer(instance).data,
            'errors': [],
            'response_status': 200,
            'request_id': 'client-request-id'
        }
        self.assertTrue(json_content['payload'] == expected)

    def test_retrieve_404(self):
        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message('testmodel', {
                'action': 'retrieve',
                'pk': 1,
                'request_id': 'client-request-id'
            }))
        expected = {
            'action': 'retrieve',
            'data': None,
            'errors': ['Not found.'],
            'response_status': 404,
            'request_id': 'client-request-id'
        }
        self.assertEqual(json_content['payload'], expected)

    def test_retrieve_invalid_pk_404(self):
        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'retrieve',
                    'pk': 'invalid-pk-value',
                    'request_id': 'client-request-id'
                }))
        expected = {
            'action': 'retrieve',
            'data': None,
            'errors': ['Not found.'],
            'response_status': 404,
            'request_id': 'client-request-id'
        }
        self.assertEqual(json_content['payload'], expected)

    def test_subscribe(self):

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                "testmodel", {
                    'action': 'subscribe',
                    'data': {
                        'action': 'create'
                    },
                    'request_id': 'client-request-id'
                }))

        expected_response = {
            'action': 'subscribe',
            'request_id': 'client-request-id',
            'data': {
                'action': 'create'
            },
            'errors': [],
            'response_status': 200
        }

        self.assertEqual(json_content['payload'], expected_response)

        # it should be on the create group
        instance = TestModel.objects.create(name='test-name')

        expected = {
            'action': 'create',
            'data': TestModelSerializer(instance).data,
            'model': 'tests.testmodel',
            'pk': instance.id
        }

        actual = self._get_next_message()

        self.assertEqual(expected, actual['payload'])

    def test_subscribe_failure(self):

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'subscribe',
                    'data': {},
                    'request_id': 'client-request-id'
                }))

        expected = {
            'action': 'subscribe',
            'data': None,
            'errors': ['action required'],
            'request_id': 'client-request-id',
            'response_status': 400
        }
        self.assertEqual(expected, json_content['payload'])

    def test_update(self):
        instance = TestModel.objects.create(name='some-test')

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'update',
                    'pk': instance.id,
                    'data': {
                        'name': 'some-value'
                    },
                    'request_id': 'client-request-id'
                }))

        instance.refresh_from_db()

        expected = {
            'action': 'update',
            'errors': [],
            'data': TestModelSerializer(instance).data,
            'response_status': 200,
            'request_id': 'client-request-id'
        }

        self.assertEqual(json_content['payload'], expected)

    def test_update_failure(self):
        instance = TestModel.objects.create(name='some-test')

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'update',
                    'pk': -1,
                    'data': {
                        'name': 'some-value'
                    },
                    'request_id': 'client-request-id'
                }))

        expected = {
            'data': None,
            'action': 'update',
            'errors': ['Not found.'],
            'response_status': 404,
            'request_id': 'client-request-id'
        }

        self.assertEqual(json_content['payload'], expected)

    def test_list_action(self):
        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'test_list',
                    'pk': None,
                    'data': {},
                    'request_id': 'client-request-id',
                }))

        expected = {
            'action': 'test_list',
            'errors': [],
            'data': 'some data',
            'response_status': 200,
            'request_id': 'client-request-id'
        }

        self.assertEqual(json_content['payload'], expected)

    def test_detail_action(self):
        instance = TestModel.objects.create(name='some-test')

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'test_detail',
                    'pk': instance.id,
                    'data': {},
                    'request_id': 'client-request-id'
                }))

        expected = {
            'action': 'test_detail',
            'errors': [],
            'data': instance.name,
            'response_status': 200,
            'request_id': 'client-request-id'
        }

        self.assertEqual(json_content['payload'], expected)

    def test_named_list_action(self):
        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'named_list',
                    'pk': None,
                    'data': {},
                    'request_id': 'client-request-id',
                }))

        expected = {
            'action': 'named_list',
            'errors': [],
            'data': 'some data',
            'response_status': 200,
            'request_id': 'client-request-id'
        }

        self.assertEqual(json_content['payload'], expected)

    def test_named_detail_action(self):
        instance = TestModel.objects.create(name='some-test')

        json_content = self._send_and_consume(
            'websocket.receive',
            self._build_message(
                'testmodel', {
                    'action': 'named_detail',
                    'pk': instance.id,
                    'data': {},
                    'request_id': 'client-request-id'
                }))

        expected = {
            'action': 'named_detail',
            'errors': [],
            'data': instance.name,
            'response_status': 200,
            'request_id': 'client-request-id'
        }

        self.assertEqual(json_content['payload'], expected)
Esempio n. 14
0
 def setUp(self):
     super().setUp()
     self.client = Client()
Esempio n. 15
0
class TestStreamConsumer(SocialhomeChannelTestCase):
    @classmethod
    def setUpTestData(cls):
        super().setUpTestData()
        cls.user = UserFactory()
        cls.content = ContentFactory()
        cls.content2 = ContentFactory()
        cls.child_content = ContentFactory(parent=cls.content)
        cls.tag = TagFactory()

    def setUp(self):
        super().setUp()
        self.client = Client()

    @patch.object(StreamConsumer, "__init__", return_value=None)
    @patch("socialhome.streams.consumers.PublicStream.get_queryset",
           return_value="spam")
    def test__get_base_qs(self, mock_qs, mock_consumer):
        consumer = StreamConsumer()
        consumer.kwargs = {"stream": "public"}
        self.assertEqual(consumer._get_base_qs(), "spam")

    @patch.object(StreamConsumer, "__init__", return_value=None)
    def test__get_stream_class(self, mock_consumer):
        consumer = StreamConsumer()
        with patch.object(consumer,
                          "_get_stream_info",
                          return_value=("public", None)):
            self.assertEqual(consumer._get_stream_class(), PublicStream)
        with patch.object(consumer,
                          "_get_stream_info",
                          return_value=("followed", None)):
            self.assertEqual(consumer._get_stream_class(), FollowedStream)
        with patch.object(consumer,
                          "_get_stream_info",
                          return_value=("tag", None)):
            self.assertEqual(consumer._get_stream_class(), TagStream)

    @patch.object(StreamConsumer, "__init__", return_value=None)
    def test__get_stream_info(self, mock_consumer):
        consumer = StreamConsumer()
        consumer.kwargs = {"stream": "spam"}
        self.assertEqual(consumer._get_stream_info(), ("spam", None))
        consumer.kwargs = {"stream": "spam__eggs"}
        self.assertEqual(consumer._get_stream_info(), ("spam", "eggs"))

    @patch.object(StreamConsumer, "__init__", return_value=None)
    def test__get_stream_instance(self, mock_consumer):
        consumer = StreamConsumer()
        consumer.kwargs = {"stream": "public"}
        instance = consumer._get_stream_instance()
        self.assertTrue(isinstance(instance, PublicStream))
        consumer.kwargs = {"stream": "followed"}
        consumer.message = Mock(user=self.user)
        instance = consumer._get_stream_instance()
        self.assertTrue(isinstance(instance, FollowedStream))
        self.assertTrue(instance.user, self.user)
        consumer.kwargs = {"stream": "tag__%s" % self.tag.id}
        instance = consumer._get_stream_instance()
        self.assertTrue(isinstance(instance, TagStream))
        self.assertEqual(instance.tag, self.tag)

    @patch.object(StreamConsumer, "__init__", return_value=None)
    @patch("socialhome.streams.consumers.PublicStream.get_content",
           return_value="spam")
    def test__get_stream_qs(self, mock_qs, mock_consumer):
        consumer = StreamConsumer()
        consumer.kwargs = {"stream": "public"}
        self.assertEqual(consumer._get_stream_qs(), "spam")

    def test_receive_load_content_sends_reply_content(self):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path":
                "/ch/streams/public/",
                "text":
                '{"action": "load_content", "ids": [%s]}' % self.content.id,
            },
        )
        receive = self.client.receive()
        text = json.loads(receive["text"])
        self.assertEqual(text["event"], "content")
        self.assertEqual(text["placement"], "prepended")
        self.assertEqual(text["contents"],
                         [self.content.dict_for_view(AnonymousUser())])

    def test_receive_load_more_sends_more_content(self):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path":
                "/ch/streams/public/",
                "text":
                '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        receive = self.client.receive()
        text = json.loads(receive["text"])
        self.assertEqual(text["event"], "content")
        self.assertEqual(text["placement"], "appended")
        self.assertEqual(text["contents"],
                         [self.content.dict_for_view(AnonymousUser())])

    def test_receive_load_children_sends_reply_content(self):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path":
                "/ch/streams/public/",
                "text":
                '{"action": "load_children", "content_id": %s}' %
                self.content.id,
            },
        )
        receive = self.client.receive()
        text = json.loads(receive["text"])
        self.assertEqual(text["event"], "content")
        self.assertEqual(text["placement"], "children")
        self.assertEqual(text["parent_id"], self.content.id)
        self.assertEqual(text["contents"],
                         [self.child_content.dict_for_view(AnonymousUser())])

    @patch("socialhome.streams.consumers.Content.objects.public",
           return_value=Content.objects.none())
    @patch("socialhome.streams.consumers.Content.objects.tag",
           return_value=Content.objects.none())
    @patch("socialhome.streams.consumers.Content.objects.profile_by_id",
           return_value=Content.objects.none())
    @patch("socialhome.streams.consumers.Content.objects.profile_pinned",
           return_value=Content.objects.none())
    @patch("socialhome.streams.consumers.Content.objects.followed",
           return_value=Content.objects.none())
    def test_get_stream_qs_per_stream(self, mock_followed, mock_pinned,
                                      mock_profile, mock_tag, mock_public):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path":
                "/ch/streams/public/",
                "text":
                '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        mock_public.assert_called_once_with()
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path":
                "/ch/streams/tag__%s_%s/" % (self.tag.id, self.tag.name),
                "text":
                '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        self.assertEqual(mock_tag.call_count, 1)
        self.assertEqual(mock_tag.call_args[0][0], self.tag)
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path":
                "/ch/streams/profile__1234/",
                "text":
                '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        self.assertEqual(mock_pinned.call_count, 1)
        self.assertEqual(mock_pinned.call_args[0][0], "1234")
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path":
                "/ch/streams/profile_all__1234/",
                "text":
                '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        self.assertEqual(mock_profile.call_count, 1)
        self.assertEqual(mock_profile.call_args[0][0], "1234")
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path":
                "/ch/streams/followed__foobar/",
                "text":
                '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        self.assertEqual(mock_followed.call_count, 1)
Esempio n. 16
0
 def setUp(self):
     super(TestStreamConsumerReceive, self).setUp()
     self.client = Client()
Esempio n. 17
0
    def test_simple_as_route_method(self):

        class WebsocketConsumer(websockets.WebsocketConsumer):

            def connect(self, message, **kwargs):
                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 = Client()

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

            client.send_and_consume('websocket.connect', {'path': '/path/2', 'order': 'next'})
            self.assertEqual(client.receive(), {'text': 'next'})
Esempio n. 18
0
class TestStreamConsumerReceive(ChannelTestCase):
    @classmethod
    def setUpTestData(cls):
        super(TestStreamConsumerReceive, cls).setUpTestData()
        cls.content = ContentFactory()
        cls.content2 = ContentFactory()

    def setUp(self):
        super(TestStreamConsumerReceive, self).setUp()
        self.client = Client()

    def test_receive_load_content_sends_reply_content(self):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/public/",
                "text": '{"action": "load_content", "ids": [%s]}' % self.content.id,
            },
        )
        receive = self.client.receive()
        text = json.loads(receive["text"])
        self.assertEqual(text["event"], "content")
        self.assertEqual(text["placement"], "prepended")
        self.assertEqual(text["contents"], [
            {
                "id": self.content.id,
                "guid": self.content.guid,
                "author": self.content.author.id,
                "author_image": self.content.author.safer_image_url_small,
                "author_name": self.content.author.handle,
                "rendered": self.content.rendered,
                "humanized_timestamp": self.content.humanized_timestamp,
                "formatted_timestamp": self.content.formatted_timestamp,
            }
        ])

    def test_receive_load_more_sends_more_content(self):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/public/",
                "text": '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        receive = self.client.receive()
        text = json.loads(receive["text"])
        self.assertEqual(text["event"], "content")
        self.assertEqual(text["placement"], "appended")
        self.assertEqual(text["contents"], [
            {
                "id": self.content.id,
                "guid": self.content.guid,
                "author": self.content.author.id,
                "author_image": self.content.author.safer_image_url_small,
                "author_name": self.content.author.handle,
                "rendered": self.content.rendered,
                "humanized_timestamp": self.content.humanized_timestamp,
                "formatted_timestamp": self.content.formatted_timestamp,
            }
        ])

    @patch("socialhome.streams.consumers.Content.objects.public", return_value=Content.objects.none())
    @patch("socialhome.streams.consumers.Content.objects.tags", return_value=Content.objects.none())
    @patch("socialhome.streams.consumers.Content.objects.profile", return_value=Content.objects.none())
    def test_get_stream_qs_per_stream(self, mock_profile, mock_tags, mock_public):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/public/",
                "text": '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        mock_public.assert_called_once_with()
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/tags__foobar/",
                "text": '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        self.assertEqual(mock_tags.call_count, 1)
        self.assertEqual(mock_tags.call_args[0][0], "foobar")
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/profile__1234/",
                "text": '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        self.assertEqual(mock_profile.call_count, 1)
        self.assertEqual(mock_profile.call_args[0][0], "1234")
Esempio n. 19
0
    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+)'),
                route_class(MyWebsocketConsumer),
        ]):
            client = Client()

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

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

            client.send_and_consume('websocket.disconnect',
                                    {'path': '/path/1'})
            self.assertEqual(
                client.receive(), {
                    "text":
                    json.dumps({
                        "stream": "mystream",
                        "payload": {
                            "id": "1"
                        },
                    })
                })
Esempio n. 20
0
    def test_simple_as_route_method(self):
        class WebsocketConsumer(websockets.WebsocketConsumer):
            def connect(self, message, **kwargs):
                self.send(text=message.get('order'))

        routes = [
            WebsocketConsumer.as_route(attrs={'slight_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 = Client()

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

            client.send_and_consume('websocket.connect', {
                'path': '/path/2',
                'order': 'next'
            })
            self.assertEqual(client.receive(), {'text': 'next'})
Esempio n. 21
0
class TestStreamConsumerReceive(ChannelTestCase):
    maxDiff = None

    @classmethod
    def setUpTestData(cls):
        super(TestStreamConsumerReceive, cls).setUpTestData()
        cls.content = ContentFactory()
        cls.content2 = ContentFactory()
        cls.child_content = ContentFactory(parent=cls.content)
        cls.tag = TagFactory()

    def setUp(self):
        super(TestStreamConsumerReceive, self).setUp()
        self.client = Client()

    def test_receive_load_content_sends_reply_content(self):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/public/",
                "text": '{"action": "load_content", "ids": [%s]}' % self.content.id,
            },
        )
        receive = self.client.receive()
        text = json.loads(receive["text"])
        self.assertEqual(text["event"], "content")
        self.assertEqual(text["placement"], "prepended")
        self.assertEqual(text["contents"], [self.content.dict_for_view(AnonymousUser())])

    def test_receive_load_more_sends_more_content(self):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/public/",
                "text": '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        receive = self.client.receive()
        text = json.loads(receive["text"])
        self.assertEqual(text["event"], "content")
        self.assertEqual(text["placement"], "appended")
        self.assertEqual(text["contents"], [self.content.dict_for_view(AnonymousUser())])

    def test_receive_load_children_sends_reply_content(self):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/public/",
                "text": '{"action": "load_children", "content_id": %s}' % self.content.id,
            },
        )
        receive = self.client.receive()
        text = json.loads(receive["text"])
        self.assertEqual(text["event"], "content")
        self.assertEqual(text["placement"], "children")
        self.assertEqual(text["parent_id"], self.content.id)
        self.assertEqual(text["contents"], [self.child_content.dict_for_view(AnonymousUser())])

    @patch("socialhome.streams.consumers.Content.objects.public", return_value=Content.objects.none())
    @patch("socialhome.streams.consumers.Content.objects.tag", return_value=Content.objects.none())
    @patch("socialhome.streams.consumers.Content.objects.profile_by_id", return_value=Content.objects.none())
    @patch("socialhome.streams.consumers.Content.objects.profile_pinned", return_value=Content.objects.none())
    @patch("socialhome.streams.consumers.Content.objects.followed", return_value=Content.objects.none())
    def test_get_stream_qs_per_stream(self, mock_followed, mock_pinned, mock_profile, mock_tag, mock_public):
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/public/",
                "text": '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        mock_public.assert_called_once_with()
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/tag__%s_%s/" % (self.tag.id, self.tag.name),
                "text": '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        self.assertEqual(mock_tag.call_count, 1)
        self.assertEqual(mock_tag.call_args[0][0], self.tag)
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/profile__1234/",
                "text": '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        self.assertEqual(mock_pinned.call_count, 1)
        self.assertEqual(mock_pinned.call_args[0][0], "1234")
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/profile_all__1234/",
                "text": '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        self.assertEqual(mock_profile.call_count, 1)
        self.assertEqual(mock_profile.call_args[0][0], "1234")
        self.client.send_and_consume(
            "websocket.receive",
            {
                "path": "/ch/streams/followed__foobar/",
                "text": '{"action": "load_more", "last_id": %s}' % self.content2.id,
            },
        )
        self.assertEqual(mock_followed.call_count, 1)