Example #1
0
    def test_send_message(self):
        for case in encoded_messages:
            self._channel.send(parse_message(MultiplexerMessage,
                case['encoded']))

            assert dict_message(self._server_channel.receive()) == \
                    case['pythonized']
Example #2
0
def test_read_message():

    bufsize = 1024
    input_bytes = ''.join(
        bytes for case in encoded_messages for bytes in
                (create_frame_header(case['encoded']), case['encoded']))

    mock = mox.Mox()
    mock_sock = mock.CreateMock(Socket)

    collected_chunks = []
    for chunk in chop_bytes(input_bytes, 5):
        collected_chunks.append(chunk)
        mock_sock.recv(bufsize).AndReturn(chunk)
    else:
        # This does in fact test chop_bytes and nothing more.
        assert input_bytes == ''.join(collected_chunks)

        mock_sock.recv(bufsize).AndReturn('')

    mock.ReplayAll()
    channel = Channel(socket=mock_sock)
    channel.receive_bufsize = bufsize

    for case in encoded_messages:
        message = channel.receive()
        assert message is not None
        assert dict_message(message) == case['pythonized']

    assert channel.receive() is None
    assert channel.receive() is None
    assert channel.receive() is None

    mock.VerifyAll()
Example #3
0
def test_deserialize():
    for case in encoded_messages:
        msg = parse_message(MultiplexerMessage, case['encoded'])
        assert dict((field.name, value) for field, value in msg.ListFields()) \
                == case['pythonized'] == dict_message(msg, all_fields=False)

    raises(DecodeError)(lambda: parse_message(VariousFields, ''))()
Example #4
0
def check_make_message(make_message):
    r = {'req_uint32': 1, 'rep_uint32': [3,4]}
    msg = make_message(VariousFields, **r)
    eq_(msg.req_uint32, 1)
    eq_(msg.opt_uint32, 0)
    assert list(msg.rep_uint32) == [3,4]
    eq_(dict_message(msg), r)
    assert dict_message(msg, all_fields=True) == dict(r, opt_uint32=0)

    msg2 = make_message(VariousFieldsList, field=r)
    eq_(msg2.field, msg)
    eq_(dict_message(msg2, recursive=True), {'field': r})

    msg3 = make_message(VariousFieldsList,
            field=make_message(VariousFields, **r))
    eq_(msg3.field, msg)
    eq_(dict_message(msg3, recursive=True), {'field': r})

    raises(ValueError)(lambda: make_message(VariousFieldsList, field=[]))()
    raises(ValueError)(lambda: make_message(VariousFieldsList, field=1))()

    r = range(10)
    msgs = make_message(VariousFieldsList, fields=[
            {'req_uint32': 1},
            {'opt_uint32': 2, 'rep_uint32': []},
            {'rep_uint32': r},
        ])
    eq_(msgs.fields[0].req_uint32, 1)
    eq_(msgs.fields[0].opt_uint32, 0)
    eq_(list(msgs.fields[0].rep_uint32), [])

    eq_(msgs.fields[1].req_uint32, 0)
    eq_(msgs.fields[1].opt_uint32, 2)
    eq_(list(msgs.fields[1].rep_uint32), [])

    eq_(msgs.fields[2].req_uint32, 0)
    eq_(list(msgs.fields[2].rep_uint32), r)
Example #5
0
def check_client_connect(server_impl):
    client = Client(type=317)
    eq_(client.type, 317)
    future = client.connect(server.server_address)
    if server_impl is SimpleMxServerThread:
        # we can't use conect future, as we can't rely on
        # SimpleMxServerThread correctly sending welcome messages
        time.sleep(0.07)
    else:
        future.wait(0.2)

    msg = client.create_message(id=5)
    assert_almost_equal(msg.timestamp, time.time(), -1)
    eq_(dict(dict_message(msg), timestamp=None), {'timestamp': None, 'id':
        5, 'from': client.instance_id})

    client.close()