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

tools/cli_commands/test/test_openshift_cost_report.py

@@ -0,0 +1,295 @@
+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 reconcile.typed_queries.cost_report.cost_namespaces import (
+    CostNamespace,
+    CostNamespaceLabels,
+)
+from tools.cli_commands.cost_report.model import ChildAppReport, Report, ReportItem
+from tools.cli_commands.cost_report.openshift import OpenShiftCostReportCommand
+from tools.cli_commands.cost_report.response import OpenShiftReportCostResponse
+from tools.cli_commands.test.conftest import (
+    COST_REPORT_SECRET,
+)
+
+
+@pytest.fixture
+def mock_gql(mocker: MockerFixture) -> Any:
+    return mocker.patch("tools.cli_commands.cost_report.openshift.gql")
+
+
+@pytest.fixture
+def mock_cost_management_api(mocker: MockerFixture) -> Any:
+    return mocker.patch(
+        "tools.cli_commands.cost_report.openshift.CostManagementApi",
+        autospec=True,
+    )
+
+
+@pytest.fixture
+def mock_fetch_cost_report_secret(mocker: MockerFixture) -> Any:
+    return mocker.patch(
+        "tools.cli_commands.cost_report.openshift.fetch_cost_report_secret",
+        return_value=COST_REPORT_SECRET,
+    )
+
+
+def test_openshift_cost_report_create(
+    mock_gql: Any,
+    mock_cost_management_api: Any,
+    mock_fetch_cost_report_secret: Any,
+) -> None:
+    openshift_cost_report_command = OpenShiftCostReportCommand.create()
+
+    assert isinstance(openshift_cost_report_command, OpenShiftCostReportCommand)
+    assert openshift_cost_report_command.gql_api == mock_gql.get_api.return_value
+    assert (
+        openshift_cost_report_command.cost_management_api
+        == mock_cost_management_api.create_from_secret.return_value
+    )
+    assert openshift_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 openshift_cost_report_command(
+    mock_gql: Any,
+    mock_cost_management_api: Any,
+    mock_fetch_cost_report_secret: Any,
+) -> OpenShiftCostReportCommand:
+    return OpenShiftCostReportCommand.create()
+
+
+@pytest.fixture
+def mock_get_app_names(mocker: MockerFixture) -> Any:
+    return mocker.patch("tools.cli_commands.cost_report.openshift.get_app_names")
+
+
+@pytest.fixture
+def mock_get_cost_namespaces(mocker: MockerFixture) -> Any:
+    return mocker.patch("tools.cli_commands.cost_report.openshift.get_cost_namespaces")
+
+
+PARENT_APP = App(name="parent", parent_app_name=None)
+CHILD_APP = App(name="child", parent_app_name="parent")
+
+PARENT_APP_NAMESPACE = CostNamespace(
+    name="parent_namespace",
+    labels=CostNamespaceLabels(),
+    app_name=PARENT_APP.name,
+    cluster_name="parent_cluster",
+    cluster_external_id="parent_cluster_external_id",
+)
+CHILD_APP_NAMESPACE = CostNamespace(
+    name="child_namespace",
+    labels=CostNamespaceLabels(),
+    app_name=CHILD_APP.name,
+    cluster_name="child_cluster",
+    cluster_external_id="child_cluster_external_id",
+)
+
+
+def test_openshift_cost_report_execute(
+    openshift_cost_report_command: OpenShiftCostReportCommand,
+    mock_get_app_names: Any,
+    mock_get_cost_namespaces: Any,
+    fx: Callable,
+) -> None:
+    expected_output = fx("empty_openshift_cost_report.md")
+
+    mock_get_app_names.return_value = []
+    mock_get_cost_namespaces.return_value = []
+
+    output = openshift_cost_report_command.execute()
+
+    assert output.rstrip() == expected_output.rstrip()
+
+
+def test_openshift_cost_report_get_apps(
+    openshift_cost_report_command: OpenShiftCostReportCommand,
+    mock_get_app_names: Any,
+) -> None:
+    expected_apps = [PARENT_APP, CHILD_APP]
+    mock_get_app_names.return_value = expected_apps
+
+    apps = openshift_cost_report_command.get_apps()
+
+    assert apps == expected_apps
+
+
+def test_openshift_cost_report_get_cost_namespaces(
+    openshift_cost_report_command: OpenShiftCostReportCommand,
+    mock_get_cost_namespaces: Any,
+) -> None:
+    expected_namespaces = [PARENT_APP_NAMESPACE, CHILD_APP_NAMESPACE]
+    mock_get_cost_namespaces.return_value = expected_namespaces
+
+    apps = openshift_cost_report_command.get_cost_namespaces()
+
+    assert apps == expected_namespaces
+
+
+def openshift_report_cost_response_builder(
+    delta_value: int,
+    delta_percent: int,
+    total: int,
+    project: str,
+    cluster: str,
+) -> OpenShiftReportCostResponse:
+    return OpenShiftReportCostResponse.parse_obj({
+        "meta": {
+            "delta": {
+                "value": delta_value,
+                "percent": delta_percent,
+            },
+            "total": {
+                "cost": {
+                    "total": {
+                        "value": total,
+                        "units": "USD",
+                    }
+                }
+            },
+        },
+        "data": [
+            {
+                "date": "2024-02",
+                "projects": [
+                    {
+                        "project": project,
+                        "values": [
+                            {
+                                "delta_value": delta_value,
+                                "delta_percent": delta_percent,
+                                "clusters": [cluster],
+                                "cost": {
+                                    "total": {
+                                        "value": total,
+                                        "units": "USD",
+                                    }
+                                },
+                            }
+                        ],
+                    },
+                ],
+            }
+        ],
+    })
+
+
+PARENT_APP_COST_RESPONSE = openshift_report_cost_response_builder(
+    delta_value=100,
+    delta_percent=10,
+    total=1100,
+    project=PARENT_APP_NAMESPACE.name,
+    cluster=PARENT_APP_NAMESPACE.cluster_name,
+)
+
+CHILD_APP_COST_RESPONSE = openshift_report_cost_response_builder(
+    delta_value=200,
+    delta_percent=10,
+    total=2200,
+    project=CHILD_APP_NAMESPACE.name,
+    cluster=CHILD_APP_NAMESPACE.cluster_name,
+)
+
+
+def test_openshift_cost_report_get_reports(
+    openshift_cost_report_command: OpenShiftCostReportCommand,
+    mock_cost_management_api: Any,
+) -> None:
+    mocked_api = mock_cost_management_api.create_from_secret.return_value
+    mocked_api.get_openshift_costs_report.return_value = PARENT_APP_COST_RESPONSE
+
+    reports = openshift_cost_report_command.get_reports([PARENT_APP_NAMESPACE])
+
+    assert reports == {PARENT_APP_NAMESPACE: PARENT_APP_COST_RESPONSE}
+    mocked_api.get_openshift_costs_report.assert_called_once_with(
+        project=PARENT_APP_NAMESPACE.name,
+        cluster=PARENT_APP_NAMESPACE.cluster_external_id,
+    )
+
+
+PARENT_APP_REPORT = Report(
+    app_name="parent",
+    parent_app_name=None,
+    child_apps=[
+        ChildAppReport(name="child", total=Decimal(2200)),
+    ],
+    child_apps_total=Decimal(2200),
+    date="2024-02",
+    items=[
+        ReportItem(
+            name=f"{PARENT_APP_NAMESPACE.cluster_name}/{PARENT_APP_NAMESPACE.name}",
+            delta_value=Decimal(100),
+            delta_percent=10,
+            total=Decimal(1100),
+        )
+    ],
+    items_total=Decimal(1100),
+    items_delta_value=Decimal(100),
+    items_delta_percent=10,
+    total=Decimal(3300),
+)
+
+CHILD_APP_REPORT = Report(
+    app_name="child",
+    parent_app_name="parent",
+    child_apps=[],
+    child_apps_total=Decimal(0),
+    date="2024-02",
+    items=[
+        ReportItem(
+            name=f"{CHILD_APP_NAMESPACE.cluster_name}/{CHILD_APP_NAMESPACE.name}",
+            delta_value=Decimal(200),
+            delta_percent=10,
+            total=Decimal(2200),
+        )
+    ],
+    items_total=Decimal(2200),
+    items_delta_value=Decimal(200),
+    items_delta_percent=10,
+    total=Decimal(2200),
+)
+
+
+def test_openshift_cost_report_process_reports(
+    openshift_cost_report_command: OpenShiftCostReportCommand,
+) -> None:
+    expected_reports = {
+        "parent": PARENT_APP_REPORT,
+        "child": CHILD_APP_REPORT,
+    }
+
+    reports = openshift_cost_report_command.process_reports(
+        apps=[PARENT_APP, CHILD_APP],
+        responses={
+            PARENT_APP_NAMESPACE: PARENT_APP_COST_RESPONSE,
+            CHILD_APP_NAMESPACE: CHILD_APP_COST_RESPONSE,
+        },
+    )
+
+    assert reports == expected_reports
+
+
+def test_openshift_cost_report_render(
+    openshift_cost_report_command: OpenShiftCostReportCommand,
+    fx: Callable,
+) -> None:
+    expected_output = fx("openshift_cost_report.md")
+    reports = {
+        "parent": PARENT_APP_REPORT,
+        "child": CHILD_APP_REPORT,
+    }
+
+    output = openshift_cost_report_command.render(reports)
+
+    assert output == expected_output

