def test_filter_conversations_by_request_started_time_rejects_conversations_outside_of_range(
):
    date_range = DateTimeRange(start=datetime(year=2020, month=6, day=1),
                               end=datetime(year=2020, month=7, day=1))

    conversation_within_range = build_parsed_conversation(
        request_started=build_message(
            time=datetime(year=2020, month=6, day=15)))
    conversation_before_range = build_parsed_conversation(
        request_started=build_message(
            time=datetime(year=2020, month=5, day=28)))
    conversation_after_range = build_parsed_conversation(
        request_started=build_message(
            time=datetime(year=2020, month=7, day=28)))

    parsed_conversations = [
        conversation_before_range,
        conversation_within_range,
        conversation_after_range,
    ]

    expected = [conversation_within_range]

    actual = filter_conversations_by_request_started_time(
        parsed_conversations, date_range)

    assert list(actual) == expected
def test_extracts_conversation_ids_for_conversations():
    conversations = [
        build_parsed_conversation(id="1234"),
        build_parsed_conversation(id="3456"),
        build_parsed_conversation(id="5678"),
    ]

    actual = derive_transfers(conversations)

    expected_conversation_ids = ["1234", "3456", "5678"]

    _assert_attributes("conversation_id", actual, expected_conversation_ids)
def test_derive_transfer_extracts_requesting_practice_ods():
    conversation = build_parsed_conversation(request_started=build_message(from_party_ods="A12345"))

    actual = derive_transfer(conversation)

    expected_ods = "A12345"
    assert actual.requesting_practice_ods == expected_ods
def test_extracts_final_error_code():
    conversations = [build_parsed_conversation(request_completed_ack=build_message(error_code=99))]

    actual = derive_transfers(conversations)

    expected_errors = [99]

    _assert_attributes("final_error_code", actual, expected_errors)
def test_derive_transfer_doesnt_extract_error_code_given_pending_request_completed_ack():
    conversation = build_parsed_conversation(request_completed_ack=None)

    actual = derive_transfer(conversation)

    expected_error = None

    assert actual.error_code == expected_error
def test_derive_transfer_extracts_error_code():
    conversation = build_parsed_conversation(request_completed_ack=build_message(error_code=99))

    actual = derive_transfer(conversation)

    expected_error = 99

    assert actual.error_code == expected_error
def test_derive_transfer_extracts_conversation_id():
    conversation = build_parsed_conversation(id="1234")

    actual = derive_transfer(conversation)

    expected_conversation_id = "1234"

    assert actual.conversation_id == expected_conversation_id
def test_extracts_sender_error_code_when_sender_error():
    conversations = [build_parsed_conversation(request_started_ack=build_message(error_code=10))]

    actual = derive_transfers(conversations)

    expected_errors = [10]

    _assert_attributes("sender_error_code", actual, expected_errors)
def test_doesnt_extract_error_code_given_pending_request_completed_ack():
    conversations = [build_parsed_conversation(request_completed_ack=None)]

    actual = derive_transfers(conversations)

    expected_errors = [None]

    _assert_attributes("final_error_code", actual, expected_errors)
def test_extracts_requesting_supplier():
    conversations = [build_parsed_conversation(request_started=build_message(from_system="EMIS"))]

    actual = derive_transfers(conversations)

    expected_supplier_name = ["EMIS"]

    _assert_attributes("requesting_supplier", actual, expected_supplier_name)
def test_extracts_conversation_id():
    conversations = [build_parsed_conversation(id="1234")]

    actual = derive_transfers(conversations)

    expected_conversation_ids = ["1234"]

    _assert_attributes("conversation_id", actual, expected_conversation_ids)
def test_extracts_sending_supplier():
    conversations = [build_parsed_conversation(request_started=build_message(to_system="Vision"))]

    actual = derive_transfers(conversations)

    expected_supplier_name = ["Vision"]

    _assert_attributes("sending_supplier", actual, expected_supplier_name)
def test_extracts_an_intermediate_message_error_code():
    intermediate_messages = [build_message(error_code=20)]
    conversations = [build_parsed_conversation(intermediate_messages=intermediate_messages)]

    actual = derive_transfers(conversations)

    expected_intermediate_error_codes = [[20]]

    _assert_attributes("intermediate_error_codes", actual, expected_intermediate_error_codes)
def test_derive_transfer_produces_no_sla_given_pending_ehr_completed():
    conversation = build_parsed_conversation(
        request_started=build_message(), request_completed=None, request_completed_ack=None,
    )
    actual = derive_transfer(conversation)

    expected_sla_duration = None

    assert actual.sla_duration == expected_sla_duration
def test_intermediate_error_code_is_empty_list_if_no_errors():
    intermediate_messages = [build_message(), build_message(), build_message()]
    conversations = [build_parsed_conversation(intermediate_messages=intermediate_messages)]

    actual = derive_transfers(conversations)

    expected_intermediate_error_codes = [[]]

    _assert_attributes("intermediate_error_codes", actual, expected_intermediate_error_codes)
def test_has_pending_status_if_no_final_ack():
    conversations = [
        build_parsed_conversation(request_started=build_message(), request_completed_ack=None)
    ]

    actual = derive_transfers(conversations)

    expected_statuses = [TransferStatus.PENDING]

    _assert_attributes("status", actual, expected_statuses)
