def test_close_idempotent(make_request, writer):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
assert (yield from ws.close(code=1, message='message1'))
assert ws.closed
assert not (yield from ws.close(code=2, message='message2'))
def test_close_idempotent(make_request, writer):
req = make_request("GET", "/")
ws = WebSocketResponse()
yield from ws.prepare(req)
assert (yield from ws.close(code=1, message="message1"))
assert ws.closed
assert not (yield from ws.close(code=2, message="message2"))
def test_close_idempotent(make_request, writer):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
assert (yield from ws.close(code=1, message='message1'))
assert ws.closed
assert not (yield from ws.close(code=2, message='message2'))
def test_pong_closing(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
ws.start(req)
ws.close()
with self.assertRaises(RuntimeError):
ws.pong()
def test_close_idempotent(make_request, writer):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
ws._reader.feed_data(WS_CLOSED_MESSAGE, 0)
assert (yield from ws.close(code=1, message='message1'))
assert ws.closed
assert not (yield from ws.close(code=2, message='message2'))
def function716(function271, function61):
var4554 = function271('GET', '/')
var4135 = WebSocketResponse()
yield from var4135.prepare(var4554)
var4135._reader.feed_data(WS_CLOSED_MESSAGE, 0)
assert yield from var4135.close(code=1, message='message1')
assert var4135.closed
assert (not yield from var4135.close(code=2, message='message2'))
def test_close_idempotent(self):
req = self.make_request("GET", "/")
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
writer = mock.Mock()
ws._writer = writer
self.assertTrue(self.loop.run_until_complete(ws.close(code=1, message="message1")))
self.assertTrue(ws.closed)
self.assertFalse(self.loop.run_until_complete(ws.close(code=2, message="message2")))
def test_close_idempotent(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
ws.start(req)
writer = mock.Mock()
ws._writer = writer
self.assertTrue(
self.loop.run_until_complete(ws.close(code=1, message='message1')))
self.assertTrue(ws.closed)
self.assertFalse(
self.loop.run_until_complete(ws.close(code=2, message='message2')))
def test_double_close(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
ws.start(req)
writer = mock.Mock()
ws._writer = writer
ws.close(code=1, message='message1')
self.assertTrue(ws.closing)
with self.assertRaisesRegex(RuntimeError, 'Already closing'):
ws.close(code=2, message='message2')
self.assertTrue(ws.closing)
writer.close.assert_called_once_with(1, 'message1')
def function113(function271):
var2027 = function271('GET', '/')
var2897 = WebSocketResponse()
yield from var2897.prepare(var2027)
var962 = ValueError()
var2897._writer = mock.Mock()
var2897._writer.close.side_effect = var962
yield from var2897.close()
assert var2897.closed
assert (var2897.exception() is var962)
var2897._closed = False
var2897._writer.close.side_effect = asyncio.CancelledError()
with pytest.raises(asyncio.CancelledError):
yield from var2897.close()
def test_send_bytes_closed(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
self.loop.run_until_complete(ws.close())
with self.assertRaises(RuntimeError):
ws.send_bytes(b'bytes')
def test_send_json_closed(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
with pytest.raises(RuntimeError):
ws.send_json({'type': 'json'})
def wso(request):
global wsk
global wst
wsk0 = WebSocketResponse()
wsk0.start(request)
unauth = True
while True:
msg = yield from wsk0.receive()
if msg.tp == MsgType.text:
print("Screen")
print(msg.data)
if unauth:
wsk0.auth = msg.data
wsk[wsk0.auth] = wsk0
unauth = False
continue
if msg.data == 'close':
yield from wsk0.close()
wsk.pop(wsk0.auth, None)
break
else:
wst[wsk0.auth].send_str(msg.data)
elif msg.tp == MsgType.close:
break
elif msg.tp == MsgType.error:
break
wsk.pop(wsk0.auth, None)
return wsk0
def test_pong_closed(self):
req = self.make_request("GET", "/")
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
self.loop.run_until_complete(ws.close())
with self.assertRaises(RuntimeError):
ws.pong()
def test_send_json_closed(make_request):
req = make_request("GET", "/")
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
with pytest.raises(RuntimeError):
ws.send_json({"type": "json"})
def test_send_str_closed(make_request):
req = make_request("GET", "/")
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
with pytest.raises(RuntimeError):
ws.send_str("string")
def test_send_json_closed(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
with pytest.raises(RuntimeError):
ws.send_json({'type': 'json'})
def test_close_exc2(self):
req = self.make_request("GET", "/")
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
exc = ValueError()
self.writer.close.side_effect = exc
ws._writer = self.writer
self.loop.run_until_complete(ws.close())
self.assertTrue(ws.closed)
self.assertIs(ws.exception(), exc)
ws._closed = False
self.writer.close.side_effect = asyncio.CancelledError()
self.assertRaises(asyncio.CancelledError, self.loop.run_until_complete, ws.close())
def test_pong_closed(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
with pytest.raises(RuntimeError):
ws.pong()
def test_pong_closed(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
ws.start(req)
self.loop.run_until_complete(ws.close())
with self.assertRaises(RuntimeError):
ws.pong()
def test_send_bytes_closed(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
self.loop.run_until_complete(ws.close())
with self.assertRaises(RuntimeError):
ws.send_bytes(b'bytes')
def test_pong_closed(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
with pytest.raises(RuntimeError):
ws.pong()
def test_close_exc2(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
exc = ValueError()
ws._writer = mock.Mock()
ws._writer.close.side_effect = exc
yield from ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
ws._writer.close.side_effect = asyncio.CancelledError()
with pytest.raises(asyncio.CancelledError):
yield from ws.close()
def test_close_exc2(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
exc = ValueError()
ws._writer = mock.Mock()
ws._writer.close.side_effect = exc
yield from ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
ws._writer.close.side_effect = asyncio.CancelledError()
with pytest.raises(asyncio.CancelledError):
yield from ws.close()
def test_close_exc2(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
ws.start(req)
exc = ValueError()
self.writer.close.side_effect = exc
ws._writer = self.writer
self.loop.run_until_complete(ws.close())
self.assertTrue(ws.closed)
self.assertIs(ws.exception(), exc)
ws._closed = False
self.writer.close.side_effect = asyncio.CancelledError()
self.assertRaises(asyncio.CancelledError,
self.loop.run_until_complete, ws.close())
def test_send_json_closed(make_request, mocker):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
mocker.spy(ws_logger, 'warning')
ws.send_json({'type': 'json'})
assert ws_logger.warning.called
def test_pong_closed(make_request, mocker):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
mocker.spy(ws_logger, 'warning')
ws.pong()
assert ws_logger.warning.called
def test_write_eof_idempotent(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
yield from ws.write_eof()
yield from ws.write_eof()
yield from ws.write_eof()
def function2561(function271, arg922):
var2863 = function271('GET', '/')
var2278 = WebSocketResponse()
yield from var2278.prepare(var2863)
var2278._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from var2278.close()
arg922.spy(ws_logger, 'warning')
var2278.send_str('string')
assert ws_logger.warning.called
def function2783(function271, arg1739):
var4570 = function271('GET', '/')
var3309 = WebSocketResponse()
yield from var3309.prepare(var4570)
var3309._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from var3309.close()
arg1739.spy(ws_logger, 'warning')
var3309.send_bytes(b'bytes')
assert ws_logger.warning.called
def function1203(function271, arg476):
var1953 = function271('GET', '/')
var1605 = WebSocketResponse()
yield from var1605.prepare(var1953)
var1605._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from var1605.close()
arg476.spy(ws_logger, 'warning')
var1605.send_json({'type': 'json', })
assert ws_logger.warning.called
def function835(function271, arg1247):
var816 = function271('GET', '/')
var1269 = WebSocketResponse()
yield from var1269.prepare(var816)
var1269._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from var1269.close()
arg1247.spy(ws_logger, 'warning')
var1269.ping()
assert ws_logger.warning.called
async def login(self, ws: web.WebSocketResponse, username: str,
token: str):
"""
Функция авторизации пользователя с валидацией его токена.
"""
try:
if await self.check_token(username, token):
await self.db.add_member(username, self.members_key)
await ws.send_json({"code": 0, "note": "Success"})
else:
await ws.send_json({
"code": 1,
"note": "Invalid username/token pair"
})
ws.close()
except Exception as e:
self.logger.error(traceback.format_exc())
await ws.send_json({"code": 2, "note": "Failed to login"})
def function2874(function271, arg512):
var1102 = function271('GET', '/')
var1066 = WebSocketResponse()
yield from var1066.prepare(var1102)
var1066._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from var1066.close()
arg512.spy(ws_logger, 'warning')
var1066.pong()
assert ws_logger.warning.called
def test_write_eof_idempotent(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
yield from ws.write_eof()
yield from ws.write_eof()
yield from ws.write_eof()
def function2567(function271):
var424 = function271('GET', '/')
var4602 = WebSocketResponse()
yield from var4602.prepare(var424)
var4602._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from var4602.close()
yield from var4602.write_eof()
yield from var4602.write_eof()
yield from var4602.write_eof()
def test_write_eof_idempotent(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
ws._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from ws.close()
yield from ws.write_eof()
yield from ws.write_eof()
yield from ws.write_eof()
def test_multiple_receive_on_close_connection(self):
req = self.make_request("GET", "/")
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
self.loop.run_until_complete(ws.close())
self.loop.run_until_complete(ws.receive())
self.loop.run_until_complete(ws.receive())
self.loop.run_until_complete(ws.receive())
self.loop.run_until_complete(ws.receive())
self.assertRaises(RuntimeError, self.loop.run_until_complete, ws.receive())
def test_write_eof_idempotent(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
ws._reader.feed_data(CLOSED_MESSAGE, 0)
yield from ws.close()
yield from ws.write_eof()
yield from ws.write_eof()
yield from ws.write_eof()
def test_ping_closed(make_request, mocker):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
ws._reader.feed_data(CLOSED_MESSAGE, 0)
yield from ws.close()
mocker.spy(ws_logger, 'warning')
ws.ping()
assert ws_logger.warning.called
def test_pong_closed(make_request, mocker):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
ws._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from ws.close()
mocker.spy(ws_logger, 'warning')
ws.pong()
assert ws_logger.warning.called
def test_close_exc(self):
req = self.make_request("GET", "/")
reader = self.reader.set_parser.return_value = mock.Mock()
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
exc = ValueError()
reader.read.return_value = asyncio.Future(loop=self.loop)
reader.read.return_value.set_exception(exc)
self.loop.run_until_complete(ws.close())
self.assertTrue(ws.closed)
self.assertIs(ws.exception(), exc)
ws._closed = False
reader.read.return_value = asyncio.Future(loop=self.loop)
reader.read.return_value.set_exception(asyncio.CancelledError())
self.assertRaises(asyncio.CancelledError, self.loop.run_until_complete, ws.close())
self.assertEqual(ws.close_code, 1006)
def test_close_exc(make_request, reader, loop):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
exc = ValueError()
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_exception(exc)
yield from ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_exception(asyncio.CancelledError())
with pytest.raises(asyncio.CancelledError):
yield from ws.close()
assert ws.close_code == 1006
def test_close_exc(make_request, reader, loop):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
exc = ValueError()
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_exception(exc)
yield from ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_exception(asyncio.CancelledError())
with pytest.raises(asyncio.CancelledError):
yield from ws.close()
assert ws.close_code == 1006
def test_multiple_receive_on_close_connection(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
ws.start(req)
self.loop.run_until_complete(ws.close())
self.loop.run_until_complete(ws.receive())
self.loop.run_until_complete(ws.receive())
self.loop.run_until_complete(ws.receive())
self.loop.run_until_complete(ws.receive())
self.assertRaises(
RuntimeError, self.loop.run_until_complete, ws.receive())
def function479(function271, arg926, arg363):
var1796 = function271('GET', '/')
var300 = WebSocketResponse()
yield from var300.prepare(var1796)
var300._reader = mock.Mock()
var4357 = ValueError()
var300._reader.read.return_value = helpers.create_future(arg926)
var300._reader.read.return_value.set_exception(var4357)
var300._payload_writer.drain = mock.Mock()
var300._payload_writer.drain.return_value = helpers.create_future(arg926)
var300._payload_writer.drain.return_value.set_result(True)
yield from var300.close()
assert var300.closed
assert (var300.exception() is var4357)
var300._closed = False
var300._reader.read.return_value = helpers.create_future(arg926)
var300._reader.read.return_value.set_exception(asyncio.CancelledError())
with pytest.raises(asyncio.CancelledError):
yield from var300.close()
assert (var300.close_code == 1006)
def test_close_exc(self):
req = self.make_request('GET', '/')
reader = self.reader.set_parser.return_value = mock.Mock()
ws = WebSocketResponse()
ws.start(req)
exc = ValueError()
reader.read.return_value = asyncio.Future(loop=self.loop)
reader.read.return_value.set_exception(exc)
self.loop.run_until_complete(ws.close())
self.assertTrue(ws.closed)
self.assertIs(ws.exception(), exc)
ws._closed = False
reader.read.return_value = asyncio.Future(loop=self.loop)
reader.read.return_value.set_exception(asyncio.CancelledError())
self.assertRaises(asyncio.CancelledError,
self.loop.run_until_complete, ws.close())
self.assertEqual(ws.close_code, 1006)
def function2740(function271):
var975 = function271('GET', '/')
var3594 = WebSocketResponse()
yield from var3594.prepare(var975)
var3594._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from var3594.close()
yield from var3594.function1900()
yield from var3594.function1900()
yield from var3594.function1900()
yield from var3594.function1900()
with pytest.raises(RuntimeError):
yield from var3594.function1900()
def test_write_eof_idempotent(self):
req = self.make_request("GET", "/")
ws = WebSocketResponse()
self.loop.run_until_complete(ws.prepare(req))
self.loop.run_until_complete(ws.close())
@asyncio.coroutine
def go():
yield from ws.write_eof()
yield from ws.write_eof()
yield from ws.write_eof()
self.loop.run_until_complete(go())
def test_multiple_receive_on_close_connection(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
yield from ws.receive()
yield from ws.receive()
yield from ws.receive()
yield from ws.receive()
with pytest.raises(RuntimeError):
yield from ws.receive()
def test_write_eof_idempotent(self):
req = self.make_request('GET', '/')
ws = WebSocketResponse()
ws.start(req)
self.loop.run_until_complete(ws.close())
@asyncio.coroutine
def go():
yield from ws.write_eof()
yield from ws.write_eof()
yield from ws.write_eof()
self.loop.run_until_complete(go())
def test_multiple_receive_on_close_connection(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
yield from ws.close()
yield from ws.receive()
yield from ws.receive()
yield from ws.receive()
yield from ws.receive()
with pytest.raises(RuntimeError):
yield from ws.receive()
def test_multiple_receive_on_close_connection(make_request):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
ws._reader.feed_data(WS_CLOSED_MESSAGE, 0)
yield from ws.close()
yield from ws.receive()
yield from ws.receive()
yield from ws.receive()
yield from ws.receive()
with pytest.raises(RuntimeError):
yield from ws.receive()
def test_close_exc(make_request, loop, mocker):
req = make_request('GET', '/')
ws = WebSocketResponse()
yield from ws.prepare(req)
ws._reader = mock.Mock()
exc = ValueError()
ws._reader.read.return_value = helpers.create_future(loop)
ws._reader.read.return_value.set_exception(exc)
ws._payload_writer.drain = mock.Mock()
ws._payload_writer.drain.return_value = helpers.create_future(loop)
ws._payload_writer.drain.return_value.set_result(True)
yield from ws.close()
assert ws.closed
assert ws.exception() is exc
ws._closed = False
ws._reader.read.return_value = helpers.create_future(loop)
ws._reader.read.return_value.set_exception(asyncio.CancelledError())
with pytest.raises(asyncio.CancelledError):
yield from ws.close()
assert ws.close_code == 1006
def test_nonstarted_close(self):
ws = WebSocketResponse()
with self.assertRaises(RuntimeError):
self.loop.run_until_complete(ws.close())
def go():
ws = WebSocketResponse()
with self.assertRaises(RuntimeError):
yield from ws.close()