tools/cli_commands/test/test_util.py

@@ -0,0 +1,70 @@
+from typing import Any
+from unittest.mock import create_autospec
+
+import pytest
+from pytest_mock import MockerFixture
+
+from reconcile.gql_definitions.common.app_interface_vault_settings import (
+    AppInterfaceSettingsV1,
+)
+from reconcile.gql_definitions.cost_report.settings import CostReportSettingsV1
+from reconcile.gql_definitions.fragments.vault_secret import VaultSecret
+from reconcile.utils.gql import GqlApi
+from tools.cli_commands.cost_report.util import fetch_cost_report_secret
+from tools.cli_commands.test.conftest import (
+    COST_REPORT_SECRET,
+)
+
+VAULT_SETTINGS = AppInterfaceSettingsV1(vault=True)
+COST_REPORT_SETTINGS = CostReportSettingsV1(
+    credentials=VaultSecret(
+        path="some-path",
+        field="all",
+        version=None,
+        format=None,
+    )
+)
+
+
+@pytest.fixture
+def mock_get_app_interface_vault_settings(mocker: MockerFixture) -> Any:
+    return mocker.patch(
+        "tools.cli_commands.cost_report.util.get_app_interface_vault_settings",
+        return_value=VAULT_SETTINGS,
+    )
+
+
+@pytest.fixture
+def mock_create_secret_reader(mocker: MockerFixture) -> Any:
+    mock = mocker.patch(
+        "tools.cli_commands.cost_report.util.create_secret_reader",
+        autospec=True,
+    )
+    mock.return_value.read_all_secret.return_value = COST_REPORT_SECRET
+    return mock
+
+
+@pytest.fixture
+def mock_get_cost_report_settings(mocker: MockerFixture) -> Any:
+    return mocker.patch(
+        "tools.cli_commands.cost_report.util.get_cost_report_settings",
+        return_value=COST_REPORT_SETTINGS,
+    )
+
+
+def test_fetch_cost_report_secret(
+    mock_get_app_interface_vault_settings: Any,
+    mock_create_secret_reader: Any,
+    mock_get_cost_report_settings: Any,
+) -> None:
+    mock_gql_api = create_autospec(GqlApi)
+
+    secret = fetch_cost_report_secret(mock_gql_api)
+
+    assert secret == COST_REPORT_SECRET
+    mock_get_app_interface_vault_settings.assert_called_once_with(mock_gql_api.query)
+    mock_get_cost_report_settings.assert_called_once_with(mock_gql_api)
+    mock_create_secret_reader.assert_called_once_with(use_vault=True)
+    mock_create_secret_reader.return_value.read_all_secret.assert_called_once_with(
+        COST_REPORT_SETTINGS.credentials
+    )