def test_extracts_sending_practice_asid():
    conversations = [
        build_parsed_conversation(request_started=build_message(to_party_asid="121212121212"))
    ]

    actual = derive_transfers(conversations)

    expected_asids = ["121212121212"]

    _assert_attributes("sending_practice_asid", actual, expected_asids)
def test_derive_transfer_flags_pending_request_completed_as_pending():
    conversation = build_parsed_conversation(
        request_started=build_message(), request_completed=None, request_completed_ack=None
    )

    actual = derive_transfer(conversation)

    expected_pending = True

    assert actual.pending == expected_pending
def test_warns_about_conversation_with_negative_sla():
    conversations = [
        build_parsed_conversation(
            request_started=build_message(),
            request_completed=build_message(time=datetime(year=2021, month=1, day=5)),
            request_completed_ack=build_message(time=datetime(year=2021, month=1, day=4)),
        )
    ]

    with pytest.warns(RuntimeWarning):
        list(derive_transfers(conversations))
def test_derive_transfer_flags_completed_conversation_as_not_pending():
    conversation = build_parsed_conversation(
        request_started=build_message(),
        request_completed=build_message(),
        request_completed_ack=build_message(),
    )

    actual = derive_transfer(conversation)

    expected_pending = False

    assert actual.pending == expected_pending
def test_date_completed_is_none_when_request_completed_ack_not_present():
    conversations = [
        build_parsed_conversation(
            request_started=build_message(),
            request_completed=build_message(),
            request_completed_ack=None,
        )
    ]

    actual = derive_transfers(conversations)

    _assert_attributes("date_completed", actual, [None])
def test_extracts_multiple_intermediate_message_error_codes():
    intermediate_messages = [
        build_message(error_code=11),
        build_message(),
        build_message(error_code=10),
    ]
    conversations = [build_parsed_conversation(intermediate_messages=intermediate_messages)]

    actual = derive_transfers(conversations)

    expected_intermediate_error_codes = [[11, 10]]

    _assert_attributes("intermediate_error_codes", actual, expected_intermediate_error_codes)
def test_produces_no_sla_given_pending_request_completed_ack():
    conversations = [
        build_parsed_conversation(
            request_started=build_message(),
            request_completed=build_message(),
            request_completed_ack=None,
        )
    ]

    actual = derive_transfers(conversations)

    expected_sla_durations = [None]

    _assert_attributes("sla_duration", actual, expected_sla_durations)
def test_has_integrated_status_if_error_is_supressed():
    conversations = [
        build_parsed_conversation(
            request_started=build_message(),
            request_completed=build_message(),
            request_completed_ack=build_message(error_code=ERROR_SUPPRESSED),
        )
    ]

    actual = derive_transfers(conversations)

    expected_statuses = [TransferStatus.INTEGRATED]

    _assert_attributes("status", actual, expected_statuses)
def test_has_failed_status_if_error_in_final_ack():
    conversations = [
        build_parsed_conversation(
            request_started=build_message(),
            request_completed=build_message(),
            request_completed_ack=build_message(error_code=30),
        )
    ]

    actual = derive_transfers(conversations)

    expected_statuses = [TransferStatus.FAILED]

    _assert_attributes("status", actual, expected_statuses)
def test_negative_sla_duration_clamped_to_zero():
    conversations = [
        build_parsed_conversation(
            request_started=build_message(),
            request_completed=build_message(time=datetime(year=2021, month=1, day=5)),
            request_completed_ack=build_message(time=datetime(year=2021, month=1, day=4)),
        )
    ]

    expected_sla = timedelta(0)

    actual = derive_transfers(conversations)

    _assert_attributes("sla_duration", actual, [expected_sla])
def test_extracts_date_requested_from_request_started_message():
    date_requested = a_datetime()

    conversations = [
        build_parsed_conversation(
            request_started=build_message(time=date_requested),
            request_completed=build_message(),
            request_completed_ack=build_message(),
        )
    ]

    actual = derive_transfers(conversations)

    _assert_attributes("date_requested", actual, [date_requested])
def test_filter_conversations_by_request_started_time_rejects_conversation_on_range_end():
    from_time = datetime(year=2020, month=6, day=1)
    to_time = datetime(year=2020, month=7, day=1)
    parsed_conversations = [
        build_parsed_conversation(
            request_started=build_message(time=datetime(year=2020, month=7, day=1))
        )
    ]

    expected = []

    actual = filter_conversations_by_request_started_time(parsed_conversations, from_time, to_time)

    assert list(actual) == expected
def test_filter_conversations_by_request_started_time_accepts_conversation_on_range_start(
):
    date_range = DateTimeRange(start=datetime(year=2020, month=6, day=1),
                               end=datetime(year=2020, month=7, day=1))
    parsed_conversations = [
        build_parsed_conversation(request_started=build_message(
            time=datetime(year=2020, month=6, day=1)))
    ]

    expected = parsed_conversations

    actual = filter_conversations_by_request_started_time(
        parsed_conversations, date_range)

    assert list(actual) == expected
def test_has_pending_with_error_status_if_error_in_intermediate_message():
    conversations = [
        build_parsed_conversation(
            request_started=build_message(),
            request_completed=build_message(),
            intermediate_messages=[build_message(error_code=30)],
            request_completed_ack=None,
        )
    ]

    actual = derive_transfers(conversations)

    expected_statuses = [TransferStatus.PENDING_WITH_ERROR]

    _assert_attributes("status", actual, expected_statuses)