qontract-reconcile 0.10.1rc1150__py3-none-any.whl → 0.10.1rc1151__py3-none-any.whl

tools/cli_commands/test/test_aws_cost_report.py

@@ -0,0 +1,258 @@
+from collections.abc import Callable
+from decimal import Decimal
+from typing import Any
+
+import pytest
+from pytest_mock import MockerFixture
+
+from reconcile.typed_queries.cost_report.app_names import App
+from tools.cli_commands.cost_report.aws import AwsCostReportCommand
+from tools.cli_commands.cost_report.model import ChildAppReport, Report, ReportItem
+from tools.cli_commands.cost_report.response import AwsReportCostResponse
+from tools.cli_commands.test.conftest import (
+    COST_REPORT_SECRET,
+)
+
+COST_MANAGEMENT_CONSOLE_BASE_URL = (
+    "https://console.redhat.com/openshift/cost-management"
+)
+
+
+@pytest.fixture
+def mock_gql(mocker: MockerFixture) -> Any:
+    return mocker.patch("tools.cli_commands.cost_report.aws.gql")
+
+
+@pytest.fixture
+def mock_cost_management_api(mocker: MockerFixture) -> Any:
+    return mocker.patch(
+        "tools.cli_commands.cost_report.aws.CostManagementApi",
+        autospec=True,
+    )
+
+
+@pytest.fixture
+def mock_fetch_cost_report_secret(mocker: MockerFixture) -> Any:
+    return mocker.patch(
+        "tools.cli_commands.cost_report.aws.fetch_cost_report_secret",
+        return_value=COST_REPORT_SECRET,
+    )
+
+
+def test_aws_cost_report_create(
+    mock_gql: Any,
+    mock_cost_management_api: Any,
+    mock_fetch_cost_report_secret: Any,
+) -> None:
+    cost_report_command = AwsCostReportCommand.create()
+
+    assert isinstance(cost_report_command, AwsCostReportCommand)
+    assert cost_report_command.gql_api == mock_gql.get_api.return_value
+    assert (
+        cost_report_command.cost_management_console_base_url
+        == COST_MANAGEMENT_CONSOLE_BASE_URL
+    )
+    assert (
+        cost_report_command.cost_management_api
+        == mock_cost_management_api.create_from_secret.return_value
+    )
+    assert cost_report_command.thread_pool_size == 10
+    mock_cost_management_api.create_from_secret.assert_called_once_with(
+        COST_REPORT_SECRET
+    )
+    mock_fetch_cost_report_secret.assert_called_once_with(mock_gql.get_api.return_value)
+
+
+@pytest.fixture
+def aws_cost_report_command(
+    mock_gql: Any,
+    mock_cost_management_api: Any,
+    mock_fetch_cost_report_secret: Any,
+) -> AwsCostReportCommand:
+    return AwsCostReportCommand.create()
+
+
+@pytest.fixture
+def mock_get_app_names(mocker: MockerFixture) -> Any:
+    return mocker.patch("tools.cli_commands.cost_report.aws.get_app_names")
+
+
+PARENT_APP = App(name="parent", parent_app_name=None)
+CHILD_APP = App(name="child", parent_app_name="parent")
+
+
+def test_aws_cost_report_execute(
+    aws_cost_report_command: AwsCostReportCommand,
+    mock_get_app_names: Any,
+    fx: Callable,
+) -> None:
+    expected_output = fx("empty_aws_cost_report.md")
+    mock_get_app_names.return_value = []
+
+    output = aws_cost_report_command.execute()
+
+    assert output.rstrip() == expected_output.rstrip()
+
+
+def test_aws_cost_report_get_apps(
+    aws_cost_report_command: AwsCostReportCommand,
+    mock_get_app_names: Any,
+) -> None:
+    expected_apps = [PARENT_APP, CHILD_APP]
+    mock_get_app_names.return_value = expected_apps
+
+    apps = aws_cost_report_command.get_apps()
+
+    assert apps == expected_apps
+
+
+def aws_report_cost_response_builder(
+    delta_value: int,
+    delta_percent: int,
+    total: int,
+    service: str,
+) -> AwsReportCostResponse:
+    return AwsReportCostResponse.parse_obj({
+        "meta": {
+            "delta": {
+                "value": delta_value,
+                "percent": delta_percent,
+            },
+            "total": {
+                "cost": {
+                    "total": {
+                        "value": total,
+                        "units": "USD",
+                    }
+                }
+            },
+        },
+        "data": [
+            {
+                "date": "2024-02",
+                "services": [
+                    {
+                        "service": service,
+                        "values": [
+                            {
+                                "delta_value": delta_value,
+                                "delta_percent": delta_percent,
+                                "cost": {
+                                    "total": {
+                                        "value": total,
+                                        "units": "USD",
+                                    }
+                                },
+                            }
+                        ],
+                    },
+                ],
+            }
+        ],
+    })
+
+
+PARENT_APP_COST_RESPONSE = aws_report_cost_response_builder(
+    delta_value=100,
+    delta_percent=10,
+    total=1000,
+    service="service1",
+)
+
+CHILD_APP_COST_RESPONSE = aws_report_cost_response_builder(
+    delta_value=200,
+    delta_percent=20,
+    total=2000,
+    service="service2",
+)
+
+PARENT_APP_REPORT = Report(
+    app_name="parent",
+    parent_app_name=None,
+    child_apps=[
+        ChildAppReport(name="child", total=Decimal(2000)),
+    ],
+    child_apps_total=Decimal(2000),
+    date="2024-02",
+    items=[
+        ReportItem(
+            name="service1",
+            delta_value=Decimal(100),
+            delta_percent=10,
+            total=Decimal(1000),
+        )
+    ],
+    items_total=Decimal(1000),
+    items_delta_value=Decimal(100),
+    items_delta_percent=10,
+    total=Decimal(3000),
+)
+
+CHILD_APP_REPORT = Report(
+    app_name="child",
+    parent_app_name="parent",
+    child_apps=[],
+    child_apps_total=Decimal(0),
+    date="2024-02",
+    items=[
+        ReportItem(
+            name="service2",
+            delta_value=Decimal(200),
+            delta_percent=20,
+            total=Decimal(2000),
+        )
+    ],
+    items_total=Decimal(2000),
+    items_delta_value=Decimal(200),
+    items_delta_percent=20,
+    total=Decimal(2000),
+)
+
+
+def test_aws_cost_report_get_reports(
+    aws_cost_report_command: AwsCostReportCommand,
+    mock_cost_management_api: Any,
+) -> None:
+    mocked_api = mock_cost_management_api.create_from_secret.return_value
+    mocked_api.get_aws_costs_report.return_value = PARENT_APP_COST_RESPONSE
+
+    reports = aws_cost_report_command.get_reports([PARENT_APP])
+
+    assert reports == {
+        "parent": PARENT_APP_COST_RESPONSE,
+    }
+    mocked_api.get_aws_costs_report.assert_called_once_with("parent")
+
+
+def test_aws_cost_report_process_reports(
+    aws_cost_report_command: AwsCostReportCommand,
+) -> None:
+    expected_reports = {
+        "parent": PARENT_APP_REPORT,
+        "child": CHILD_APP_REPORT,
+    }
+
+    reports = aws_cost_report_command.process_reports(
+        [PARENT_APP, CHILD_APP],
+        {
+            "parent": PARENT_APP_COST_RESPONSE,
+            "child": CHILD_APP_COST_RESPONSE,
+        },
+    )
+
+    assert reports == expected_reports
+
+
+def test_aws_cost_report_render(
+    aws_cost_report_command: AwsCostReportCommand,
+    fx: Callable,
+) -> None:
+    expected_output = fx("aws_cost_report.md")
+    reports = {
+        "parent": PARENT_APP_REPORT,
+        "child": CHILD_APP_REPORT,
+    }
+
+    output = aws_cost_report_command.render(reports)
+
+    assert output == expected_output