tools/qontract_cli.py

@@ -7,6 +7,7 @@ import logging
 import os
 import re
 import sys
+import textwrap
 from collections import defaultdict
 from datetime import (
     UTC,
@@ -150,6 +151,9 @@ from reconcile.utils.state import init_state
 from reconcile.utils.terraform_client import TerraformClient as Terraform
 from tools.cli_commands.cost_report.aws import AwsCostReportCommand
 from tools.cli_commands.cost_report.openshift import OpenShiftCostReportCommand
+from tools.cli_commands.cost_report.openshift_cost_optimization import (
+    OpenShiftCostOptimizationReportCommand,
+)
 from tools.cli_commands.erv2 import (
     Erv2Cli,
     TerraformCli,
@@ -1372,53 +1376,70 @@ def aws_creds(ctx, account_name):
 
 
 @root.command()
-@click.argument("account_name")
-@click.argument("bucket")
-@click.argument("src")
-@click.argument("dest")
-@click.argument("region", required=False, default="us-east-1")
+@click.option(
+    "--account-uid",
+    help="account UID of the account that owns the bucket",
+    required=True,
+)
+@click.option(
+    "--source-bucket",
+    help="aws bucket where the source statefile is stored",
+    required=True,
+)
+@click.option(
+    "--source-object-path",
+    help="path in the bucket where the statefile is stored",
+    required=True,
+)
+@click.option(
+    "--rename",
+    help="optionally rename the destination repo, otherwise keep the same name for the new location",
+)
+@click.option("--region", help="AWS region")
 @click.option(
     "--force/--no-force",
     help="Force the copy even if a statefile already exists at the destination",
     default=False,
 )
 @click.pass_context
-def copy_tfstate(ctx, account_name, bucket, src, dest, region, force):
-    """copy a manually managed terraform state file to the correct location expected by
-    the terraform-repo integration.
-
-    SRC should include the full filename including the extension
-
-    DEST should include the filename without extension.
-    """
+def copy_tfstate(
+    ctx, source_bucket, source_object_path, account_uid, rename, region, force
+):
     settings = queries.get_app_interface_settings()
     secret_reader = SecretReader(settings=settings)
-    accounts = queries.get_aws_accounts(name=account_name, terraform_state=True)
+    accounts = queries.get_aws_accounts(uid=account_uid, terraform_state=True)
     if not accounts:
-        print(f"{account_name} not found.")
+        print(f"{account_uid} not found in App-Interface.")
         sys.exit(1)
     account = accounts[0]
 
-    state_key = [
+    # terraform repo stores its statefiles within a "folder" in AWS S3 which is defined in App-Interface
+    dest_folder = [
         i
         for i in account["terraformState"]["integrations"]
         if i["integration"] == "terraform-repo"
     ]
-    if len(state_key) == 0:
+    if not dest_folder:
         logging.error(
-            "terraform-repo is missing a section in this account's '/dependencies/terraform-state-1.yml' file, please add one using the docs in https://gitlab.cee.redhat.com/service/app-interface/-/blob/master/docs/terraform-repo/sop/migrating-existing-state.md?ref_type=heads and then try again"
+            "terraform-repo is missing a section in this account's '/dependencies/terraform-state-1.yml' file, please add one using the docs in https://gitlab.cee.redhat.com/service/app-interface/-/blob/master/docs/terraform-repo/getting-started.md?ref_type=heads#step-1-setup-aws-account and then try again"
         )
         return
 
-    dest_key = f"{state_key[0]['key']}/{dest}-tf-repo.tfstate"
+    dest_filename = ""
+    if rename:
+        dest_filename = rename.removesuffix(".tfstate")
+    else:
+        dest_filename = source_object_path.removesuffix(".tfstate")
+
+    dest_key = f"{dest_folder[0]['key']}/{dest_filename}-tf-repo.tfstate"
     dest_bucket = account["terraformState"]["bucket"]
 
     with AWSApi(1, accounts, settings, secret_reader) as aws:
-        session = aws.get_session(account_name)
+        session = aws.get_session(account["name"])
         s3_client = aws.get_session_client(session, "s3", region)
         copy_source = {
-            "Bucket": bucket,
-            "Key": src,
+            "Bucket": source_bucket,
+            "Key": source_object_path,
         }
 
         dest_pretty_path = f"s3://{dest_bucket}/{dest_key}"
@@ -1438,10 +1459,25 @@ def copy_tfstate(ctx, account_name, bucket, src, dest, region, force):
                 )
                 return
 
-        prompt_text = f"Are you sure you want to copy 's3://{bucket}/{src}' to '{dest_pretty_path}'?"
+        prompt_text = f"Are you sure you want to copy 's3://{source_bucket}/{source_object_path}' to '{dest_pretty_path}'?"
         if click.confirm(prompt_text):
             s3_client.copy(copy_source, dest_bucket, dest_key)
-            logging.info("successfully copied the statefile to the new location")
+            print(
+                textwrap.dedent(f"""
+                            Nicely done! Your tfstate file has been migrated. Now you can create a repo definition in App-Interface like so:
+
+                            ---
+                            $schema: /aws/terraform-repo-1.yml
+
+                            account:
+                                $ref: {account["path"]}
+
+                            name: {dest_filename}
+                            repository: <FILL_IN>
+                            projectPath: <FILL_IN>
+                            tfVersion: <FILL_IN>
+                            ref: <FILL_IN>""")
+            )
 
 
 @get.command(short_help='obtain "rosa create cluster" command by cluster name')
@@ -2739,6 +2775,13 @@ def openshift_cost_report(ctx):
     print(command.execute())
 
 
+@get.command()
+@click.pass_context
+def openshift_cost_optimization_report(ctx):
+    command = OpenShiftCostOptimizationReportCommand.create()
+    print(command.execute())
+
+
 @get.command()
 @click.pass_context
 def osd_component_versions(ctx):

tools/test/test_qontract_cli.py

@@ -171,3 +171,27 @@ def test_get_openshift_cost_report(
     assert result.output == "some report\n"
     mock_openshift_cost_report_command.create.assert_called_once_with()
     mock_openshift_cost_report_command.create.return_value.execute.assert_called_once_with()
+
+
+@pytest.fixture
+def mock_openshift_cost_optimization_report_command(mocker):
+    return mocker.patch(
+        "tools.qontract_cli.OpenShiftCostOptimizationReportCommand", autospec=True
+    )
+
+
+def test_get_openshift_cost_optimization_report(
+    env_vars, mock_queries, mock_openshift_cost_optimization_report_command
+):
+    mock_openshift_cost_optimization_report_command.create.return_value.execute.return_value = "some report"
+    runner = CliRunner()
+    result = runner.invoke(
+        qontract_cli.get,
+        "openshift-cost-optimization-report",
+        obj={},
+    )
+
+    assert result.exit_code == 0
+    assert result.output == "some report\n"
+    mock_openshift_cost_optimization_report_command.create.assert_called_once_with()
+    mock_openshift_cost_optimization_report_command.create.return_value.execute.assert_called_once_with()