Exemplo n.º 1
0
async def test_stream_paging():

    output = TeeQueue()
    convo = IterStreamEvents("my-stream")
    response = proto.ReadStreamEventsCompleted()
    response.result = msg.ReadEventResult.Success
    response.next_event_number = 10
    response.last_event_number = 9
    response.is_end_of_stream = False
    response.last_commit_position = 8

    await convo.respond_to(
        msg.InboundMessage(
            uuid4(),
            msg.TcpCommand.ReadStreamEventsForwardCompleted,
            response.SerializeToString(),
        ),
        output,
    )

    reply = await output.get()
    body = proto.ReadStreamEvents()
    body.ParseFromString(reply.payload)

    assert body.from_event_number == 10
Exemplo n.º 2
0
async def test_stream_not_found():

    output = TeeQueue()
    convo = IterStreamEvents("my-stream")
    response = proto.ReadStreamEventsCompleted()
    response.result = msg.ReadStreamResult.NoStream
    response.is_end_of_stream = False
    response.next_event_number = 0
    response.last_event_number = 0
    response.last_commit_position = 0

    await convo.respond_to(
        msg.InboundMessage(
            uuid4(),
            msg.TcpCommand.ReadStreamEventsForwardCompleted,
            response.SerializeToString(),
        ),
        output,
    )

    with pytest.raises(exceptions.StreamNotFound) as exn:
        await convo.result
        assert exn.stream == "my-stream"
        assert exn.conversation_id == convo.conversation_id

    assert not output.items
async def test_end_of_stream():

    output = TeeQueue()
    event_1_id = uuid4()
    event_2_id = uuid4()

    convo = IterStreamEvents("my-stream")
    response = proto.ReadStreamEventsCompleted()
    response.result = msg.ReadEventResult.Success
    response.next_event_number = 10
    response.last_event_number = 9
    response.is_end_of_stream = True
    response.last_commit_position = 8

    event_1 = proto.ResolvedIndexedEvent()
    event_1.event.event_stream_id = "stream-123"
    event_1.event.event_number = 32
    event_1.event.event_id = event_1_id.bytes_le
    event_1.event.event_type = "event-type"
    event_1.event.data_content_type = msg.ContentType.Json
    event_1.event.metadata_content_type = msg.ContentType.Binary
    event_1.event.data = """
    {
        'color': 'red',
        'winner': true
    }
    """.encode(
        "UTF-8"
    )

    event_2 = proto.ResolvedIndexedEvent()
    event_2.CopyFrom(event_1)
    event_2.event.event_type = "event-2-type"
    event_2.event.event_id = event_2_id.bytes_le
    event_2.event.event_number = 33

    response.events.extend([event_1, event_2])

    await convo.respond_to(
        msg.InboundMessage(
            uuid4(), msg.TcpCommand.ReadEventCompleted, response.SerializeToString()
        ),
        output,
    )

    # Todo: Use a slice here so that we can give information
    # to the iterator about its position in the stream?
    # assert isinstance(reply.result, msg.StreamSlice)

    result = await convo.result
    [event_1, event_2] = [e async for e in result]
    assert event_1.event.stream == "stream-123"
    assert event_1.event.id == event_1_id
    assert event_1.event.type == "event-type"
    assert event_1.event.event_number == 32

    assert event_2.event.stream == "stream-123"
    assert event_2.event.id == event_2_id
    assert event_2.event.type == "event-2-type"
    assert event_2.event.event_number == 33
Exemplo n.º 4
0
async def test_reconnect_at_last_event_number():

    output = TeeQueue()
    event_1_id = uuid4()
    event_2_id = uuid4()
    convo = IterStreamEvents("my-stream", from_event=32)
    await convo.start(output)

    response = proto.ReadStreamEventsCompleted()
    response.result = msg.ReadEventResult.Success
    response.next_event_number = 32
    response.last_event_number = 31
    response.is_end_of_stream = False
    response.last_commit_position = 31

    event_1 = proto.ResolvedIndexedEvent()
    event_1.event.event_stream_id = "stream-123"
    event_1.event.event_number = 32
    event_1.event.event_id = event_1_id.bytes_le
    event_1.event.event_type = "event-type"
    event_1.event.data_content_type = msg.ContentType.Json
    event_1.event.metadata_content_type = msg.ContentType.Binary
    event_1.event.data = """
    {
        'color': 'red',
        'winner': true
    }
    """.encode("UTF-8")

    event_2 = proto.ResolvedIndexedEvent()
    event_2.CopyFrom(event_1)
    event_2.event.event_type = "event-2-type"
    event_2.event.event_id = event_2_id.bytes_le
    event_2.event.event_number = 33

    response.events.extend([event_1, event_2])

    await convo.respond_to(
        msg.InboundMessage(
            uuid4(),
            msg.TcpCommand.ReadStreamEventsForwardCompleted,
            response.SerializeToString(),
        ),
        output,
    )

    await convo.start(output)
    request = output.items[-1]

    body = proto.ReadStreamEvents()
    body.ParseFromString(request.payload)

    assert request.command is msg.TcpCommand.ReadStreamEventsForward
    assert body.event_stream_id == "my-stream"
    assert body.from_event_number == 33
    assert body.resolve_link_tos is True
    assert body.require_master is False
    assert body.max_count == 100