tools/cli_commands/test/test_cost_management_api.py

@@ -0,0 +1,326 @@
+from collections.abc import Callable
+from decimal import Decimal
+from typing import Any
+
+import pytest
+import requests
+from pytest_httpserver import HTTPServer
+from pytest_mock import MockerFixture
+from requests import HTTPError
+
+from tools.cli_commands.cost_report.cost_management_api import CostManagementApi
+from tools.cli_commands.cost_report.response import (
+    AwsReportCostResponse,
+    CostResponse,
+    CostTotalResponse,
+    DeltaResponse,
+    MoneyResponse,
+    OpenShiftCostResponse,
+    OpenShiftReportCostResponse,
+    ProjectCostResponse,
+    ProjectCostValueResponse,
+    ReportMetaResponse,
+    ServiceCostResponse,
+    ServiceCostValueResponse,
+    TotalMetaResponse,
+)
+from tools.cli_commands.test.conftest import (
+    COST_MANAGEMENT_API_HOST,
+    COST_REPORT_SECRET,
+    OPENSHIFT_COST_OPTIMIZATION_RESPONSE,
+)
+
+
+@pytest.fixture
+def mock_session(mocker: MockerFixture) -> Any:
+    return mocker.patch(
+        "tools.cli_commands.cost_report.cost_management_api.OAuth2BackendApplicationSession",
+        autospec=True,
+    )
+
+
+@pytest.fixture
+def base_url(httpserver: HTTPServer) -> str:
+    return httpserver.url_for("/")
+
+
+TOKEN_URL = "token_url"
+CLIENT_ID = COST_REPORT_SECRET["client_id"]
+CLIENT_SECRET = COST_REPORT_SECRET["client_secret"]
+SCOPE = ["scope"]
+
+
+def test_cost_management_api_create_from_secret(
+    mock_session: Any,
+) -> None:
+    api = CostManagementApi.create_from_secret(COST_REPORT_SECRET)
+
+    assert api.host == COST_MANAGEMENT_API_HOST
+    assert api.base_url == COST_REPORT_SECRET["api_base_url"]
+    assert api.session == mock_session.return_value
+    mock_session.assert_called_once_with(
+        client_id=CLIENT_ID,
+        client_secret=CLIENT_SECRET,
+        token_url=TOKEN_URL,
+        scope=SCOPE,
+    )
+
+
+def test_cost_management_api_init(mock_session: Any, base_url: str) -> None:
+    with CostManagementApi(
+        base_url=base_url,
+        token_url=TOKEN_URL,
+        client_id=CLIENT_ID,
+        client_secret=CLIENT_SECRET,
+        scope=SCOPE,
+    ) as api:
+        pass
+
+    assert api.base_url == base_url
+    assert api.session == mock_session.return_value
+
+    mock_session.assert_called_once_with(
+        client_id=CLIENT_ID,
+        client_secret=CLIENT_SECRET,
+        token_url=TOKEN_URL,
+        scope=SCOPE,
+    )
+    assert mock_session.return_value.mount.call_count == 2
+    mock_session.return_value.close.assert_called_once_with()
+
+
+@pytest.fixture
+def cost_management_api(mock_session: Any, base_url: str) -> CostManagementApi:
+    # swap to requests.request to skip oauth2 logic
+    mock_session.return_value.request.side_effect = requests.request
+    return CostManagementApi(
+        base_url=base_url,
+        token_url=TOKEN_URL,
+        client_id=CLIENT_ID,
+        client_secret=CLIENT_SECRET,
+        scope=SCOPE,
+    )
+
+
+EXPECTED_REPORT_COST_RESPONSE = AwsReportCostResponse(
+    meta=ReportMetaResponse(
+        delta=DeltaResponse(
+            value=Decimal(100),
+            percent=10,
+        ),
+        total=TotalMetaResponse(
+            cost=CostTotalResponse(
+                total=MoneyResponse(
+                    value=Decimal(1000),
+                    units="USD",
+                )
+            )
+        ),
+    ),
+    data=[
+        CostResponse(
+            date="2024-02",
+            services=[
+                ServiceCostResponse(
+                    service="AmazonEC2",
+                    values=[
+                        ServiceCostValueResponse(
+                            delta_percent=10,
+                            delta_value=Decimal(200),
+                            cost=CostTotalResponse(
+                                total=MoneyResponse(
+                                    value=Decimal(800),
+                                    units="USD",
+                                )
+                            ),
+                        )
+                    ],
+                ),
+                ServiceCostResponse(
+                    service="AmazonS3",
+                    values=[
+                        ServiceCostValueResponse(
+                            delta_percent=-10,
+                            delta_value=Decimal(-100),
+                            cost=CostTotalResponse(
+                                total=MoneyResponse(
+                                    value=Decimal(200),
+                                    units="USD",
+                                )
+                            ),
+                        )
+                    ],
+                ),
+            ],
+        ),
+    ],
+)
+
+
+def test_get_aws_costs_report(
+    cost_management_api: CostManagementApi,
+    fx: Callable,
+    httpserver: HTTPServer,
+    base_url: str,
+) -> None:
+    response_body = fx("aws_cost_report.json")
+    httpserver.expect_request(
+        "/reports/aws/costs/",
+        query_string={
+            "cost_type": "calculated_amortized_cost",
+            "delta": "cost",
+            "filter[resolution]": "monthly",
+            "filter[tag:app]": "test",
+            "filter[time_scope_units]": "month",
+            "filter[time_scope_value]": "-2",
+            "group_by[service]": "*",
+        },
+    ).respond_with_data(response_body)
+
+    report_cost_response = cost_management_api.get_aws_costs_report(app="test")
+
+    assert report_cost_response == EXPECTED_REPORT_COST_RESPONSE
+
+
+def test_get_aws_costs_report_error(
+    cost_management_api: CostManagementApi,
+    fx: Callable,
+    httpserver: HTTPServer,
+) -> None:
+    httpserver.expect_request("/reports/aws/costs/").respond_with_data(status=500)
+
+    with pytest.raises(HTTPError) as error:
+        cost_management_api.get_aws_costs_report(app="test")
+
+    assert error.value.response.status_code == 500
+
+
+EXPECTED_OPENSHIFT_REPORT_COST_RESPONSE = OpenShiftReportCostResponse(
+    meta=ReportMetaResponse(
+        delta=DeltaResponse(
+            value=Decimal(100),
+            percent=10,
+        ),
+        total=TotalMetaResponse(
+            cost=CostTotalResponse(
+                total=MoneyResponse(
+                    value=Decimal(1000),
+                    units="USD",
+                )
+            )
+        ),
+    ),
+    data=[
+        OpenShiftCostResponse(
+            date="2024-02",
+            projects=[
+                ProjectCostResponse(
+                    project="some-project",
+                    values=[
+                        ProjectCostValueResponse(
+                            delta_percent=10,
+                            delta_value=Decimal(100),
+                            clusters=["some-cluster"],
+                            cost=CostTotalResponse(
+                                total=MoneyResponse(
+                                    value=Decimal(1000),
+                                    units="USD",
+                                )
+                            ),
+                        )
+                    ],
+                ),
+            ],
+        ),
+    ],
+)
+
+
+def test_get_openshift_costs_report(
+    cost_management_api: CostManagementApi,
+    fx: Callable,
+    httpserver: HTTPServer,
+) -> None:
+    response_body = fx("openshift_cost_report.json")
+    project = "some-project"
+    cluster = "some-cluster-uuid"
+    httpserver.expect_request(
+        "/reports/openshift/costs/",
+        query_string={
+            "delta": "cost",
+            "filter[resolution]": "monthly",
+            "filter[cluster]": cluster,
+            "filter[exact:project]": project,
+            "filter[time_scope_units]": "month",
+            "filter[time_scope_value]": "-2",
+            "group_by[project]": "*",
+        },
+    ).respond_with_data(response_body)
+
+    report_cost_response = cost_management_api.get_openshift_costs_report(
+        cluster=cluster,
+        project=project,
+    )
+
+    assert report_cost_response == EXPECTED_OPENSHIFT_REPORT_COST_RESPONSE
+
+
+def test_get_openshift_costs_report_error(
+    cost_management_api: CostManagementApi,
+    fx: Callable,
+    httpserver: HTTPServer,
+) -> None:
+    httpserver.expect_request("/reports/openshift/costs/").respond_with_data(status=500)
+
+    with pytest.raises(HTTPError) as error:
+        cost_management_api.get_openshift_costs_report(
+            cluster="some-cluster",
+            project="some-project",
+        )
+
+    assert error.value.response.status_code == 500
+
+
+def test_get_openshift_cost_optimization_report(
+    cost_management_api: CostManagementApi,
+    fx: Callable,
+    httpserver: HTTPServer,
+) -> None:
+    response_body = fx("openshift_cost_optimization_report.json")
+    project = "some-project"
+    cluster = "some-cluster-uuid"
+    httpserver.expect_request(
+        "/recommendations/openshift",
+        query_string={
+            "cluster": cluster,
+            "project": project,
+            "limit": "100",
+            "memory-unit": "MiB",
+            "cpu-unit": "millicores",
+        },
+    ).respond_with_data(response_body)
+
+    report_cost_response = cost_management_api.get_openshift_cost_optimization_report(
+        cluster=cluster,
+        project=project,
+    )
+
+    assert report_cost_response == OPENSHIFT_COST_OPTIMIZATION_RESPONSE
+
+
+def test_get_openshift_cost_optimization_report_error(
+    cost_management_api: CostManagementApi,
+    fx: Callable,
+    httpserver: HTTPServer,
+) -> None:
+    httpserver.expect_request("/recommendations/openshift").respond_with_data(
+        status=500
+    )
+
+    with pytest.raises(HTTPError) as error:
+        cost_management_api.get_openshift_cost_optimization_report(
+            cluster="some-cluster",
+            project="some-project",
+        )
+
+    assert error.value.response.status_code == 500