Example #1
0
async def drop_subscription(convo, reason=SubscriptionDropReason):

    response = proto.SubscriptionDropped()
    response.reason = reason

    await convo.respond_to(
        InboundMessage(uuid4(), TcpCommand.SubscriptionDropped,
                       response.SerializeToString()),
        None,
    )
Example #2
0
async def test_ping_response():

    output = TeeQueue()
    conversation = Ping()
    await conversation.start(output)

    await conversation.respond_to(
        InboundMessage(conversation.conversation_id, TcpCommand.Pong, b""),
        output)

    assert conversation.is_complete
Example #3
0
async def complete_subscription(convo, result):
    response = proto.CreatePersistentSubscriptionCompleted()
    response.result = result

    await convo.respond_to(
        InboundMessage(
            uuid4(),
            TcpCommand.CreatePersistentSubscriptionCompleted,
            response.SerializeToString(),
        ),
        None,
    )
Example #4
0
async def confirm_subscription(convo, output_queue=None, event_number=1, commit_pos=1):

    response = proto.SubscriptionConfirmation()
    response.last_event_number = event_number
    response.last_commit_position = commit_pos

    await convo.respond_to(
        InboundMessage(
            uuid4(), TcpCommand.SubscriptionConfirmation, response.SerializeToString()
        ),
        output_queue,
    )

    return await convo.result
Example #5
0
async def test_when_server_responds_to_heartbeat():

    output = TeeQueue()

    id = uuid4()
    conversation = Heartbeat(id, direction=Heartbeat.OUTBOUND)

    await conversation.respond_to(
        InboundMessage(conversation.conversation_id,
                       TcpCommand.HeartbeatResponse, b""),
        output,
    )
    await conversation.result

    assert conversation.is_complete
async def test_when_receiving_a_heartbeat_request():
    """
    When we receive a HeartbeatRequest from the server, we should
    immediately respond with a HeartbeatResponse
    """
    out_queue = TeeQueue()
    pace_maker = PaceMaker(out_queue, None)

    heartbeat_id = uuid.uuid4()

    await pace_maker.handle_request(
        InboundMessage(heartbeat_id, TcpCommand.HeartbeatRequest, bytes())
    )

    response = await out_queue.get()
    assert response == OutboundMessage(
        heartbeat_id, TcpCommand.HeartbeatResponse, bytes()
    )
Example #7
0
async def confirm_subscription(convo,
                               commit=23,
                               event_number=56,
                               subscription_id="FUUBARRBAXX",
                               queue=None):

    response = proto.PersistentSubscriptionConfirmation()
    response.last_commit_position = commit
    response.last_event_number = event_number
    response.subscription_id = subscription_id

    await convo.respond_to(
        InboundMessage(
            convo.conversation_id,
            TcpCommand.PersistentSubscriptionConfirmation,
            response.SerializeToString(),
        ),
        queue,
    )
Example #8
0
async def test_when_the_conversation_raises_an_error():
    """
    If the conversation raises an error, that error should be returned
    to the caller.
    """
    out_queue = TeeQueue()
    dispatcher = MessageDispatcher()
    conversation = Ping()
    future = await dispatcher.start_conversation(conversation)

    await dispatcher.dispatch(
        InboundMessage(conversation.conversation_id,
                       TcpCommand.NotAuthenticated, bytes()),
        out_queue,
    )

    with pytest.raises(NotAuthenticated):
        await asyncio.wait_for(future, 1)

    assert not dispatcher.has_conversation(conversation.conversation_id)
async def test_when_the_heartbeat_succeeds():
    """
    If the heartbeat receives a response within the timeout period
    we should record the success.
    """

    heartbeat_id = uuid.uuid4()
    out_queue = TeeQueue()
    connector = FakeConnector()
    pace_maker = PaceMaker(out_queue, connector, heartbeat_id=heartbeat_id)

    await pace_maker.send_heartbeat()
    await pace_maker.handle_response(
        InboundMessage(heartbeat_id, TcpCommand.HeartbeatResponse, bytes())
    )

    await pace_maker.await_heartbeat_response()

    assert connector.failures == []
    assert connector.successes == 1
Example #10
0
async def test_persistent_subscription_already_exists():

    output = Queue()
    convo = CreatePersistentSubscription("my-other-subscription",
                                         "my-other-stream")

    await convo.start(output)

    response = proto.CreatePersistentSubscriptionCompleted()
    response.result = SubscriptionResult.AlreadyExists
    await convo.respond_to(
        InboundMessage(
            uuid4(),
            TcpCommand.CreatePersistentSubscriptionCompleted,
            response.SerializeToString(),
        ),
        output,
    )

    with pytest.raises(exceptions.SubscriptionCreationFailed):
        await convo.result
Example #11
0
def event_appeared(event_id, commit_position=1, prepare_position=1):
    message_id = uuid4()
    response = proto.StreamEventAppeared()

    response.event.event.event_stream_id = "stream-123"
    response.event.event.event_number = 32
    response.event.event.event_id = event_id.bytes_le
    response.event.event.event_type = "event-type"
    response.event.event.data_content_type = ContentType.Json
    response.event.event.metadata_content_type = ContentType.Binary
    response.event.commit_position = commit_position
    response.event.prepare_position = prepare_position
    response.event.event.data = """
    {
        'color': 'blue',
        'winner': false
    }
    """.encode("UTF-8")

    return InboundMessage(message_id, TcpCommand.StreamEventAppeared,
                          response.SerializeToString())
Example #12
0
async def test_stream_event_appeared():
    convo = ConnectPersistentSubscription("my-subscription",
                                          "my-stream",
                                          max_in_flight=57)

    event_id = uuid4()
    await confirm_subscription(convo)
    response = event_appeared(event_id)

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

    subscription = await convo.result
    event = await subscription.events.anext()

    assert event.event.id == event_id
Example #13
0
async def test_when_the_conversation_receives_an_unexpected_response():
    """
    If the conversation receives an unhandled response, an error should
    be returned to the caller. This is a separate code path for now, but
    should probably be cleaned up in the Conversation. Maybe use a decorator?
    """

    out_queue = TeeQueue()
    dispatcher = MessageDispatcher()
    conversation = Ping()
    future = await dispatcher.start_conversation(conversation)

    await dispatcher.dispatch(
        InboundMessage(conversation.conversation_id,
                       TcpCommand.WriteEventsCompleted, bytes()),
        out_queue,
    )

    with pytest.raises(PayloadUnreadable):
        await asyncio.wait_for(future, 1)

    assert not dispatcher.has_conversation(conversation.conversation_id)