async def test_read_stream_success():

    event_1_id = uuid4()
    event_2_id = uuid4()

    convo = ReadStreamEvents("my-stream", 0)
    response = proto.ReadStreamEventsCompleted()
    response.result = msg.ReadEventResult.Success
    response.next_event_number = 10
    response.last_event_number = 9
    response.is_end_of_stream = True
    response.last_commit_position = 8

    event_1 = proto.ResolvedIndexedEvent()
    event_1.event.event_stream_id = "stream-123"
    event_1.event.event_number = 32
    event_1.event.event_id = event_1_id.bytes_le
    event_1.event.event_type = "event-type"
    event_1.event.data_content_type = msg.ContentType.Json
    event_1.event.metadata_content_type = msg.ContentType.Binary
    event_1.event.data = """
    {
        'color': 'red',
        'winner': true
    }
    """.encode("UTF-8")

    event_2 = proto.ResolvedIndexedEvent()
    event_2.CopyFrom(event_1)
    event_2.event.event_type = "event-2-type"
    event_2.event.event_id = event_2_id.bytes_le
    event_2.event.event_number = 33

    response.events.extend([event_1, event_2])

    await convo.respond_to(
        msg.InboundMessage(uuid4(), msg.TcpCommand.ReadEventCompleted,
                           response.SerializeToString()),
        None,
    )

    result = await convo.result

    assert isinstance(result, msg.StreamSlice)

    [event_1, event_2] = result.events
    assert event_1.event.stream == "stream-123"
    assert event_1.event.id == event_1_id
    assert event_1.event.type == "event-type"
    assert event_1.event.event_number == 32

    assert event_2.event.stream == "stream-123"
    assert event_2.event.id == event_2_id
    assert event_2.event.type == "event-2-type"
    assert event_2.event.event_number == 33
Exemplo n.º 6
0
def read_stream_events_failure(conversation_id, result):
    payload = proto.ReadStreamEventsCompleted()
    payload.result = result
    payload.last_event_number = 1
    payload.next_event_number = 1
    payload.last_commit_position = 1
    payload.is_end_of_stream = False

    return msg.InboundMessage(
        conversation_id,
        msg.TcpCommand.ReadStreamEventsForwardCompleted,
        payload.SerializeToString(),
    )
Exemplo n.º 7
0
    def build(self):
        response = proto.ReadStreamEventsCompleted()
        response.result = self.result
        response.next_event_number = self.next_event_number
        response.last_event_number = self.last_event_number
        response.is_end_of_stream = self.is_end_of_stream
        response.last_commit_position = self.last_commit_position

        response.events.extend(self.events)

        return (
            msg.TcpCommand.ReadStreamEventsForwardCompleted,
            response.SerializeToString(),
        )
Exemplo n.º 8
0
async def test_error_mid_stream():

    output = TeeQueue()
    convo = IterStreamEvents("my-stream")
    response = proto.ReadStreamEventsCompleted()
    response.result = msg.ReadStreamResult.Success
    response.is_end_of_stream = False
    response.next_event_number = 0
    response.last_event_number = 0
    response.last_commit_position = 0

    await convo.respond_to(
        msg.InboundMessage(
            uuid4(),
            msg.TcpCommand.ReadStreamEventsForwardCompleted,
            response.SerializeToString(),
        ),
        output,
    )

    response.result = msg.ReadStreamResult.AccessDenied

    await convo.respond_to(
        msg.InboundMessage(
            uuid4(),
            msg.TcpCommand.ReadStreamEventsForwardCompleted,
            response.SerializeToString(),
        ),
        output,
    )

    iterator = await convo.result
    with pytest.raises(exceptions.AccessDenied) as exn:
        await iterator.anext()

        assert exn.conversation_id == convo.conversation_id
        assert exn.conversation_type == "IterStreamEvents"

    assert len(output.items) == 1
async def test_stream_deleted():

    convo = ReadStreamEvents("my-stream")
    response = proto.ReadStreamEventsCompleted()
    response.result = msg.ReadStreamResult.StreamDeleted
    response.is_end_of_stream = False
    response.next_event_number = 0
    response.last_event_number = 0
    response.last_commit_position = 0

    await convo.respond_to(
        msg.InboundMessage(
            uuid4(),
            msg.TcpCommand.ReadStreamEventsForwardCompleted,
            response.SerializeToString(),
        ),
        None,
    )

    with pytest.raises(exceptions.StreamDeleted) as exn:
        await convo.result
        assert exn.stream == "my-stream"
        assert exn.conversation_id == convo.conversation_id
async def test_read_error():

    convo = ReadStreamEvents("my-stream")
    response = proto.ReadStreamEventsCompleted()
    response.result = msg.ReadStreamResult.Error
    response.is_end_of_stream = False
    response.next_event_number = 0
    response.last_event_number = 0
    response.last_commit_position = 0
    response.error = "Something really weird just happened"

    await convo.respond_to(
        msg.InboundMessage(
            uuid4(),
            msg.TcpCommand.ReadStreamEventsForwardCompleted,
            response.SerializeToString(),
        ),
        None,
    )

    with pytest.raises(exceptions.ReadError) as exn:
        await convo.result
        assert exn.stream == "my-stream"
        assert exn.conversation_id == convo.conversation_id
Exemplo n.º 11
0
def read_stream_events_completed(conversation_id, stream, events, end_of_stream=False):
    payload = proto.ReadStreamEventsCompleted()
    payload.result = msg.ReadStreamResult.Success
    payload.is_end_of_stream = end_of_stream

    for (idx, event) in enumerate(events):
        payload.next_event_number = idx + 1
        payload.last_event_number = idx
        payload.last_commit_position = idx

        e = payload.events.add()
        e.event.event_stream_id = stream
        e.event.event_number = idx
        e.event.event_id = event.id.bytes_le
        e.event.event_type = event.type
        e.event.data_content_type = msg.ContentType.Json
        e.event.metadata_content_type = msg.ContentType.Binary
        e.event.data = json.dumps(event.data).encode("UTF-8")

    return msg.InboundMessage(
        conversation_id,
        msg.TcpCommand.ReadStreamEventsForwardCompleted,
        payload.SerializeToString(),
    )