notifications-admin/tests/app/main/views/test_jobs.py

import json
from datetime import datetime, timezone

import pytest
from flask import url_for
from freezegun import freeze_time
from hypothesis import HealthCheck, given, settings
from hypothesis import strategies as st

from app.main.views.jobs import get_time_left
from tests import job_json, sample_uuid, user_json
from tests.conftest import (
    SERVICE_ONE_ID,
    create_active_caseworking_user,
    create_active_user_with_permissions,
    normalize_spaces,
)


def test_old_jobs_hub_redirects(
    client_request,
):
    client_request.get(
        "main.view_jobs",
        service_id=SERVICE_ONE_ID,
        _expected_status=302,
        _expected_redirect=url_for(
            "main.uploads",
            service_id=SERVICE_ONE_ID,
        ),
    )


@pytest.mark.parametrize(
    "user",
    [
        create_active_user_with_permissions(),
        create_active_caseworking_user(),
    ],
)
@pytest.mark.parametrize(
    ("status_argument", "expected_api_call"),
    [
        (
            "",
            [
                "created",
                "pending",
                "sending",
                "delivered",
                "sent",
                "failed",
                "temporary-failure",
                "permanent-failure",
                "technical-failure",
                "validation-failed",
            ],
        ),
        ("sending", ["sending", "created", "pending"]),
        ("delivered", ["delivered", "sent"]),
        (
            "failed",
            [
                "failed",
                "temporary-failure",
                "permanent-failure",
                "technical-failure",
                "validation-failed",
            ],
        ),
    ],
)
@freeze_time("2016-01-01 11:09:00.061258")
def test_should_show_page_for_one_job(
    client_request,
    mock_get_service_template,
    mock_get_job,
    mocker,
    mock_get_notifications,
    mock_get_service_data_retention,
    fake_uuid,
    status_argument,
    expected_api_call,
    user,
):
    page = client_request.get(
        "main.view_job",
        service_id=SERVICE_ONE_ID,
        job_id=fake_uuid,
        status=status_argument,
    )

    assert page.h1.text.strip() == "Message status"
    assert " ".join(page.find("tbody").find("tr").text.split()) == (
        "2021234567 template content Delivered 01-01-2016 at 06:09 AM"
    )
    client_request.get_response(
        "main.view_job_updates",
        service_id=SERVICE_ONE_ID,
        job_id=fake_uuid,
        status=status_argument,
    )
    mock_get_notifications.assert_called()
    csv_link = page.select_one("a[download]")
    assert csv_link["href"] == url_for(
        "main.view_job_csv",
        service_id=SERVICE_ONE_ID,
        job_id=fake_uuid,
        status=status_argument,
    )
    assert csv_link.text == "Download this report (CSV)"
    assert page.find("span", {"id": "time-left"}).text == "Data available for 7 days"

    assert normalize_spaces(page.select_one("tbody tr").text) == normalize_spaces(
        "2021234567 " "template content " "Delivered 01-01-2016 at 06:09 AM"
    )
    assert page.select_one("tbody tr a")["href"] == url_for(
        "main.view_notification",
        service_id=SERVICE_ONE_ID,
        notification_id=sample_uuid(),
        from_job=fake_uuid,
    )

    mock_get_notifications.assert_called_with(
        SERVICE_ONE_ID, fake_uuid, status=expected_api_call
    )


@freeze_time("2016-01-01 11:09:00.061258")
def test_should_show_page_for_one_job_with_flexible_data_retention(
    client_request,
    active_user_with_permissions,
    mock_get_service_template,
    mock_get_job,
    mocker,
    mock_get_notifications,
    mock_get_service_data_retention,
    fake_uuid,
):
    mock_get_service_data_retention.side_effect = [
        [{"days_of_retention": 10, "notification_type": "sms"}]
    ]
    page = client_request.get(
        "main.view_job", service_id=SERVICE_ONE_ID, job_id=fake_uuid, status="delivered"
    )

    assert page.find("span", {"id": "time-left"}).text == "Data available for 10 days"
    assert "Cancel sending these letters" not in page


def test_get_jobs_should_tell_user_if_more_than_one_page(
    client_request,
    fake_uuid,
    service_one,
    mock_get_job,
    mock_get_service_template,
    mock_get_notifications_with_previous_next,
    mock_get_service_data_retention,
):
    page = client_request.get(
        "main.view_job",
        service_id=service_one["id"],
        job_id=fake_uuid,
        status="",
    )
    assert (
        page.find("p", {"class": "table-show-more-link"}).text.strip()
        == "Only showing the first 50 rows"
    )


