def test_optional_rule_matching_OPEN_CLOSE_CONNECTION():
    client_messages = make_messages("C:protocol-header",
                                    "C:connection.start-ok",
                                    "C:connection.tune-ok",
                                    "C:connection.open",
                                    "C:connection.close")
    server_messages = make_messages("S:connection.start",
                                    "S:connection.tune",
                                    "S:connection.open-ok",
                                    "S:connection.close-ok")
    protocol_analyzer = ProtocolDetective(client_messages, server_messages)

    protocol_analyzer._analyze_protocol_part("protocol")
    result = protocol_analyzer.processed_messages

    assert len(result) == 9
    assert result == make_messages("C:protocol-header",
                                   "S:connection.start",
                                   "C:connection.start-ok",
                                   "S:connection.tune",
                                   "C:connection.tune-ok",
                                   "C:connection.open",
                                   "S:connection.open-ok",
                                   "C:connection.close",
                                   "S:connection.close-ok"
                                   )
    assert all([not message.out_of_order for message in result])
def test_atomic_rule_matching_DELIVER():
    client_messages = []
    server_messages = make_messages("S:basic.deliver",
                                    "S:BODY")
    protocol_analyzer = ProtocolDetective(client_messages, server_messages)

    protocol_analyzer._analyze_protocol_part("deliver")
    result = protocol_analyzer.processed_messages

    assert len(result) == 2
    assert result == make_messages("S:basic.deliver", "S:BODY")
    assert all([not message.out_of_order for message in result])
def test_atomic_rule_matching_SINGLE_CHALLENGE_EXCHANGE():
    client_messages = make_messages("C:connection.secure-ok")
    server_messages = make_messages("S:connection.secure")
    protocol_analyzer = ProtocolDetective(client_messages, server_messages)

    protocol_analyzer._analyze_protocol_part("challenge")
    result = protocol_analyzer.processed_messages

    assert len(result) == 2
    assert result == make_messages("S:connection.secure",
                                   "C:connection.secure-ok")
    assert all([not message.out_of_order for message in result])
def test_atomic_rule_matching_PUBLISH():
    client_messages = make_messages("C:basic.publish",
                                    "C:HEADER",
                                    "C:BODY")
    server_messages = []
    protocol_analyzer = ProtocolDetective(client_messages, server_messages)

    protocol_analyzer._analyze_protocol_part("publish")
    result = protocol_analyzer.processed_messages

    assert len(result) == 3
    assert result == make_messages("C:basic.publish",
                                   "C:HEADER",
                                   "C:BODY")
    assert all([not message.out_of_order for message in result])
def test_atomic_rule_matching_SINGLE_CHALLENGE_EXCHANGE_ignore_heartbeats():
    client_messages = make_messages("C:HEARTBEAT", "C:connection.secure-ok")
    server_messages = make_messages("S:HEARTBEAT", "S:connection.secure")
    protocol_analyzer = ProtocolDetective(client_messages, server_messages)

    protocol_analyzer._analyze_protocol_part("challenge")
    result = protocol_analyzer.processed_messages

    assert len(result) == 4
    for message in make_messages("S:HEARTBEAT",
                                 "C:HEARTBEAT",
                                 "S:connection.secure",
                                 "C:connection.secure-ok"):
        assert message in result  # heartbeat frames could be anywhere in between
    server_request = get_message("S:connection.secure")
    client_response = get_message("C:connection.secure-ok")
    assert result.index(server_request) < result.index(client_response), \
        "Server request should have been before client response: %s" % result
    assert all([not message.out_of_order for message in result])
def test_alternative_rule_matching_CLOSE_CONNECTION():
    # test client initiated close
    client_messages = make_messages("C:connection.close")
    server_messages = make_messages("S:connection.close-ok")
    protocol_analyzer = ProtocolDetective(client_messages, server_messages)

    protocol_analyzer._analyze_protocol_part("close-connection")
    result = protocol_analyzer.processed_messages

    assert len(result) == 2
    assert result == make_messages("C:connection.close",
                                   "S:connection.close-ok")
    assert all([not message.out_of_order for message in result])

    # test server initiated close
    client_messages = make_messages("C:connection.close-ok")
    server_messages = make_messages("S:connection.close")
    protocol_analyzer = ProtocolDetective(client_messages, server_messages)

    protocol_analyzer._analyze_protocol_part("close-connection")
    result = protocol_analyzer.processed_messages

    assert len(result) == 2
    assert result == make_messages("S:connection.close",
                                   "C:connection.close-ok")
    assert all([not message.out_of_order for message in result])
def test_repetitive_rule_matching_CHANNEL():
    client_messages = make_messages("C:channel.open",
                                    "C:channel.flow",
                                    "C:basic.consume",
                                    "C:basic.publish",
                                    "C:HEADER",
                                    "C:BODY",
                                    "C:basic.ack",
                                    "C:channel.close")
    server_messages = make_messages("S:channel.open-ok",
                                    "S:channel.flow-ok",
                                    "S:basic.consume-ok",
                                    "S:basic.ack",
                                    "S:basic.ack",
                                    "S:basic.ack",
                                    "S:channel.close-ok")

    protocol_analyzer = ProtocolDetective(client_messages, server_messages)

    protocol_analyzer._analyze_protocol_part("channel")
    result = protocol_analyzer.processed_messages

    assert len(result) == 15
    assert result == make_messages("C:channel.open",
                                   "S:channel.open-ok",
                                   "C:channel.flow",
                                   "S:channel.flow-ok",
                                   "C:basic.consume",
                                   "S:basic.consume-ok",
                                   "C:basic.publish",
                                   "S:basic.ack",
                                   "C:HEADER",
                                   "S:basic.ack",
                                   "C:BODY",
                                   "S:basic.ack",
                                   "C:basic.ack",
                                   "C:channel.close",
                                   "S:channel.close-ok")
    assert all([not message.out_of_order for message in result])