def function2305(function2574, function2564):
    function2564.parse_frame = mock.Mock()
    function2564.parse_frame.return_value = [(0, WSMsgType.TEXT, b'line1'),
                                             (0, WSMsgType.CLOSE, b''),
                                             (1, WSMsgType.CONTINUATION,
                                              b'line2')]
    function2564.feed_data(b'')
    var4580 = function2574._buffer[0]
    assert res, (WSMessage(WSMsgType.CLOSE, 0, ''), 0)
    var4580 = function2574._buffer[1]
    assert (var4580 == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10))
def function950(function2574, function2564):
    function2564.parse_frame = mock.Mock()
    function2564.parse_frame.return_value = [
        (0, WSMsgType.TEXT, b'line1'),
        (0, WSMsgType.CLOSE, function2245(1002, b'test', noheader=True)),
        (1, WSMsgType.CONTINUATION, b'line2')
    ]
    function2564.feed_data(b'')
    var1440 = function2574._buffer[0]
    assert res, (WSMessage(WSMsgType.CLOSE, 1002, 'test'), 0)
    var1440 = function2574._buffer[1]
    assert (var1440 == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10))
Esempio n. 3
0
def test_continuation_with_close_empty(out: Any, parser: Any) -> None:
    parser.parse_frame = mock.Mock()
    parser.parse_frame.return_value = [
        (0, WSMsgType.TEXT, b"line1", False),
        (0, WSMsgType.CLOSE, b"", False),
        (1, WSMsgType.CONTINUATION, b"line2", False),
    ]

    parser.feed_data(b"")
    res = out._buffer[0]
    assert res, (WSMessage(WSMsgType.CLOSE, 0, ""), 0)
    res = out._buffer[1]
    assert res == (WSMessage(WSMsgType.TEXT, "line1line2", ""), 10)
def test_continuation_with_close(out, parser):
    parser.parse_frame = mock.Mock()
    parser.parse_frame.return_value = [
        (0, WSMsgType.TEXT, b'line1'),
        (0, WSMsgType.CLOSE, build_close_frame(1002, b'test', noheader=True)),
        (1, WSMsgType.CONTINUATION, b'line2'),
    ]

    parser.feed_data(b'')
    res = out._buffer[0]
    assert res, (WSMessage(WSMsgType.CLOSE, 1002, 'test'), 0)
    res = out._buffer[1]
    assert res == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10)
def test_continuation_with_close_empty(out, parser):
    parser.parse_frame = mock.Mock()
    parser.parse_frame.return_value = [
        (0, WSMsgType.TEXT, b'line1', False),
        (0, WSMsgType.CLOSE, b'', False),
        (1, WSMsgType.CONTINUATION, b'line2', False),
    ]

    parser.feed_data(b'')
    res = out._buffer[0]
    assert res, (WSMessage(WSMsgType.CLOSE, 0, ''), 0)
    res = out._buffer[1]
    assert res == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10)
Esempio n. 6
0
def test_continuation_with_close(out, parser) -> None:
    parser.parse_frame = mock.Mock()
    parser.parse_frame.return_value = [
        (0, WSMsgType.TEXT, b"line1", False),
        (0, WSMsgType.CLOSE, build_close_frame(1002, b"test",
                                               noheader=True), False),
        (1, WSMsgType.CONTINUATION, b"line2", False),
    ]

    parser.feed_data(b"")
    res = out._buffer[0]
    assert res, (WSMessage(WSMsgType.CLOSE, 1002, "test"), 0)
    res = out._buffer[1]
    assert res == (WSMessage(WSMsgType.TEXT, "line1line2", ""), 10)
def function2790(function2574, function2564):
    function2564.parse_frame = mock.Mock()
    function2564.parse_frame.return_value = [(0, WSMsgType.TEXT, b'line1'),
                                             (0, WSMsgType.PING, b''),
                                             (1, WSMsgType.CONTINUATION,
                                              b'line2')]
    var2761 = function2753(b'line1', WSMsgType.TEXT, is_fin=False)
    function2564._feed_data(var2761)
    var2430 = function2753(b'', WSMsgType.PING)
    function2564._feed_data(var2430)
    var4041 = function2753(b'line2', WSMsgType.CONTINUATION)
    function2564._feed_data(var4041)
    var2958 = function2574._buffer[0]
    assert (var2958 == (WSMessage(WSMsgType.PING, b'', ''), 0))
    var2958 = function2574._buffer[1]
    assert (var2958 == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10))
def function2462(function2574, function2564):
    var2814 = function2753(b'line1', WSMsgType.TEXT, is_fin=False)
    function2564._feed_data(var2814)
    var2357 = function2753(b'line2', WSMsgType.CONTINUATION)
    function2564._feed_data(var2357)
    var582 = function2574._buffer[0]
    assert (var582 == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10))
Esempio n. 9
0
def test_close_frame_info(out: Any, parser: Any) -> None:
    parser.parse_frame = mock.Mock()
    parser.parse_frame.return_value = [(1, WSMsgType.CLOSE, b"0112345", False)]

    parser.feed_data(b"")
    res = out._buffer[0]
    assert res == (WSMessage(WSMsgType.CLOSE, 12337, "12345"), 0)
