Esempio n. 1
0
def test_message_serializer_deserialize_completion_response():
    # TODO should start with a packed message and use msgpack to unpack, for now start with builtin form:
    unpacked = {
        '_message': 'CompletionResponse',
        'token': 'thetoken',
        'start': 11,
        'end': 12,
        'limitExceeded': True,
        'options': [
            {'insert': 'insert', 'desc': 'thedescription', 'semantics': 'string', 'extensionId': 'theExtId'},
            {'insert': 'insert2', 'desc': 'thedescription2', 'semantics': 'identifier', 'extensionId': 'theExtId2'}
        ]
    }

    packed = umsgpack.packb(unpacked)

    # and use serializer without unpacker:
    serializer = MessageSerializer()

    msg = serializer.deserialize(packed)

    expected = CompletionResponse(11, 12, True, [CompletionOption('insert', 'thedescription', semantics=SemanticType.string, extensionId='theExtId'),
                                                 CompletionOption('insert2', 'thedescription2', semantics=SemanticType.identifier, extensionId='theExtId2')],
                                  'thetoken')

    # avoid implementation of eq in schema classes, so rely on correct serialization for now:
    assert serializer.serialize(msg) == serializer.serialize(expected)
Esempio n. 2
0
def test_message_serializer_message_iterator():
    serializer = MessageSerializer()

    serializer.enque_data(serializer.serialize(CompletionResponse(1, 2, False)))
    serializer.enque_data(serializer.serialize(CompletionResponse(3, 4, True)))

    count = 0
    for msg in serializer:
        assert isinstance(msg, CompletionResponse)
        count += 1

    assert count == 2
Esempio n. 3
0
def test_message_serializer_enqueue_dequeue():
    serializer = MessageSerializer()

    serializer.enque_data(serializer.serialize(CompletionResponse(1, 2, False, (), 'token')))
    serializer.enque_data(serializer.serialize(CompletionResponse(3, 4, True, (), 'token2')))

    assert serializer.buffer

    msg1 = serializer.dequeue_message()
    msg2 = serializer.dequeue_message()
    msg3 = serializer.dequeue_message()
    msg4 = serializer.dequeue_message()

    assert isinstance(msg1, CompletionResponse)
    assert msg1.token == 'token'
    assert msg1.start == 1
    assert msg1.end == 2
    assert not msg1.limitExceeded

    assert isinstance(msg2, CompletionResponse)
    assert msg2.token == 'token2'
    assert msg2.start == 3
    assert msg2.end == 4
    assert msg2.limitExceeded

    assert not msg3
    assert not msg4
Esempio n. 4
0
def test_message_serializer_serialize_chain():
    mock_packer = mock.MagicMock()
    mock_packer.dumps = mock.MagicMock(return_value=mock.sentinel.PACKER_RESULT)
    serializer = MessageSerializer(mock_packer)

    # make sure packer is called and its result is returned:
    assert serializer.serialize(Shutdown()) == mock.sentinel.PACKER_RESULT
    mock_packer.dumps.assert_called_once_with(dict(_message='Shutdown'))
Esempio n. 5
0
def test_message_serializer_enqueue_dequeue_incomplete():
    serializer = MessageSerializer()
    packed = serializer.serialize(CompletionResponse(1, 2, False))
    assert len(packed) > 1

    for b in packed:
        assert not serializer.dequeue_message()
        serializer.enque_data([b])

    assert isinstance(serializer.dequeue_message(), CompletionResponse)
    assert not serializer.dequeue_message()