def test_Session(self): @MyJsonRpcWebsocketConsumerTest.rpc_method() def ping_set_session2(**kwargs): original_message = kwargs["original_message"] original_message.channel_session["test"] = True return "pong_set_session2" @MyJsonRpcWebsocketConsumerTest.rpc_method() def ping_get_session2(**kwargs): original_message = kwargs["original_message"] self.assertNotIn("test", original_message.channel_session) return "pong_get_session2" client = HttpClient() client.send_and_consume( u'websocket.receive', text= '{"id":1, "jsonrpc":"2.0", "method":"ping_set_session2", "params":{}}' ) msg = client.receive() self.assertEqual(msg['result'], "pong_set_session2") client2 = HttpClient() client2.send_and_consume( u'websocket.receive', text= '{"id":1, "jsonrpc":"2.0", "method":"ping_get_session2", "params":{}}' ) msg = client2.receive() self.assertEqual(msg['result'], "pong_get_session2")
class MockUser: def __init__(self,name): self.client=HttpClient() User.objects.create_user(username=name, email='*****@*****.**',password='******') self.client.force_login(User.objects.get(username=name)) self.client.send_and_consume('websocket.connect',path='/')
def test_demultiplexer_without_payload_and_steam(self): class Demultiplexer(WebsocketDemultiplexer): mapping = { 'users': 'binding.users', } groups = ['inbound'] with apply_routes([Demultiplexer.as_route(path='/')]): client = HttpClient() client.send_and_consume('websocket.connect', path='/') with self.assertRaises(ValueError) as value_error: client.send_and_consume('websocket.receive', path='/', text={ 'nostream': 'users', 'payload': 'test', }) self.assertIn('no channel/payload key', value_error.exception.args[0]) message = client.get_next_message('binding.users') self.assertIsNone(message) with self.assertRaises(ValueError) as value_error: client.send_and_consume('websocket.receive', path='/', text={ 'stream': 'users', }) self.assertIn('no channel/payload key', value_error.exception.args[0]) message = client.get_next_message('binding.users') self.assertIsNone(message)
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='******', email='*****@*****.**') 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)
def test_id_on_good_request(self): # Test that parsing a ping request works client = HttpClient() client.send_and_consume( u'websocket.receive', text='{"id":52, "jsonrpc":"2.0", "method":"ping", "params":{}}') msg = client.receive() self.assertEqual(msg['id'], 52)
def setUp(self): self.alice=SimpleNamespace() self.alice.client=HttpClient() self.alice.user=User.objects.create_user(username='******', email='*****@*****.**',password='******') self.alice.client.force_login(self.alice.user) self.eve=SimpleNamespace() self.eve.client=HttpClient()
def test_notification(self): # Test that parsing a bad request works client = HttpClient() client.send_and_consume( u'websocket.receive', text='{"jsonrpc":"2.0", "method":"a_notif", "params":{}}') self.assertEqual(client.receive(), None)
def test_parsing_with_good_request(self): # Test that parsing a ping request works client = HttpClient() client.send_and_consume( u'websocket.receive', text='{"id":1, "jsonrpc":"2.0", "method":"ping", "params":[false]}' ) msg = client.receive() self.assertEquals(msg['result'], "pong")
def test_list_consumers(self): # create object for i in range(20): User.objects.create_user(username='******' + str(i), email='*****@*****.**') # 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'], '*****@*****.**') self.assertEqual(res[0]['is_active'], True)
def test_create_appointment_celery_task_send_notification_to_user(self): self._create_appointment() client = HttpClient() client.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.simple_user) ) msg = client.receive() self.assertEquals(msg.get('action'), 'appointment_timeout_expired') self.assertIn('appointment', msg.get('message'))
def test_websocket_param_in_decorator_for_notification(self): @MyJsonRpcWebsocketConsumerTest.rpc_notification(websocket=False) def ping(): return "pong" client = HttpClient() client.send_and_consume(u'websocket.receive', text='{"jsonrpc":"2.0", "method":"ping", ' '"params":[]}') msg = client.receive() self.assertEqual(msg, None)
def test_create_appointment_notification_expired(self, *args): c, r, appointment = self._create_appointment() user_notif = UserNotification.objects.get(user=self.clinic_admin1) user_notif.expired = F('expired') - timedelta(seconds=58) user_notif.save(update_fields=['expired', ]) time.sleep(2) client = HttpClient() client.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin1) ) self.assertIsNone(client.receive())
def test_websocket_param_in_decorator_for_method(self): @MyJsonRpcWebsocketConsumerTest.rpc_method(websocket=False) def ping(): return "pong" client = HttpClient() client.send_and_consume( u'websocket.receive', text='{"id":1, "jsonrpc":"2.0", "method":"ping", ' '"params":[]}') msg = client.receive() self.assertEqual(msg['error']['message'], "Method Not Found")
def test_admin_suggested_another_time_patient_receive_notification( self, *args): c, r, appointment = self._create_appointment() self._suggest(appointment, self.clinic_admin1) client = HttpClient() client.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.simple_user) ) msg = client.receive() self.assertEquals(msg.get('action'), 'appointment_clinic_suggested') self.assertTrue(msg.get('message'))
def test_create_appointment_admin_receive_notification_after_connect( self, *args): self._create_appointment() time.sleep(1) client = HttpClient() client.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin1) ) msg = client.receive() self.assertEquals(msg.get('action'), 'appointment_created') self.assertTrue(msg.get('message'))
def test_create_appointment_celery_task_send_notification_to_admin(self): client = HttpClient() client.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin1) ) self._create_appointment() msg = client.receive() # first message about creating request msg = client.receive() self.assertEquals(msg.get('action'), 'appointment_timeout_expired') self.assertIn('appointment_event', msg.get('message'))
def test_method(self): @MyJsonRpcWebsocketConsumerTest.rpc_method() def ping2(): return "pong2" client = HttpClient() client.send_and_consume( u'websocket.receive', text='{"id":1, "jsonrpc":"2.0", "method":"ping2", "params":{}}') msg = client.receive() self.assertEqual(msg['result'], "pong2")
def test_kwargs_not_there(self): @MyJsonRpcWebsocketConsumerTest.rpc_method() def ping(): return True client = HttpClient() # we send a notification to the server client.send_and_consume( u'websocket.receive', text='{"id":1, "jsonrpc":"2.0", "method":"ping", "params":[]}') msg = client.receive() self.assertEqual(msg["result"], True)
def test_error_on_notification_frame(self): @MyJsonRpcWebsocketConsumerTest.rpc_method() def ping(): return True client = HttpClient() # we send a notification to the server client.send_and_consume( u'websocket.receive', text='{"jsonrpc":"2.0", "method":"dwqwdq", "params":[]}') msg = client.receive() self.assertEqual(msg, None)
def test_one_admin_suggested_others_receive_notification_about_inactive( self, *args): client = HttpClient() client.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin2) ) c, r, appointment = self._create_appointment() self._suggest(appointment, self.clinic_admin1) msg = client.receive() # first message about creating msg = client.receive() self.assertEquals(msg.get('action'), 'appointment_inactive') self.assertTrue(msg.get('message'))
def test_inbound_delete(self): user = User.objects.create(username='******', email='*****@*****.**') 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())
def setUp(self): self.test_user = User.objects.create(username='******') self.client = HttpClient() # Authenticate user self.client.force_login(user=self.test_user) self.test_player = Player.objects.create(user=self.test_user, username='******') self.test_game_player = GamePlayer.objects.get( user_acct=self.test_player) self.test_team = Team.objects.create(name="TESTER", description='LOL', captain=self.test_game_player) self.endpoint_path = '/%s/sockets/status/TESTER/' % GAME_NAME
def test_update_mixin(self): # create object obj = User.objects.create_user(username='******', email='*****@*****.**') # create client client = HttpClient() data = {'username': '******'} with apply_routes([ UpdateConsumers.as_routes(model=User, path='/(?P<pk>\d+)/?', channel_name='test') ]): client.send_and_consume('websocket.connect', {'path': '/{}'.format(obj.pk)}) client.send_and_consume( 'websocket.receive', { 'path': '/{}'.format(obj.pk), 'action': 'update', 'data': json.dumps(data) }) client.consume('test') user = User.objects.filter(pk=obj.pk).first() self.assertTrue(user) self.assertEqual(user.username, 'new_name')
def test_demultiplexer(self): class Demultiplexer(WebsocketDemultiplexer): mapping = { 'users': 'binding.users', } groups = ['inbound'] with apply_routes([Demultiplexer.as_route(path='/')]): client = HttpClient() client.send_and_consume('websocket.connect', path='/') # assert in group Group('inbound').send({'text': json.dumps({'test': 'yes'})}, immediately=True) self.assertEqual(client.receive(), {'test': 'yes'}) # assert that demultiplexer stream message client.send_and_consume('websocket.receive', path='/', text={ 'stream': 'users', 'payload': { 'test': 'yes' } }) message = client.get_next_message('binding.users') self.assertIsNotNone(message) self.assertEqual(message.content['test'], 'yes')
def test_after_reopen_clinic_admins_receive_notification(self, *args): c, r, appointment = self._create_appointment() AppointmentActions(appointment).timeout() self._reopen(appointment.pk) client = HttpClient() client.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin1) ) msg = client.receive() self.assertEquals(msg.get('action'), 'appointment_created') self.assertTrue(msg.get('message', {}).get('appointment_event'))
def test_appointment_confirmed_push_notification_should_sent_to_user( self, *args): client = HttpClient() client.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.simple_user) ) with mock.patch('clinicapp.pkg.notifications.messenger.Messenger.' 'send_push_notifications') as push_call: c, r, appointment = self._create_appointment() c, r, event = self._accept(appointment, self.clinic_admin1) AppointmentActions(event.appointment).confirm(event) self.assertEquals(push_call.call_count, 1) self.assertEquals(push_call.call_args[0][0], self.simple_user)
def test_original_message_position_safe(self): @MyJsonRpcWebsocketConsumerTest.rpc_method() def ping_set_session(name, value, **kwargs): original_message = kwargs["original_message"] original_message.channel_session["test"] = True return ["pong_set_session", value, name] @MyJsonRpcWebsocketConsumerTest.rpc_method() def ping_get_session(value2, name2, **kwargs): original_message = kwargs["original_message"] self.assertEqual(original_message.channel_session["test"], True) return ["pong_get_session", value2, name2] client = HttpClient() client.send_and_consume( u'websocket.receive', text='{"id":1, "jsonrpc":"2.0", "method":"ping_set_session", ' '"params":["name_of_function", "value_of_function"]}') msg = client.receive() self.assertEqual( msg['result'], ["pong_set_session", "value_of_function", "name_of_function"]) client.send_and_consume( u'websocket.receive', text='{"id":1, "jsonrpc":"2.0", "method":"ping_get_session", ' '"params":{"name2": "name2_of_function", "value2": "value2_of_function"}}' ) msg = client.receive() self.assertEqual( msg['result'], ["pong_get_session", "value2_of_function", "name2_of_function"])
def test_user_not_payment_admin_receive_appointment_canceled_after_timeout( self, *args): client = HttpClient() client.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin1) ) c, r, appointment = self._create_appointment() self._accept(appointment, self.clinic_admin1) msg = client.receive() # first message about creating msg = client.receive() self.assertEquals(msg.get('action'), 'appointment_canceled') self.assertIn('appointment_event', msg.get('message'))
def test_inbound_delete(self): user = User.objects.create(username='******', email='*****@*****.**') 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())
def test_error_on_rpc_call(self): @MyJsonRpcWebsocketConsumerTest.rpc_method() def ping_with_error(): raise Exception("pong_with_error") # Test that parsing a ping request works client = HttpClient() client.send_and_consume( u'websocket.receive', text= '{"id":1, "jsonrpc":"2.0", "method":"ping_with_error", "params":{}}' ) msg = client.receive() self.assertEqual(msg['error']['message'], u'pong_with_error')
def test_parsing_with_bad_request(self): # Test that parsing a bad request works client = HttpClient() client.send_and_consume( u'websocket.receive', text='{"id":"2", "method":"ping2", "params":{}}') self.assertEqual( client.receive()['error'], { u'code': JsonRpcConsumerTest.INVALID_REQUEST, u'message': JsonRpcConsumerTest.errors[JsonRpcConsumerTest.INVALID_REQUEST] })
def test_user_accept_suggestion_admin_receive_notification(self, *args): c, r, appointment = self._create_appointment() c, r, event = self._suggest(appointment, self.clinic_admin1) suggestion_id = r.get('suggestions')[0].get('id') self._accept_suggestion(event, suggestion_id) client = HttpClient() client.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin1) ) msg = client.receive() # first message about creating msg = client.receive() self.assertEquals(msg.get('action'), 'appointment_user_accept_suggestion') self.assertTrue(msg.get('message'))
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='******', email='*****@*****.**') consumer_finished.send(sender=None) with apply_routes([route('test', TestBinding.consumer)]): client = HttpClient() client.join_group('users2') user.username = '******' 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'], '*****@*****.**') 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)
def test_model_sub_with_fields(self): # define consumers routes = ModelSubscribeConsumers.as_routes(model=User, serializer_kwargs={'fields': ['username']}) # create client client = HttpClient() with apply_routes([routes]): # subscribe for Models changes client.send_and_consume(u'websocket.connect') # create object User.objects.create_user(username='******', email='*****@*****.**') res = json.loads(client.receive()['text']) self.assertEqual(res['action'], 'created') self.assertEqual(res['data']['username'], 'test') self.assertNotIn('is_active', res['data']) self.assertNotIn('email', res['data'])
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"}, })
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='******', email='*****@*****.**') with apply_routes([routes]): # subscribe for Models changes client.send_and_consume(u'websocket.connect') # change object user.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'], '*****@*****.**') # create new one to_del = User.objects.create_user(username='******', email='*****@*****.**') res = json.loads(client.receive()['text']) self.assertEqual(res['action'], 'created') self.assertEqual(res['data']['username'], 'test2') self.assertEqual(res['data']['email'], '*****@*****.**') # 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'], '*****@*****.**')
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()
def test_delete_mixin(self): # create object obj = User.objects.create_user(username='******', email='*****@*****.**') # create client client = HttpClient() with apply_routes([DeleteConsumers.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': 'delete'}) client.consume('test') self.assertFalse(User.objects.filter(pk=obj.pk).exists())
def test_create_mixin(self): # create client client = HttpClient() data = {'username': '******', 'email': '*****@*****.**'} with apply_routes([CreateConsumers.as_routes(model=User, path='/', channel_name='test')]): client.send_and_consume(u'websocket.connect', {'path': '/'}) client.send_and_consume(u'websocket.receive', {'path': '/', 'action': 'create', 'data': json.dumps(data)}) client.consume(u'test') self.assertTrue(User.objects.filter(username='******', email='*****@*****.**').exists())
def test_dynamic_channels_names(self): class Test(Consumers): channel_name = 'test1' @consumer def test(self, message): return self.channel_name test = Test.as_routes() test_2 = Test.as_routes(channel_name='test') client = HttpClient() with apply_routes([test]): client.send_and_consume(u'websocket.receive') with apply_routes([test_2]): client.send_and_consume(u'websocket.receive') channel_layer = channel_layers[DEFAULT_CHANNEL_LAYER] self.assertEqual(len(channel_layer._channels), 3, channel_layer._channels.keys()) self.assertIn('test', channel_layer._channels.keys())
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='******', email='*****@*****.**') 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'], '*****@*****.**') self.assertEqual(data['is_staff'], False) # check that nothing happened self.assertIsNone(client.receive())
def test_get_mixin(self): # create object obj = User.objects.create_user(username='******', email='*****@*****.**') # 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'], '*****@*****.**') self.assertEqual(res['is_active'], True)
def test_object_sub_with_fields(self): # create object for subscribe sub_object = User.objects.create_user(username='******', email='*****@*****.**') # 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.email = '*****@*****.**' 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 = '******' 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 = '******' 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 = '*****@*****.**' sub_object.save(update_fields=['email']) # check that nothing happened self.assertIsNone(client.receive())
def test_list_consumers(self): # create object for i in range(20): User.objects.create_user(username='******' + str(i), email='*****@*****.**') # 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'], '*****@*****.**') self.assertEqual(res[0]['is_active'], True)
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'})
def test_update_mixin(self): # create object obj = User.objects.create_user(username='******', email='*****@*****.**') # create client client = HttpClient() data = {'username': '******'} with apply_routes([UpdateConsumers.as_routes(model=User, path='/(?P<pk>\d+)/?', channel_name='test')]): client.send_and_consume('websocket.connect', {'path': '/{}'.format(obj.pk)}) client.send_and_consume('websocket.receive', {'path': '/{}'.format(obj.pk), 'action': 'update', 'data': json.dumps(data)}) client.consume('test') user = User.objects.filter(pk=obj.pk).first() self.assertTrue(user) self.assertEqual(user.username, 'new_name')
def test_inbound_create(self): self.assertEqual(User.objects.all().count(), 0) class Demultiplexer(WebsocketDemultiplexer): mapping = { 'users': 'binding.users', } groups = ['inbound'] class UserBinding(WebsocketBinding): model = User stream = 'users' fields = ['username', 'email', 'password', 'last_name'] @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': CREATE, 'data': {'username': '******', 'email': 'test@user_steam.com'}} }) # our Demultiplexer route message to the inbound consumer, so call Demultiplexer consumer client.consume('binding.users') self.assertEqual(User.objects.all().count(), 1) user = User.objects.all().first() self.assertEqual(user.username, 'test_inbound') self.assertEqual(user.email, 'test@user_steam.com') self.assertIsNone(client.receive())
def test_demultiplexer(self): class Demultiplexer(WebsocketDemultiplexer): mapping = { 'users': 'binding.users', } groups = ['inbound'] with apply_routes([Demultiplexer.as_route(path='/')]): client = HttpClient() client.send_and_consume('websocket.connect', path='/') # assert in group Group('inbound').send({'text': json.dumps({'test': 'yes'})}, immediately=True) self.assertEqual(client.receive(), {'test': 'yes'}) # assert that demultiplexer stream message client.send_and_consume('websocket.receive', path='/', text={'stream': 'users', 'payload': {'test': 'yes'}}) message = client.get_next_message('binding.users') self.assertIsNotNone(message) self.assertEqual(message.content['test'], 'yes')
def test_object_sub(self): # create object for subscribe sub_object = User.objects.create_user(username='******', email='*****@*****.**') # create object without subscribers just_object = User.objects.create_user(username='******', email='*****@*****.**') # 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.email = '*****@*****.**' 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'], '*****@*****.**') self.assertEqual(res['data']['is_staff'], False) # change second object just_object.email = '*****@*****.**' 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'], '*****@*****.**') self.assertEqual(res['data']['is_staff'], False)
def test_demultiplexer_with_wrong_payload(self): class Demultiplexer(WebsocketDemultiplexer): mapping = { 'users': 'binding.users', } groups = ['inbound'] with apply_routes([Demultiplexer.as_route(path='/')]): client = HttpClient() client.send_and_consume('websocket.connect', path='/') with self.assertRaises(ValueError) as value_error: client.send_and_consume('websocket.receive', path='/', text={ 'stream': 'users', 'payload': 'test', }) self.assertEqual(value_error.exception.args[0], 'Multiplexed frame payload is not a dict') message = client.get_next_message('binding.users') self.assertIsNone(message)
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())
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')
def test_crud_consumers(self): # create object for i in range(20): User.objects.create_user(username='******' + str(i), email='*****@*****.**') # 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'], '*****@*****.**') 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': '******'} 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')
def test_inbound_update(self): user = User.objects.create(username='******', email='*****@*****.**') 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': UPDATE, 'pk': user.pk, 'data': {'username': '******'}} }) # our Demultiplexer route message to the inbound consumer, so call Demultiplexer consumer client.consume('binding.users') user = User.objects.get(pk=user.pk) self.assertEqual(user.username, 'test_inbound') self.assertEqual(user.email, '*****@*****.**') # trying change field that not in binding fields client.send_and_consume('websocket.receive', path='/', text={ 'stream': 'users', 'payload': {'action': UPDATE, 'pk': user.pk, 'data': {'email': '*****@*****.**'}} }) client.consume('binding.users') user = User.objects.get(pk=user.pk) self.assertEqual(user.username, 'test_inbound') self.assertEqual(user.email, '*****@*****.**')