def test_fragmentation_header(out, parser):
    data = build_frame(b'a', WSMsgType.TEXT)
    parser._feed_data(data[:1])
    parser._feed_data(data[1:])

    res = out._buffer[0]
    assert res == (WSMessage(WSMsgType.TEXT, 'a', ''), 1)
Esempio n. 11
0
def test_fragmentation_header(out: Any, parser: Any) -> None:
    data = build_frame(b"a", WSMsgType.TEXT)
    parser._feed_data(data[:1])
    parser._feed_data(data[1:])

    res = out._buffer[0]
    assert res == (WSMessage(WSMsgType.TEXT, "a", ""), 1)
def test_close_frame_info(out, parser):
    parser.parse_frame = mock.Mock()
    parser.parse_frame.return_value = [(1, WSMsgType.CLOSE, b'0112345', False)]

    parser.feed_data(b'')
    res = out._buffer[0]
    assert res == (WSMessage(WSMsgType.CLOSE, 12337, '12345'), 0)
def test_continuation(out, parser):
    data1 = build_frame(b'line1', WSMsgType.TEXT, is_fin=False)
    parser._feed_data(data1)

    data2 = build_frame(b'line2', WSMsgType.CONTINUATION)
    parser._feed_data(data2)

    res = out._buffer[0]
    assert res == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10)
Esempio n. 14
0
def test_continuation(out: Any, parser: Any) -> None:
    data1 = build_frame(b"line1", WSMsgType.TEXT, is_fin=False)
    parser._feed_data(data1)

    data2 = build_frame(b"line2", WSMsgType.CONTINUATION)
    parser._feed_data(data2)

    res = out._buffer[0]
    assert res == (WSMessage(WSMsgType.TEXT, "line1line2", ""), 10)
Esempio n. 15
0
def test_continuation(out, parser):
    parser.parse_frame = mock.Mock()
    parser.parse_frame.return_value = [(0, WSMsgType.TEXT, b'line1'),
                                       (1, WSMsgType.CONTINUATION, b'line2')]

    parser._feed_data(b'')

    res = out._buffer[0]
    assert res == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10)
def test_continuation_with_ping(out, parser):
    parser.parse_frame = mock.Mock()
    parser.parse_frame.return_value = [
        (0, WSMsgType.TEXT, b'line1', False),
        (0, WSMsgType.PING, b'', False),
        (1, WSMsgType.CONTINUATION, b'line2', False),
    ]

    data1 = build_frame(b'line1', WSMsgType.TEXT, is_fin=False)
    parser._feed_data(data1)

    data2 = build_frame(b'', WSMsgType.PING)
    parser._feed_data(data2)

    data3 = build_frame(b'line2', WSMsgType.CONTINUATION)
    parser._feed_data(data3)

    res = out._buffer[0]
    assert res == (WSMessage(WSMsgType.PING, b'', ''), 0)
    res = out._buffer[1]
    assert res == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10)
Esempio n. 17
0
def test_continuation_with_ping(out: Any, parser: Any) -> None:
    parser.parse_frame = mock.Mock()
    parser.parse_frame.return_value = [
        (0, WSMsgType.TEXT, b"line1", False),
        (0, WSMsgType.PING, b"", False),
        (1, WSMsgType.CONTINUATION, b"line2", False),
    ]

    data1 = build_frame(b"line1", WSMsgType.TEXT, is_fin=False)
    parser._feed_data(data1)

    data2 = build_frame(b"", WSMsgType.PING)
    parser._feed_data(data2)

    data3 = build_frame(b"line2", WSMsgType.CONTINUATION)
    parser._feed_data(data3)

    res = out._buffer[0]
    assert res == (WSMessage(WSMsgType.PING, b"", ""), 0)
    res = out._buffer[1]
    assert res == (WSMessage(WSMsgType.TEXT, "line1line2", ""), 10)
Esempio n. 18
0
    async def handle_ws_text_message(
        self,
        request: web.Request,
        ws: web.WebSocketResponse,
        ws_text_message: http.WSMessage,
    ) -> None:
        message: dict = ws_text_message.json()
        message_type: str = message["type"]

        if message_type == GQL_CONNECTION_INIT:
            await self.handle_connection_init(ws)
        elif message_type == GQL_CONNECTION_TERMINATE:
            await self.handle_connection_terminate(ws)
        elif message_type == GQL_START:
            await self.handle_start(request, ws, message)
        elif message_type == GQL_STOP:
            await self.handle_stop(message)
def function2724(function2574, function2564):
    function2564.parse_frame = mock.Mock()
    function2564.parse_frame.return_value = [(1, WSMsgType.CLOSE, b'0112345')]
    function2564.feed_data(b'')
    var4135 = function2574._buffer[0]
    assert (var4135 == (WSMessage(WSMsgType.CLOSE, 12337, '12345'), 0))
def function1009(function2574, function2564):
    var1174 = function2753(b'a', WSMsgType.TEXT)
    function2564._feed_data(var1174[:1])
    function2564._feed_data(var1174[1:])
    var1658 = function2574._buffer[0]
    assert (var1658 == (WSMessage(WSMsgType.TEXT, 'a', ''), 1))