async def test_sessions():
app = SimpleHttpApp()
communicator = HttpCommunicator(SessionMiddlewareStack(app), "GET",
"/test/")
response = await communicator.get_response()
headers = response.get("headers", [])
assert len(headers) == 1
name, value = headers[0]
assert name == b"Set-Cookie"
value = value.decode("utf-8")
assert re.compile(r"sessionid=").search(value) is not None
assert re.compile(r"expires=").search(value) is not None
assert re.compile(r"HttpOnly").search(value) is not None
assert re.compile(r"Max-Age").search(value) is not None
assert re.compile(r"Path").search(value) is not None
samesite = re.compile(r"SameSite=(\w+)").search(value)
assert samesite is not None
assert samesite.group(1) == "Lax"
async def test_muliple_sessions():
"""
Create two application instances and test then out of order to verify that
separate scopes are used.
"""
async def inner(scope, receive, send):
send(scope["path"])
class SimpleHttpApp(AsyncConsumer):
async def http_request(self, event):
await database_sync_to_async(self.scope["session"].save)()
assert self.scope["method"] == "GET"
await self.send({
"type": "http.response.start",
"status": 200,
"headers": []
})
await self.send({
"type": "http.response.body",
"body": self.scope["path"].encode()
})
app = SessionMiddlewareStack(SimpleHttpApp.as_asgi())
first_communicator = HttpCommunicator(app, "GET", "/first/")
second_communicator = HttpCommunicator(app, "GET", "/second/")
second_response = await second_communicator.get_response()
assert second_response["body"] == b"/second/"
first_response = await first_communicator.get_response()
assert first_response["body"] == b"/first/"
async def test_session_pass_param(self):
from channels.sessions import SessionMiddlewareStack
from .routing import websocket_urlpatterns
application = ProtocolTypeRouter({
'websocket': SessionMiddlewareStack(
URLRouter(
websocket_urlpatterns
)
),
})
@MyJsonRpcWebsocketConsumerTest.rpc_method()
def ping_set_session(**kwargs):
kwargs['consumer'].scope["session"]["test"] = True
return "pong_set_session"
@MyJsonRpcWebsocketConsumerTest.rpc_method()
def ping_get_session(**kwargs):
assert (kwargs['consumer'].scope["session"]["test"] is True)
return "pong_get_session"
client = WebsocketCommunicator(application, 'ws/')
await client.connect()
await client.send_json_to({"id": 1, "jsonrpc": "2.0", "method": "ping_set_session", "params": {}})
msg = await client.receive_json_from()
self.assertEqual(msg['result'], "pong_set_session")
await client.send_json_to({"id": 1, "jsonrpc": "2.0", "method": "ping_get_session", "params": {}})
msg = await client.receive_json_from()
self.assertEqual(msg['result'], "pong_get_session")
await client.disconnect()
async def test_session_samesite_invalid(samesite_invalid):
app = SimpleHttpApp()
communicator = HttpCommunicator(SessionMiddlewareStack(app), "GET",
"/test/")
with pytest.raises(AssertionError):
await communicator.get_response()
async def test_websocket_can_connect(self,settings):
settings.CHANNEL_LAYERS = TEST_CHANNEL_LAYERS
app = SessionMiddlewareStack(application)
# Create to communicators
match,playerFirst = await make_match_with_one_player()
communicator = WebsocketCommunicator(app, f'ws/match/{match.pk}')
connected, _ = await communicator.connect()
assert connected is True
await communicator.disconnect()
async def test_websocket_consumer(self, settings) -> None:
settings.CHANNEL_LAYERS = TEST_CHANNEL_LAYERS
application = ProtocolTypeRouter({
'websocket':
AuthMiddlewareStack(
SessionMiddlewareStack(
URLRouter([
re_path(r'ws/chat/(?P<room_name>\w+)/$',
TemplateChatConsumer)
])))
})
# Create the test room in ChatRoom
room_instance, _ = ChatRoom.objects.get_or_create(room_name='test',
bot_id=uuid.uuid4())
assert room_instance.room_name == 'test'
communicator = WebsocketCommunicator(application, "/ws/chat/test/")
connected, _ = await communicator.connect()
assert connected == True
# Send a sample message from end_user
await communicator.send_json_to({
"user": "******",
"message": {
"userInputVal": "User Message!"
}
})
# response contains other fields too! So check only the necessary ones
response = await communicator.receive_json_from(timeout=3)
assert response["user"] == "end_user" and response["message"][
"userInputVal"] == "User Message!"
# And from admin
await communicator.send_json_to({
"user": "******",
"message": "Admin Message!"
})
# response contains other fields too! So check only the necessary ones
response = await communicator.receive_json_from()
assert response["user"] == "admin" and response[
"message"] == "Admin Message!"
# Close
await communicator.disconnect()
async def test_session_samesite(samesite, settings):
app = SimpleHttpApp()
communicator = HttpCommunicator(SessionMiddlewareStack(app), "GET",
"/test/")
response = await communicator.get_response()
headers = response.get("headers", [])
assert len(headers) == 1
name, value = headers[0]
assert name == b"Set-Cookie"
value = value.decode("utf-8")
samesite = re.compile(r"SameSite=(\w+)").search(value)
assert samesite is not None
assert samesite.group(1) == settings.SESSION_COOKIE_SAMESITE
async def test_sessions():
class SimpleHttpApp(AsyncConsumer):
"""
Barebones HTTP ASGI app for testing.
"""
async def http_request(self, event):
await database_sync_to_async(self.scope["session"].save)()
assert self.scope["path"] == "/test/"
assert self.scope["method"] == "GET"
await self.send({
"type": "http.response.start",
"status": 200,
"headers": []
})
await self.send({
"type": "http.response.body",
"body": b"test response"
})
app = SimpleHttpApp()
communicator = HttpCommunicator(SessionMiddlewareStack(app), "GET",
"/test/")
response = await communicator.get_response()
headers = response.get("headers", [])
assert len(headers) == 1
name, value = headers[0]
assert name == b"Set-Cookie"
value = value.decode("utf-8")
assert re.compile(r"sessionid=").search(value) is not None
assert re.compile(r"expires=").search(value) is not None
assert re.compile(r"HttpOnly").search(value) is not None
assert re.compile(r"Max-Age").search(value) is not None
assert re.compile(r"Path").search(value) is not None
async def test_multiple_websocket_consumers_with_sessions():
"""
Tests that multiple consumers use the correct scope when using
SessionMiddleware.
"""
class TestConsumer(WebsocketConsumer):
def connect(self):
self.accept()
def receive(self, text_data=None, bytes_data=None):
path = self.scope["path"]
self.send(text_data=path)
app = SessionMiddlewareStack(TestConsumer.as_asgi())
# Create to communicators.
communicator = WebsocketCommunicator(app, "/first/")
second_communicator = WebsocketCommunicator(app, "/second/")
connected, _ = await communicator.connect()
assert connected
connected, _ = await second_communicator.connect()
assert connected
# Test out of order
await second_communicator.send_to(text_data="Echo Path")
response = await second_communicator.receive_from()
assert response == "/second/"
await communicator.send_to(text_data="Echo Path")
response = await communicator.receive_from()
assert response == "/first/"
# Close out
await communicator.disconnect()
await second_communicator.disconnect()
from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
from channels.sessions import SessionMiddlewareStack
from apps.questions.consumers import QuestionConsumer
import apps.questions.routing
application = ProtocolTypeRouter({
'websocket':
SessionMiddlewareStack(
URLRouter(apps.questions.routing.websocket_urlpatterns))
})
from channels.routing import ProtocolTypeRouter, URLRouter
from django.urls import path
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator
from channels.sessions import SessionMiddlewareStack
from social.consumer import NoseyConsumer
from imessage.consumer import ChatConsumer
application = ProtocolTypeRouter({
'websocket':
SessionMiddlewareStack(
AuthMiddlewareStack(
URLRouter([
path('notify/', NoseyConsumer),
path('chat/', ChatConsumer),
])))
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from django.urls import path
from app.authentication import QueryAuthMiddleware
from .consumers import FrontendConsumer
application = ProtocolTypeRouter({
'websocket': QueryAuthMiddleware(
SessionMiddlewareStack(URLRouter([
path('frontend/', FrontendConsumer),
]))),
})
from django.urls import path
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from game.consumers import RoomConsumer
application = ProtocolTypeRouter({
'websocket':
SessionMiddlewareStack(
URLRouter([
path('api/', URLRouter([
path('room/<code>/', RoomConsumer),
])),
]), ),
})
"""
ASGI config for queueapp project.
It exposes the ASGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/asgi/
"""
import os
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from django.core.asgi import get_asgi_application
import que.websockets.routing
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "queueapp.settings")
application = ProtocolTypeRouter({
"http":
get_asgi_application(),
"websocket":
SessionMiddlewareStack(URLRouter(que.websockets.routing.urls, )),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from django.urls import path
from core import consumers
urlrouter = [
path('product/', consumers.ProductConsumer),
]
application = ProtocolTypeRouter({
"websocket":
SessionMiddlewareStack(URLRouter(urlrouter), ),
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from django.urls import path
from .consumers import PushNotificationConsumer
websockets = URLRouter(
[
path(
"ws/notifications/",
PushNotificationConsumer.as_asgi(),
name="ws_notifications",
)
]
)
application = ProtocolTypeRouter(
{
# (http->django views is added by default)
"websocket": SessionMiddlewareStack(AuthMiddlewareStack(websockets)),
}
)
import pytest
from django.urls import path
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from lesync import ApiConsumer
from utils import HttpRequest
application = ProtocolTypeRouter({
'http': SessionMiddlewareStack(
URLRouter([
path('<path:path>', ApiConsumer),
]),
),
})
http = HttpRequest(application)
@pytest.mark.asyncio
async def test_query_validation():
resp = await http.get('/query-validation')
assert resp.status == 400
assert resp.json == {'errors': {'id': 'is required'}}
resp = await http.get('/query-validation?id=foo')
assert resp.status == 400
resp = await http.get('/query-validation?id=1&foo=bar')
assert resp.status == 400
from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
from channels.auth import AuthMiddlewareStack
from channels.sessions import SessionMiddlewareStack
import chat.routing
# import autoplatform.routing
# from autoplatform import consumers
from chat import consumers
application = ProtocolTypeRouter({
# (http->django views is added by default)
# 【channels】（第6步）添加路由配置指向应用的路由模块
# 'websocket': AuthMiddlewareStack( # 使用Session中间件，可以请求中session的值
'websocket':
SessionMiddlewareStack( # 使用Session中间件，可以请求中session的值
URLRouter(chat.routing.websocket_urlpatterns)),
# "channel": ChannelNameRouter({
# # "service-detection": consumers.ServiceConsumer, # AsyncConsumer
# "service-detection": consumers.AsyncConsumer,
# }),
})
from channels.sessions import SessionMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator
from channels.routing import ProtocolTypeRouter, URLRouter
import dectauth.routing
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
AllowedHostsOriginValidator(
SessionMiddlewareStack(
URLRouter(dectauth.routing.websocket_urlpatterns))),
})
# from rest_framework import routers
from channels.routing import ChannelNameRouter, ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from django.conf import settings
from django.conf.urls.static import static
from django.http import HttpResponse
from django.urls import include, path, re_path
from .consumers import AsyncConsumer
async_root_application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
SessionMiddlewareStack(URLRouter([
path('', AsyncConsumer, name="root"),
]))
})
# router = routers.DefaultRouter()
# router.registry.extend(test_router.registry)
# urlpatterns = [
# # re_path(r"^$", lambda request: HttpResponse(f"[OK] WSAPI CLEARVERSION")
# # ),
# path(r'', include((router.urls, 'api'), namespace='api')),
# path(r'api-auth/', include('rest_framework.urls')),
# path(r'graphmodels/', graphmodels)
# ]
from django.conf.urls import url
from django.urls import path
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from .consumers import ChatConsumer
application = ProtocolTypeRouter({
# WebSocket chat handler
"websocket": SessionMiddlewareStack(
URLRouter([
path("chat-room/<int:room_id>", ChatConsumer),
]),
)
})
from channels.routing import ProtocolTypeRouter, ChannelNameRouter, URLRouter
from .consumers import LncConsumer, WorkerConsumer
from django.conf.urls import url
from channels.sessions import SessionMiddlewareStack
application = ProtocolTypeRouter({
"websocket":SessionMiddlewareStack(
URLRouter([
url("^lightning/ws$", LncConsumer),
])),
'channel': ChannelNameRouter({
'lnws': WorkerConsumer,
}),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from django.conf.urls import url
from scriptpad import proxysshtowebsocket
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket': SessionMiddlewareStack(
URLRouter(
[
url(r'^websocket/$', proxysshtowebsocket.AsyncConsumer),
]
)
)
})
from django.urls import re_path
from channels.sessions import SessionMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from rockpaperscissors import consumers
application = ProtocolTypeRouter({
'websocket': SessionMiddlewareStack(
URLRouter([
re_path(r'ws/find_match/$', consumers.MatchFindingConsumer),
re_path(r'ws/match/(?P<Match>\w+)/$', consumers.GameUpdateConsumer),
])
),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from django.apps import apps
from django.urls import path
from .consumers import GraphQLSubscriptionConsumer
if apps.is_installed("django.contrib.auth"):
from channels.auth import AuthMiddlewareStack
else:
AuthMiddlewareStack = None
websocket_urlpatterns = [path("subscriptions", GraphQLSubscriptionConsumer)]
application = ProtocolTypeRouter({"websocket": URLRouter(websocket_urlpatterns)})
session_application = ProtocolTypeRouter(
{"websocket": SessionMiddlewareStack(URLRouter(websocket_urlpatterns))}
)
if AuthMiddlewareStack:
auth_application = ProtocolTypeRouter(
{"websocket": AuthMiddlewareStack(URLRouter(websocket_urlpatterns))}
)
import os
from channels.auth import AuthMiddlewareStack
from channels.sessions import SessionMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
import geochats.routing
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "localchats.settings")
application = ProtocolTypeRouter({
"http":
get_asgi_application(),
"websocket":
SessionMiddlewareStack(URLRouter(geochats.routing.websocket_urlpatterns)),
})
from chat.models import Profile
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'django_chat.settings')
@database_sync_to_async
def get_user(name):
try:
return Profile.objects.get(name=name)
except Profile.DoesNotExist:
return None
class QueryAuthMiddleware:
def __init__(self, app):
self.app = app
async def __call__(self, scope, receive, send):
# scope['user'] = await get_user(scope["query_string"])
scope['user'] = None
return await self.app(scope, receive, send)
application = ProtocolTypeRouter({
"http":
get_asgi_application(),
'websocket':
SessionMiddlewareStack(URLRouter(chat.routing.websocket_urlpatterns), ),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
import rushcafe.routing
application = ProtocolTypeRouter({
'websocket':
SessionMiddlewareStack(URLRouter(
rushcafe.routing.websocket_urlpatterns), ),
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import webApp.routing
from channels.sessions import SessionMiddlewareStack
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
SessionMiddlewareStack(URLRouter(webApp.routing.websocket_urlpatterns)),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
import chat.routing
import connect4_game.routing
# from django.conf.urls import url
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
SessionMiddlewareStack(
URLRouter(chat.routing.websocket_urlpatterns +
connect4_game.routing.websocket_urlpatterns)),
})