class PrivateRouterTests(RestLiveTestCase):
async def asyncSetUp(self):
self.list = await db(List.objects.create)(name="test list")
self.router = RealtimeRouter(public=False)
self.router.register(TodoViewSet)
@async_test
async def test_reject_no_auth(self):
self.client = APICommunicator(
AuthMiddlewareStack(self.router.as_consumer()),
"/ws/subscribe/",
)
connected, code = await self.client.connect()
self.assertFalse(connected)
self.assertEqual(4003, code)
@async_test
async def test_reject_no_middleware(self):
self.client = APICommunicator(
self.router.as_consumer(),
"/ws/subscribe/",
)
connected, code = await self.client.connect()
self.assertFalse(connected)
self.assertEqual(4003, code)
@async_test
async def test_accept_with_auth(self):
user = await db(User.objects.create_user)("test")
headers = await get_headers_for_user(user)
self.client = APICommunicator(
AuthMiddlewareStack(self.router.as_consumer()), "/ws/subscribe/",
headers)
connected, _ = await self.client.connect()
self.assertTrue(connected)
async def asyncSetUp(self):
router = RealtimeRouter()
router.register(TodoViewSet)
self.client = APICommunicator(router.as_consumer(), "/ws/subscribe/")
connected, _ = await self.client.connect()
self.assertTrue(connected)
async def asyncSetUp(self):
router = RealtimeRouter()
router.register(FilteredViewSet)
self.client = APICommunicator(router.as_consumer(), "/ws/subscribe/")
connected, _ = await self.client.connect()
self.assertTrue(connected)
self.list = await db(List.objects.create)(name="test list")
async def asyncSetUp(self):
router = RealtimeRouter()
router.register(AnnotatedTodoViewSet)
self.client = make_client(router.as_consumer(), "/ws/subscribe/")
connected, _ = await self.client.connect()
self.assertTrue(connected)
self.list = await db(List.objects.create)(name="test list")
async def asyncSetUp(self):
self.list = await db(List.objects.create)(name="test list")
router = RealtimeRouter()
router.register(AuthedTodoViewSet)
self.client = make_client(router.as_consumer(), "/ws/subscribe/",
AuthMiddlewareStack)
connected, _ = await self.client.connect()
self.assertTrue(connected)
self.user = await db(User.objects.create_user)("test")
headers = await get_headers_for_user(self.user)
self.auth_client = make_client(
router.as_consumer(),
"/ws/subscribe/",
AuthMiddlewareStack,
headers,
)
connected, _ = await self.auth_client.connect()
self.assertTrue(connected)
async def test_list_sub_conditional_serializers(self):
await self.client.disconnect()
await self.auth_client.disconnect()
router = RealtimeRouter()
router.register(ConditionalTodoViewSet)
self.client = make_client(
router.as_consumer(),
"/ws/subscribe/",
AuthMiddlewareStack,
)
connected, _ = await self.client.connect()
self.assertTrue(connected)
headers = await get_headers_for_user(self.user)
self.auth_client = make_client(
router.as_consumer(),
"/ws/subscribe/",
AuthMiddlewareStack,
headers,
)
connected, _ = await self.auth_client.connect()
self.assertTrue(connected)
req = await self.subscribe_to_list(self.client)
req_auth = await self.subscribe_to_list(self.auth_client)
new_todo = await self.make_todo()
await self.assertReceivedBroadcastForTodo(new_todo,
CREATED,
req,
communicator=self.client)
await self.assertReceivedBroadcastForTodo(
new_todo,
CREATED,
req_auth,
communicator=self.auth_client,
serializer=AuthedTodoSerializer,
)
# Assert that each connection has only received a single update.
self.assertTrue(await self.client.receive_nothing())
self.assertTrue(await self.auth_client.receive_nothing())
class MultiRouterTests(RestLiveTestCase):
"""
Tests to ensure that multiple routers/consumers can be stood up on
separate domains and that they don't interfere with each other.
"""
async def asyncSetUp(self):
self.list = await db(List.objects.create)(name="test list")
self.router1 = RealtimeRouter()
self.router1.register(TodoViewSet)
self.router2 = RealtimeRouter("auth")
self.router2.register(AuthedTodoViewSet)
self.user = await db(User.objects.create_user)("test")
self.headers = await get_headers_for_user(self.user)
async def asyncTearDown(self):
await self.client1.disconnect()
await self.client2.disconnect()
@async_test
async def test_broadcasts_one_per_router(self):
self.client1 = APICommunicator(
AuthMiddlewareStack(self.router1.as_consumer()),
"/ws/subscribe/",
self.headers,
)
self.assertTrue(await self.client1.connect())
self.client2 = APICommunicator(
AuthMiddlewareStack(self.router2.as_consumer()),
"/ws/subscribe/auth/",
self.headers,
)
self.assertTrue(await self.client2.connect())
req1 = await self.subscribe_to_list(self.client1)
req2 = await self.subscribe_to_list(self.client2)
new_todo = await db(Todo.objects.create)(list=self.list, text="test")
await self.assertReceivedBroadcastForTodo(new_todo, CREATED, req1,
self.client1)
self.assertTrue(await self.client1.receive_nothing())
await self.assertReceivedBroadcastForTodo(new_todo, CREATED, req2,
self.client2)
self.assertTrue(await self.client2.receive_nothing())
@async_test
async def test_broadcasts_only_to_one(self):
self.client1 = APICommunicator(
AuthMiddlewareStack(self.router1.as_consumer()),
"/ws/subscribe/",
self.headers,
)
self.assertTrue(await self.client1.connect())
self.client2 = APICommunicator(
AuthMiddlewareStack(self.router2.as_consumer()),
"/ws/subscribe/auth/")
self.assertTrue(await self.client2.connect())
req1 = await self.subscribe_to_list(self.client1)
req2 = await self.subscribe_to_list(self.client2, 403)
new_todo = await db(Todo.objects.create)(list=self.list, text="test")
await self.assertReceivedBroadcastForTodo(new_todo, CREATED, req1,
self.client1)
self.assertTrue(await self.client1.receive_nothing())
self.assertTrue(await self.client2.receive_nothing())
