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_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_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, '*****@*****.**')
