async def test_http1_websocket(nursery: trio._core._run.Nursery) -> None:
client_stream, server_stream = trio.testing.memory_stream_pair()
server_stream.socket = MockSocket()
server = TCPServer(sanity_framework, Config(), server_stream)
nursery.start_soon(server.run)
client = wsproto.WSConnection(wsproto.ConnectionType.CLIENT)
await client_stream.send_all(
client.send(wsproto.events.Request(host="hypercorn", target="/")))
client.receive_data(await client_stream.receive_some(1024))
assert list(client.events()) == [
wsproto.events.AcceptConnection(extra_headers=[
(b"date", b"Thu, 01 Jan 1970 01:23:20 GMT"),
(b"server", b"hypercorn-h11"),
])
]
await client_stream.send_all(
client.send(wsproto.events.BytesMessage(data=SANITY_BODY)))
client.receive_data(await client_stream.receive_some(1024))
assert list(client.events()) == [
wsproto.events.TextMessage(data="Hello & Goodbye")
]
await client_stream.send_all(
client.send(wsproto.events.CloseConnection(code=1000)))
client.receive_data(await client_stream.receive_some(1024))
assert list(client.events()) == [
wsproto.events.CloseConnection(code=1000, reason="")
]
def __init__(self, config, server_state, _loop=None):
if not config.loaded:
config.load()
self.config = config
self.app = config.loaded_app
self.loop = _loop or asyncio.get_event_loop()
self.logger = config.logger_instance
self.root_path = config.root_path
# Shared server state
self.connections = server_state.connections
self.tasks = server_state.tasks
# Connection state
self.transport = None
self.server = None
self.client = None
self.scheme = None
# WebSocket state
self.connect_event = None
self.queue = asyncio.Queue()
self.handshake_complete = False
self.close_sent = False
self.conn = wsproto.WSConnection(connection_type=ConnectionType.SERVER)
self.read_paused = False
self.writable = asyncio.Event()
self.writable.set()
# Buffers
self.bytes = b""
self.text = ""
async def test_http1_websocket(event_loop: asyncio.AbstractEventLoop) -> None:
server = TCPServer(
sanity_framework,
event_loop,
Config(),
MemoryReader(),
MemoryWriter() # type: ignore
)
asyncio.ensure_future(server.run())
client = wsproto.WSConnection(wsproto.ConnectionType.CLIENT)
await server.reader.send( # type: ignore
client.send(wsproto.events.Request(host="hypercorn", target="/")))
client.receive_data(await server.writer.receive()) # type: ignore
assert list(client.events()) == [
wsproto.events.AcceptConnection(extra_headers=[
(b"date", b"Thu, 01 Jan 1970 01:23:20 GMT"),
(b"server", b"hypercorn-h11"),
])
]
await server.reader.send( # type: ignore
client.send(wsproto.events.BytesMessage(data=SANITY_BODY)))
client.receive_data(await server.writer.receive()) # type: ignore
assert list(client.events()) == [
wsproto.events.TextMessage(data="Hello & Goodbye")
]
await server.reader.send( # type: ignore
client.send(wsproto.events.CloseConnection(code=1000)))
client.receive_data(await server.writer.receive()) # type: ignore
assert list(client.events()) == [
wsproto.events.CloseConnection(code=1000, reason="")
]
assert server.writer.is_closed # type: ignore
def __init__(self, url, log=None, stream=None):
if log is None:
log = logging.getLogger('HTTP_WS')
self.log = log
self.stream = stream
self.url = url
parsed = urllib.parse.urlsplit(url)
self.scheme = parsed.scheme or 'ws'
if self.scheme.startswith('http'):
self.scheme = 'ws' + self.scheme[4:]
assert self.scheme in ('ws', 'wss')
self.hostname = parsed.hostname
self.port = int(parsed.port or {'ws': 80, 'wss': 443}[self.scheme])
self.resource = (parsed.path or '/') + (
('?' + parsed.query) if parsed.query else '')
self.ws = wsproto.WSConnection(wsproto.ConnectionType.CLIENT)
self.connected = False
self.closed = False
self.response = None
self.inbuf = []
self.reading = False
def __init__(self):
self.ws = wsproto.WSConnection(wsproto.ConnectionType.SERVER)
self.out = []
self.closed = False
self.srream = None