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'))
