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 RealtimeSetupErrorTests(RestLiveTestCase):
"""
Tests making sure that we error at registration-time
if a view does not have all the information we need to
use it for realtime broadcasts.
"""
async def asyncSetUp(self):
self.router = RealtimeRouter()
@async_test
async def test_view_no_mixin(self):
class TestView(GenericAPIView):
queryset = Todo.objects.all()
serializer_class = TodoSerializer
self.assertRaises(RuntimeError, self.router.register, TestView)
@async_test
async def test_model_has_two_views(self):
class TestView(GenericAPIView, RealtimeMixin):
queryset = Todo.objects.all()
serializer_class = TodoSerializer
self.router.register(TestView)
self.assertRaises(RuntimeWarning, self.router.register, TestView)
@async_test
async def test_not_apiview(self):
class TestView(APIView, RealtimeMixin):
pass
self.assertRaises(AssertionError, self.router.register, TestView)
@async_test
async def test_no_queryset_attribute(self):
class TestView(GenericAPIView, RealtimeMixin):
def get_queryset(self):
return Todo.objects.all()
self.assertRaises(AssertionError, self.router.register, TestView)
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())
course_router = routers.NestedSimpleRouter(router, "courses", lookup="course")
course_router.register("queues", QueueViewSet, basename="queue")
course_router.register("members", MembershipViewSet, basename="member")
course_router.register("invites", MembershipInviteViewSet, basename="invite")
course_router.register("announcements",
AnnouncementViewSet,
basename="announcement")
course_router.register("tags", TagViewSet, basename="tag")
queue_router = routers.NestedSimpleRouter(course_router,
"queues",
lookup="queue")
queue_router.register("questions", QuestionViewSet, basename="question")
realtime_router = RealtimeRouter()
realtime_router.register(QuestionViewSet)
realtime_router.register(AnnouncementViewSet)
additional_urls = [
path("accounts/me/", UserView.as_view(), name="me"),
path("accounts/me/resend/",
ResendNotificationView.as_view(),
name="resend"),
path("courses/<slug:course_pk>/mass-invite/",
MassInviteView.as_view(),
name="mass-invite"),
path("courses/<slug:course_pk>/questions/",
QuestionSearchView.as_view(),
name="questionsearch"),
path(
"courses/<slug:course_pk>/queues/<slug:queue_pk>/statistics/",