def test_should_show_job_in_progress(
    client_request,
    service_one,
    active_user_with_permissions,
    mock_get_service_template,
    mock_get_job_in_progress,
    mocker,
    mock_get_notifications,
    mock_get_service_data_retention,
    fake_uuid,
):
    page = client_request.get(
        "main.view_job",
        service_id=service_one["id"],
        job_id=fake_uuid,
    )
    assert [
        normalize_spaces(link.text)
        for link in page.select(".pill a:not(.pill-item--selected)")
    ] == [
        "10 pending text messages",
        "0 delivered text messages",
        "0 failed text messages",
    ]
    assert page.select_one("p.hint").text.strip() == "Report is 50% complete…"


def test_should_show_job_without_notifications(
    client_request,
    service_one,
    active_user_with_permissions,
    mock_get_service_template,
    mock_get_job_in_progress,
    mocker,
    mock_get_notifications_with_no_notifications,
    mock_get_service_data_retention,
    fake_uuid,
):
    page = client_request.get(
        "main.view_job",
        service_id=service_one["id"],
        job_id=fake_uuid,
    )
    assert [
        normalize_spaces(link.text)
        for link in page.select(".pill a:not(.pill-item--selected)")
    ] == [
        "10 pending text messages",
        "0 delivered text messages",
        "0 failed text messages",
    ]
    assert page.select_one("p.hint").text.strip() == "Report is 50% complete…"
    assert page.select_one("tbody").text.strip() == "No messages to show yet…"


def test_should_show_job_with_sending_limit_exceeded_status(
    client_request,
    service_one,
    active_user_with_permissions,
    mock_get_service_template,
    mock_get_job_with_sending_limits_exceeded,
    mock_get_notifications_with_no_notifications,
    mock_get_service_data_retention,
    fake_uuid,
):
    page = client_request.get(
        "main.view_job",
        service_id=service_one["id"],
        job_id=fake_uuid,
    )

    assert normalize_spaces(page.select("main p")[3].text) == (
        "Notify cannot send these messages because you have reached a limit. "
        "You can only send 1,000 messages per day and 250,000 messages in total."
    )
    assert normalize_spaces(page.select("main p")[4].text) == (
        "Upload this spreadsheet again tomorrow or contact the Notify.gov team to raise the limit."
    )


@freeze_time("2020-01-10 1:0:0")
@pytest.mark.parametrize(
    ("created_at", "processing_started", "expected_message"),
    [
        # Recently created, not yet started
        (datetime(2020, 1, 10, 0, 0, 0), None, ("No messages to show yet…")),
        # Just started
        (
            datetime(2020, 1, 10, 0, 0, 0),
            datetime(2020, 1, 10, 0, 0, 1),
            ("No messages to show yet…"),
        ),
        # Created a while ago, just started
        (
            datetime(2020, 1, 1, 0, 0, 0),
            datetime(2020, 1, 10, 0, 0, 1),
            ("No messages to show yet…"),
        ),
        # Created a while ago, started just within the last 24h
        # TODO -- fails locally, should pass, tech debt due to timezone changes, re-evaluate after UTC changes
        pytest.param(
            datetime(2020, 1, 1, 0, 0, 0),
            datetime(2020, 1, 9, 6, 0, 1),
            ("No messages to show yet…"),
        ),
        # Created a while ago, started exactly 24h ago
        # ---
        # It doesn’t matter that 24h (1 day) and 7 days (the service’s data
        # retention) don’t match up. We’re testing the case of no
        # notifications existing more than 1 day after the job started
        # processing. In this case we assume it’s because the service’s
        # data retention has kicked in.
        (
            datetime(2020, 1, 1, 0, 0, 0),
            datetime(2020, 1, 9, 1, 0, 0),
            (
                "These messages have been deleted because they were sent more than 7 days ago"
            ),
        ),
    ],
)
def test_should_show_old_job(
    client_request,
    service_one,
    active_user_with_permissions,
    mock_get_service_template,
    mocker,
    mock_get_notifications_with_no_notifications,
    mock_get_service_data_retention,
    fake_uuid,
    created_at,
    processing_started,
    expected_message,
):
    mocker.patch(
        "app.job_api_client.get_job",
        return_value={
            "data": job_json(
                SERVICE_ONE_ID,
                active_user_with_permissions,
                created_at=created_at.replace(tzinfo=timezone.utc).isoformat(),
                processing_started=(
                    processing_started.replace(tzinfo=timezone.utc).isoformat()
                    if processing_started
                    else None
                ),
            ),
        },
    )
    page = client_request.get(
        "main.view_job",
        service_id=SERVICE_ONE_ID,
        job_id=fake_uuid,
    )
    assert not page.select("p.hint")
    assert not page.select("a[download]")
    assert page.select_one("tbody").text.strip() == expected_message
    assert [
        normalize_spaces(column.text) for column in page.select("main .pill .pill-item")
    ] == [
        "1 total text messages",
        "1 pending text message",
        "0 delivered text messages",
        "0 failed text messages",
    ]


