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")
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_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_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_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_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_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_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_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_inbound_notifications(self): @MyJsonRpcWebsocketConsumerTest.rpc_notification() def notif1(params, **kwargs): self.assertEqual(params, {"payload": True}) @MyJsonRpcWebsocketConsumerTest.rpc_notification('notif.notif2') def notif2(params, **kwargs): self.assertEqual(params, {"payload": 12345}) client = HttpClient() # we send a notification to the server client.send_and_consume( u'websocket.receive', text= '{"jsonrpc":"2.0", "method":"notif1", "params":[{"payload": true}]}' ) msg = client.receive() self.assertEqual(msg, None) # we test with method rewriting client.send_and_consume( u'websocket.receive', text= '{"jsonrpc":"2.0", "method":"notif.notif2", "params":[{"payload": 12345}]}' ) self.assertEqual(msg, None)
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_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_trigger_outbound_create_non_auto_pk(self): class TestBinding(WebsocketBinding): model = models.TestUUIDModel stream = 'test' fields = ['name'] @classmethod def group_names(cls, instance): return ["testuuidmodels"] def has_permission(self, user, action, pk): return True client = HttpClient() client.join_group('testuuidmodels') instance = models.TestUUIDModel.objects.create(name='testname') received = client.receive() self.assertTrue('payload' in received) self.assertTrue('action' in received['payload']) self.assertTrue('data' in received['payload']) self.assertTrue('name' in received['payload']['data']) self.assertTrue('model' in received['payload']) self.assertTrue('pk' in received['payload']) self.assertEqual(received['payload']['action'], 'create') self.assertEqual(received['payload']['model'], 'tests.testuuidmodel') self.assertEqual(received['payload']['pk'], str(instance.pk)) self.assertEqual(received['payload']['data']['name'], 'testname') received = client.receive() self.assertIsNone(received)
def test_inbound_delete(self): user = User.objects.create(username='******', email='*****@*****.**') class UserBinding(WebsocketBinding): model = User stream = 'users' fields = ['username', ] @classmethod def group_names(cls, instance): return ['users_outbound'] def has_permission(self, user, action, pk): return True class Demultiplexer(WebsocketDemultiplexer): consumers = { 'users': UserBinding.consumer, } groups = ['inbound'] with apply_routes([Demultiplexer.as_route(path='/')]): 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} }) self.assertIsNone(User.objects.filter(pk=user.pk).first()) 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_custom_json_encoder(self): some_date = datetime.utcnow() @MyJsonRpcWebsocketConsumerTest.rpc_method() def test_method(): return {'date': some_date} client = HttpClient() try: client.send_and_consume( u'websocket.receive', text= '{"id":1, "jsonrpc":"2.0", "method":"test_method", "params":{}}' ) self.fail('Looks like test does not work') except TypeError: pass @DjangoJsonRpcWebsocketConsumerTest.rpc_method() def test_method1(): return {'date': some_date} client.send_and_consume( u'websocket.receive', text= '{"id":1, "jsonrpc":"2.0", "method":"test_method1", "params":{}}', path='/django/') msg = client.receive() self.assertEqual(msg['result'], {u'date': some_date.isoformat()[:-3]})
def __init__(self, name): self.client = HttpClient() self.user = User.objects.create_user(username=name, email='*****@*****.**', password='******') self.user.save() self.client.force_login(self.user) self.client.send_and_consume('websocket.connect', path='/')
def test_connect_failed(self): acc, user, device = self.init_db_and_get_data() device.dKey = app_auth_tools.generate_aes_key() device.save() client = HttpClient() path, msgs = self.connect_websocket_return_code( client, acc.api_hostname, device.identifer) self.assertEqual(msgs[0], {'close': True})
def test_create_appointment_admins_received_notification(self, *args): client1 = HttpClient() client1.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin1) ) client2 = HttpClient() client2.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin2) ) self._create_appointment() msg1 = client1.receive() msg2 = client2.receive() self.assertEquals(msg1.get('action'), 'appointment_created') self.assertEquals(msg2.get('action'), 'appointment_created') self.assertTrue(msg1.get('message'))
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_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 test_websockets(self): client = HttpClient() wf_path = '/workflow/' + str(self.wf_id) # cannot connect to an invalid workflow ID with self.assertRaises(AssertionError): client.send_and_consume('websocket.connect', path='/workflow/999999') self.assertIsNone(client.receive()) # can connect to valid workflow ID client.send_and_consume('websocket.connect', path=wf_path) self.assertIsNone(client.receive()) # send message ws_send_workflow_update(self.workflow, {'foo': 42}) self.assertEqual(client.receive(), {'foo': 42}) # add another client to same workflow, test receive client2 = HttpClient() client2.send_and_consume('websocket.connect', path=wf_path) self.assertIsNone(client2.receive()) ws_send_workflow_update(self.workflow, {'bar': 42}) self.assertEqual(client.receive(), {'bar': 42}) self.assertEqual(client2.receive(), {'bar': 42}) # remove client from workflow, test no longer receives client2.send_and_consume('websocket.disconnect', path=wf_path) self.assertIsNone(client2.receive()) ws_send_workflow_update(self.workflow, {'baz': 42}) self.assertEqual(client.receive(), {'baz': 42}) self.assertIsNone(client2.receive()) # test that utility functions send the right messages ws_client_rerender_workflow(self.workflow) self.assertEqual(client.receive(), {'type': 'reload-workflow'}) ws_client_wf_module_status(self.wf_module, 'busy') self.assertEqual(client.receive(), { 'type': 'wfmodule-status', 'id': self.wf_module.id, 'status': 'busy' })
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_reopen_appointment_new_clinic_receive_notification(self, *args): client1 = HttpClient() client1.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin1) ) client2 = HttpClient() client2.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(self.clinic_admin2) ) c, r, appointment = self._create_appointment() client1.receive() # first message about creating client2.receive() # first message about creating self._reject(appointment, self.clinic_admin1) self._reject(appointment, self.clinic_admin2) AppointmentActions(appointment).timeout() admin = UserRecipe.make(email='*****@*****.**', is_active=True) admin.groups.add(GroupService.get_clinics_admin()) clinic = ClinicRecipe.make(admin=admin, location=self.clinic_point1, status=ClinicState.Approved.value) clinic.treatments.add(self.treatment) client3 = HttpClient() client3.send_and_consume( "websocket.connect", path="/?auth_token=%s" % self._get_token_for(admin) ) self._reopen(appointment.pk) msg = client3.receive() self.assertIsNone(client1.receive()) self.assertIsNone(client2.receive()) self.assertEquals(msg.get('action'), 'appointment_created') self.assertTrue(msg.get('message', {}).get('appointment_event'))
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_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_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'))