@freeze_time("2016-01-01T06:00:00.061258")
def test_should_show_scheduled_job(
    client_request,
    mock_get_service_template,
    mock_get_scheduled_job,
    mock_get_service_data_retention,
    mock_get_notifications,
    fake_uuid,
):
    page = client_request.get(
        "main.view_job",
        service_id=SERVICE_ONE_ID,
        job_id=fake_uuid,
    )

    assert normalize_spaces(page.select("main div p")[1].text) == (
        "Example template - service one was scheduled on January 02, 2016 at 12:00 AM America/New_York by Test User"
    )

    assert page.select("main p a")[0]["href"] == url_for(
        "main.message_status",
    )
    assert page.select_one("main button[type=submit]").text.strip() == "Cancel sending"


def test_should_cancel_job(
    client_request,
    fake_uuid,
    mock_get_job,
    mock_get_service_template,
    mocker,
):
    mock_cancel = mocker.patch("app.job_api_client.cancel_job")
    client_request.post(
        "main.cancel_job",
        service_id=SERVICE_ONE_ID,
        job_id=fake_uuid,
        _expected_status=302,
        _expected_redirect=url_for(
            "main.service_dashboard",
            service_id=SERVICE_ONE_ID,
        ),
    )

    mock_cancel.assert_called_once_with(SERVICE_ONE_ID, fake_uuid)


@settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
@given(fuzzed_uuid=st.uuids())
def test_should_not_show_cancelled_job(
    client_request, active_user_with_permissions, mock_get_cancelled_job, fuzzed_uuid
):
    client_request.get(
        "main.view_job",
        service_id=SERVICE_ONE_ID,
        job_id=fuzzed_uuid,
        _expected_status=404,
    )


@freeze_time("2016-01-01 05:00:00.000001")
def test_should_show_updates_for_one_job_as_json(
    client_request,
    service_one,
    active_user_with_permissions,
    mock_get_notifications,
    mock_get_service_template,
    mock_get_job,
    mock_get_service_data_retention,
    mocker,
    fake_uuid,
):
    response = client_request.get_response(
        "main.view_job_updates",
        service_id=service_one["id"],
        job_id=fake_uuid,
    )

    content = json.loads(response.get_data(as_text=True))
    assert "pending" in content["counts"]
    assert "delivered" in content["counts"]
    assert "failed" in content["counts"]
    assert "Recipient" in content["notifications"]
    assert "2021234567" in content["notifications"]
    assert "Message status" in content["notifications"]
    assert "Delivered" in content["notifications"]
    assert "01-01-2016 at 12:00 AM" in content["notifications"]


@freeze_time("2016-01-01 05:00:00.000001")
def test_should_show_updates_for_scheduled_job_as_json(
    client_request,
    service_one,
    active_user_with_permissions,
    mock_get_notifications,
    mock_get_service_template,
    mock_get_service_data_retention,
    mocker,
    fake_uuid,
):
    mocker.patch(
        "app.job_api_client.get_job",
        return_value={
            "data": job_json(
                service_one["id"],
                created_by=user_json(),
                job_id=fake_uuid,
                scheduled_for="2016-06-01T18:00:00+00:00",
                processing_started="2016-06-01T20:00:00+00:00",
            )
        },
    )

    response = client_request.get_response(
        "main.view_job_updates",
        service_id=service_one["id"],
        job_id=fake_uuid,
    )

    content = response.json
    assert "pending" in content["counts"]
    assert "delivered" in content["counts"]
    assert "failed" in content["counts"]
    assert "Recipient" in content["notifications"]
    assert "2021234567" in content["notifications"]
    assert "Message status" in content["notifications"]
    assert "Delivered" in content["notifications"]
    assert "01-01-2016 at 12:00 AM" in content["notifications"]


@pytest.mark.parametrize(
    ("job_created_at", "expected_message"),
    [
        ("2016-01-10 11:09:00.000000+00:00", "Data available for 8 days"),
        ("2016-01-04 11:09:00.000000+00:00", "Data available for 2 days"),
        ("2016-01-03 11:09:00.000000+00:00", "Data available for 1 day"),
        ("2016-01-02 11:09:00.000000+00:00", "Data available for 12 hours"),
        ("2016-01-01 23:59:59.000000+00:00", "Data no longer available"),
    ],
)
@freeze_time("2016-01-10 12:00:00.000000")
def test_time_left(job_created_at, expected_message):
    assert get_time_left(job_created_at) == expected_message


def test_should_show_message_note(
    client_request,
    mock_get_service_template,
    mock_get_scheduled_job,
    mock_get_service_data_retention,
    mock_get_notifications,
    fake_uuid,
):
    page = client_request.get(
        "main.view_job",
        service_id=SERVICE_ONE_ID,
        job_id=fake_uuid,
    )

    assert normalize_spaces(page.select_one("main p.notification-status").text) == (
        'Messages are sent immediately to the cell phone carrier, but will remain in "pending" status until we hear '
        "back from the carrier they have received it and attempted deliver. More information on delivery status."
    )