qontract-reconcile 0.10.0__py3-none-any.whl → 0.10.1.dev1203__py3-none-any.whl

reconcile/test/test_aws_iam_keys.py

@@ -1,70 +0,0 @@
-import pytest
-
-import reconcile.aws_iam_keys as integ
-
-
-def test_filter_accounts_with_account_name():
-    a = {"name": "a", "deleteKeys": ["AKIA"]}
-    b = {"name": "b", "deleteKeys": ["AKIA"]}
-    accounts = [a, b]
-    filtered = integ.filter_accounts(accounts, a["name"])
-    assert filtered == [a]
-
-
-def test_filter_accounts_without_account_name():
-    a = {"name": "a", "deleteKeys": ["AKIA"]}
-    b = {"name": "b", "deleteKeys": ["AKIA"]}
-    accounts = [a, b]
-    filtered = integ.filter_accounts(accounts, None)
-    assert filtered == accounts
-
-
-def test_filter_accounts_without_delete_keys():
-    a = {"name": "a", "deleteKeys": ["AKIA"]}
-    b = {"name": "b"}
-    accounts = [a, b]
-    filtered = integ.filter_accounts(accounts, None)
-    assert filtered == [a]
-
-
-def test_get_keys_to_delete():
-    a = {"name": "a", "deleteKeys": ["k1", "k2"]}
-    b = {"name": "b", "deleteKeys": None}
-    c = {"name": "c", "deleteKeys": []}
-    accounts = [a, b, c]
-    expected_result = {a["name"]: a["deleteKeys"]}
-    keys_to_delete = integ.get_keys_to_delete(accounts)
-    assert keys_to_delete == expected_result
-
-
-class StateMock:
-    def __init__(self):
-        self.data = {}
-
-    def get(self, key, *args):
-        return self.data.get(key, args[0])
-
-    def add(self, key, value, force):
-        self.data[key] = value
-
-
-@pytest.fixture
-def state():
-    return StateMock()
-
-
-def test_should_run_true(state):
-    keys_to_delete = {"a": ["k1"]}
-    assert integ.should_run(state, keys_to_delete) is True
-
-
-def test_should_run_false(state):
-    keys_to_delete = {"a": ["k1"]}
-    state.data.update(keys_to_delete)
-    assert integ.should_run(state, keys_to_delete) is False
-
-
-def test_update_state(state):
-    keys_to_update = {"a": ["k1"]}
-    integ.update_state(state, keys_to_update)
-    assert state.data == keys_to_update

reconcile/test/test_aws_iam_password_reset.py

@@ -1,35 +0,0 @@
-from typing import Any
-
-import pytest
-
-from reconcile.aws_iam_password_reset import (
-    account_in_roles,
-    get_roles,
-)
-
-
-@pytest.fixture
-def roles() -> list[dict[str, Any]]:
-    return [
-        {
-            "org_username": "foobar",
-            "roles": [
-                {"name": "test", "aws_groups": None},
-                {"name": "test2", "aws_groups": [{"account": {"name": "testaws1"}}]},
-            ],
-        },
-        {"org_username": "barfoo"},
-    ]
-
-
-def test_get_roles(roles: list[dict[str, Any]]):
-    r = get_roles(roles, "barfoo")
-    assert r and r["org_username"] == "barfoo"
-    r = get_roles(roles, "foo")
-    assert not r
-
-
-def test_account_in_roles(roles: list[dict[str, Any]]):
-    r = get_roles(roles, "foobar")
-    assert r and account_in_roles(r["roles"], "testaws1")
-    assert r and not account_in_roles(r["roles"], "a")

reconcile/test/test_aws_support_cases_sos.py

@@ -1,23 +0,0 @@
-from unittest import TestCase
-
-import reconcile.aws_support_cases_sos as integ
-
-
-class TestSupportFunctions(TestCase):
-    def test_filter_accounts(self):
-        a = {"name": "a", "premiumSupport": True}
-        b = {"name": "b", "premiumSupport": False}
-        c = {"name": "c", "premiumSupport": None}
-        d = {"name": "d"}
-        accounts = [a, b, c, d]
-        filtered = integ.filter_accounts(accounts)
-        self.assertEqual(filtered, [a])
-
-    def test_get_deleted_keys(self):
-        a = {"name": "a", "deleteKeys": ["k1", "k2"]}
-        b = {"name": "b", "deleteKeys": None}
-        c = {"name": "c", "deleteKeys": []}
-        accounts = [a, b, c]
-        expected_result = {a["name"]: a["deleteKeys"]}
-        keys_to_delete = integ.get_deleted_keys(accounts)
-        self.assertEqual(keys_to_delete, expected_result)

reconcile/test/test_checkpoint.py

@@ -1,178 +0,0 @@
-from http import HTTPStatus
-
-import pytest
-import requests
-
-import reconcile.checkpoint as sut
-
-
-@pytest.fixture
-def valid_app():
-    """How a valid application looks like."""
-    return {
-        "sopsUrl": "https://www.redhat.com/sops",
-        "architectureDocument": "https://www.redhat.com/arch",
-        "grafanaUrl": "https://www.redhat.com/graf",
-        "serviceOwners": [{"name": "A Name", "email": "aname@adomain.com"}],
-    }
-
-
-@pytest.fixture
-def valid_owner():
-    """How a valid owner looks like."""
-    return {"name": "A Name", "email": "a.name@redhat.com"}
-
-
-def invalid_owners():
-    """List the ways in which an owner can be invalid."""
-    return [
-        {"name": "A Name", "email": None},
-        {"name": "A Name", "email": "domainless"},
-        {"name": "A Name", "email": "@name.less"},
-        {"name": None, "email": "a-name@redhat.com"},
-    ]
-
-
-def test_valid_owner(valid_owner) -> None:
-    """Confirm that the valid owner is recognized as such."""
-    assert sut.valid_owners([valid_owner])
-
-
-@pytest.mark.parametrize("invalid_owner", invalid_owners())
-def test_invalid_owners(invalid_owner):
-    """Confirm that the invalid owners are flagged."""
-    assert not sut.valid_owners([invalid_owner])
-
-
-@pytest.mark.parametrize("invalid_owner", invalid_owners())
-def test_invalid_owners_remain_invalid(valid_owner, invalid_owner):
-    """Confirm rejection of invalid owners even mixed with good ones."""
-    assert not sut.valid_owners([valid_owner, invalid_owner])
-
-
-def test_url_makes_sense_ok(mocker):
-    """Good URLs are accepted."""
-    get = mocker.patch.object(requests, "get", autospec=True)
-    r = requests.Response()
-    r.status_code = HTTPStatus.OK
-    get.return_value = r
-
-    assert sut.url_makes_sense("https://www.redhat.com/existing")
-
-
-def test_url_makes_sense_unknown(mocker):
-    """Ensure rejection of URLs pointing to missing documents."""
-    get = mocker.patch.object(requests, "get", autospec=True)
-    r = requests.Response()
-    r.status_code = HTTPStatus.NOT_FOUND
-    get.return_value = r
-    assert not sut.url_makes_sense("https://www.redhat.com/nonexisting")
-
-
-def test_url_makes_sense_error():
-    """Ensure rejection of URLs returning ConnectionError."""
-    assert not sut.url_makes_sense("https://TODO")
-
-
-def test_url_makes_sense_empty():
-    """Ensure rejection of empty URLs."""
-    assert not sut.url_makes_sense("")
-
-
-def test_render_template():
-    """Confirm rendering of all placeholders in the ticket template."""
-    txt = sut.render_template(
-        sut.MISSING_DATA_TEMPLATE, "aname", "apath", "afield", "avalue"
-    )
-    assert "aname" in txt
-    assert "apath" in txt
-    assert "afield" in txt
-    assert "avalue" in txt
-
-
-def app_metadata():
-    """List some metadata for some fake apps.
-
-    Returns the app structure and whether we expect it to have a
-    ticket associated with it
-    """
-    return [
-        (
-            {
-                "name": "appname",
-                "sopsUrl": "https://www.somewhe.re",
-                "architectureDocument": "https://www.hereand.now",
-                "grafanaUrls": [],
-            },
-            False,
-        ),
-        # Missing field - should cut a ticket
-        (
-            {
-                "name": "appname",
-                "sopsUrl": "https://www.somewhe.re",
-                "grafanaUrls": [],
-            },
-            True,
-        ),
-        # Bad field - should cut a ticket
-        (
-            {
-                "name": "appname",
-                "architectureDocument": "",
-                "grafanaUrls": [],
-                "sopsUrl": "http://www.herea.nd",
-            },
-            True,
-        ),
-    ]
-
-
-@pytest.mark.parametrize("app,needs_ticket", app_metadata())
-def test_report_invalid_metadata(mocker, app, needs_ticket):
-    """Test that valid apps don't get tickets and that invalid apps do."""
-    # TODO: I'm pretty sure a fixture can help with this
-    jira = mocker.patch.object(sut, "JiraClient", autospec=True)
-    filer = mocker.patch.object(sut, "file_ticket", autospec=True)
-
-    valid = sut.VALIDATORS
-
-    sut.VALIDATORS = {
-        "sopsUrl": bool,
-        "architectureDocument": bool,
-        "grafanaUrls": lambda _: True,
-    }
-
-    sut.report_invalid_metadata(app, "/a/path", "jiraboard", {}, "TICKET-123")
-    if needs_ticket:
-        filer.assert_called_once_with(
-            jira=jira.return_value,
-            app_name=app["name"],
-            labels=sut.DEFAULT_CHECKPOINT_LABELS,
-            parent="TICKET-123",
-            field="architectureDocument",
-            bad_value=str(app.get("architectureDocument")),
-            app_path="/a/path",
-        )
-    else:
-        filer.assert_not_called()
-
-    sut.VALIDATORS = valid
-
-
-@pytest.mark.parametrize("app,needs_ticket", app_metadata())
-def test_report_invalid_metadata_dry_run(mocker, app, needs_ticket):
-    """Test the dry-run mode."""
-    renderer = mocker.patch.object(sut, "render_template", autospec=True)
-    valid = sut.VALIDATORS
-    sut.VALIDATORS = {
-        "sopsUrl": bool,
-        "architectureDocument": bool,
-        "grafanaUrls": lambda _: True,
-    }
-    sut.report_invalid_metadata(app, "/a/path", "jiraboard", {}, "TICKET-123", True)
-    if needs_ticket:
-        renderer.assert_called_once()
-    else:
-        renderer.assert_not_called()
-    sut.VALIDATORS = valid

reconcile/test/test_cli.py

@@ -1,41 +0,0 @@
-import pytest
-from click.testing import CliRunner
-
-import reconcile.cli as reconcile_cli
-
-
-def test_config_is_required():
-    runner = CliRunner()
-    result = runner.invoke(reconcile_cli.integration)
-    assert result.exit_code == 0
-
-
-def test_parse_image_tag_from_ref_valid():
-    t = ("env=main",)
-    expected = {"env": "main"}
-    result = reconcile_cli.parse_image_tag_from_ref(None, None, t)
-    assert result == expected
-
-
-def test_parse_image_tag_from_ref_invalid_1():
-    t = ("env=",)
-    with pytest.raises(SystemExit):
-        reconcile_cli.parse_image_tag_from_ref(None, None, t)
-
-
-def test_parse_image_tag_from_ref_invalid_2():
-    t = ("=main",)
-    with pytest.raises(SystemExit):
-        reconcile_cli.parse_image_tag_from_ref(None, None, t)
-
-
-def test_parse_image_tag_from_ref_invalid_3():
-    t = ("=",)
-    with pytest.raises(SystemExit):
-        reconcile_cli.parse_image_tag_from_ref(None, None, t)
-
-
-def test_parse_image_tag_from_ref_invalid_4():
-    t = ("env=main=test",)
-    with pytest.raises(SystemExit):
-        reconcile_cli.parse_image_tag_from_ref(None, None, t)

reconcile/test/test_closedbox_endpoint_monitoring.py

@@ -1,207 +0,0 @@
-from unittest.mock import ANY
-
-import pytest
-
-from reconcile.blackbox_exporter_endpoint_monitoring import (
-    PROVIDER as BLACKBOX_EXPORTER_PROVIDER,
-)
-from reconcile.blackbox_exporter_endpoint_monitoring import (
-    build_probe as blackbox_exporter_probe_builder,
-)
-from reconcile.closedbox_endpoint_monitoring_base import (
-    fill_desired_state,
-    get_endpoints,
-    parse_prober_url,
-    queries,
-)
-from reconcile.signalfx_endpoint_monitoring import PROVIDER as SIGNALFX_PROVIDER
-from reconcile.signalfx_endpoint_monitoring import build_probe as signalfx_probe_builder
-from reconcile.utils.openshift_resource import ResourceInventory
-
-from .fixtures import Fixtures
-
-fxt = Fixtures("closedbox_exporter_endpoint_monitoring")
-
-
-def get_endpoint_fixtures(path: str) -> dict:
-    return fxt.get_anymarkup(path)["appInterface"]["apps"]
-
-
-def test_invalid_endpoints(mocker):
-    query = mocker.patch.object(queries, "get_service_monitoring_endpoints")
-    query.return_value = get_endpoint_fixtures("test_invalid_endpoints.yaml")
-
-    endpoints = get_endpoints(BLACKBOX_EXPORTER_PROVIDER)
-    assert len(endpoints) == 0
-
-
-def test_blackbox_exporter_endpoint_loading(mocker):
-    ep_query = mocker.patch.object(queries, "get_service_monitoring_endpoints")
-    ep_query.return_value = get_endpoint_fixtures("test_endpoint.yaml")
-
-    endpoints = get_endpoints(BLACKBOX_EXPORTER_PROVIDER)
-    assert endpoints is not None
-    assert len(endpoints) == 1
-
-    provider = list(endpoints.keys())[0]
-    assert provider.provider == BLACKBOX_EXPORTER_PROVIDER
-    provider_endpoints = endpoints.get(provider)
-    assert provider_endpoints is not None
-    assert len(provider_endpoints) == 1
-    assert len(provider_endpoints[0].monitoring) == 1
-
-
-def test_parse_prober_url():
-    assert parse_prober_url("http://host:1234/path") == {
-        "url": "host:1234",
-        "scheme": "http",
-        "path": "/path",
-    }
-
-    assert parse_prober_url("http://host") == {"url": "host", "scheme": "http"}
-
-
-def test_invalid_prober_url():
-    # scheme missing
-    with pytest.raises(ValueError):
-        parse_prober_url("host:1234/path")
-
-
-def test_blackbox_exporter_probe_building(mocker):
-    ep_query = mocker.patch.object(queries, "get_service_monitoring_endpoints")
-    ep_query.return_value = get_endpoint_fixtures("test_blackbox_probe_building.yaml")
-
-    endpoints = get_endpoints(BLACKBOX_EXPORTER_PROVIDER)
-    assert len(endpoints) == 1
-
-    provider = list(endpoints.keys())[0]
-    provider_endpoints = endpoints.get(provider)
-    assert provider_endpoints is not None
-    probe_resource = blackbox_exporter_probe_builder(provider, provider_endpoints)
-    assert probe_resource is not None
-
-    # verify prober url decomposition
-    spec = probe_resource.body.get("spec")
-    assert spec.get("prober") == {
-        "url": "exporterhost:9115",
-        "scheme": "http",
-        "path": "/probe",
-    }
-
-    # verify labels
-    labels = spec["targets"]["staticConfig"]["labels"]
-    assert labels.get("environment") == "staging"
-
-    # verify timeout and interval
-    assert spec["scrapeTimeout"] == provider.timeout
-    assert spec["interval"] == provider.checkInterval
-
-    # verify targets
-    assert "https://test1.url" in spec["targets"]["staticConfig"]["static"]
-    assert "https://test2.url" in spec["targets"]["staticConfig"]["static"]
-
-
-def test_signalfx_probe_building(mocker):
-    ep_query = mocker.patch.object(queries, "get_service_monitoring_endpoints")
-    ep_query.return_value = get_endpoint_fixtures("test_signalfx_probe_building.yaml")
-
-    endpoints = get_endpoints(SIGNALFX_PROVIDER)
-    assert len(endpoints) == 1
-
-    provider = list(endpoints.keys())[0]
-    provider_endpoints = endpoints.get(provider)
-    assert provider_endpoints is not None
-    probe_resource = signalfx_probe_builder(provider, provider_endpoints)
-    assert probe_resource is not None
-
-    # verify prober url decomposition
-    spec = probe_resource.body.get("spec")
-    assert spec.get("prober") == {
-        "url": "signalfxexporter:9091",
-        "scheme": "http",
-        "path": "/metrics/probe",
-    }
-
-    # verify labels
-    labels = spec["targets"]["staticConfig"]["labels"]
-    assert labels.get("environment") == "staging"
-
-    # verify timeout and interval
-    assert spec["scrapeTimeout"] == provider.timeout
-    assert spec["interval"] == provider.checkInterval
-
-    # verify targets
-    assert "test_1" in spec["targets"]["staticConfig"]["static"]
-    assert "test_2" in spec["targets"]["staticConfig"]["static"]
-
-    # verify relabeling
-    assert {
-        "action": "replace",
-        "regex": "^test_1$",
-        "replacement": "https://test1.url",
-        "sourceLabels": ["instance"],
-        "targetLabel": "instance",
-    } in spec["targets"]["staticConfig"]["relabelingConfigs"]
-    assert {
-        "action": "replace",
-        "regex": "^test_2$",
-        "replacement": "https://test2.url",
-        "sourceLabels": ["instance"],
-        "targetLabel": "instance",
-    } in spec["targets"]["staticConfig"]["relabelingConfigs"]
-
-
-def test_blackbox_exporter_filling_desired_state(mocker):
-    ep_query = mocker.patch.object(queries, "get_service_monitoring_endpoints")
-    ep_query.return_value = get_endpoint_fixtures("test_endpoint.yaml")
-    add_desired_mock = mocker.patch.object(ResourceInventory, "add_desired")
-
-    endpoints = get_endpoints(BLACKBOX_EXPORTER_PROVIDER)
-    provider = list(endpoints.keys())[0]
-    probe = blackbox_exporter_probe_builder(provider, endpoints[provider])
-    assert probe is not None
-    fill_desired_state(provider, probe, ResourceInventory())
-
-    assert add_desired_mock.call_count == 1
-    add_desired_mock.assert_called_with(
-        cluster="app-sre-stage-01",
-        namespace="openshift-customer-monitoring",
-        resource_type="Probe",
-        name="blackbox-exporter-http-2xx",
-        value=ANY,
-    )
-
-
-def test_signalfx_filling_desired_state(mocker):
-    ep_query = mocker.patch.object(queries, "get_service_monitoring_endpoints")
-    ep_query.return_value = get_endpoint_fixtures("test_endpoint.yaml")
-    add_desired_mock = mocker.patch.object(ResourceInventory, "add_desired")
-
-    endpoints = get_endpoints(SIGNALFX_PROVIDER)
-    provider = list(endpoints.keys())[0]
-    probe = signalfx_probe_builder(provider, endpoints[provider])
-    assert probe is not None
-    fill_desired_state(provider, probe, ResourceInventory())
-
-    assert add_desired_mock.call_count == 1
-    add_desired_mock.assert_called_with(
-        cluster="app-sre-stage-01",
-        namespace="openshift-customer-monitoring",
-        resource_type="Probe",
-        name="signalfx-exporter-http-2xx",
-        value=ANY,
-    )
-
-
-def test_loading_multiple_providers_per_endpoint(mocker):
-    ep_query = mocker.patch.object(queries, "get_service_monitoring_endpoints")
-    ep_query.return_value = get_endpoint_fixtures(
-        "test_multiple_providers_per_endpoint.yaml"
-    )
-    endpoints = get_endpoints(BLACKBOX_EXPORTER_PROVIDER)
-
-    assert len(endpoints) == 2
-
-    for provider, eps in endpoints.items():
-        assert provider.provider == BLACKBOX_EXPORTER_PROVIDER
-        assert len(eps) == 2

reconcile/test/test_gabi_authorized_users.py

@@ -1,72 +0,0 @@
-from datetime import (
-    date,
-    timedelta,
-)
-
-import pytest
-from pytest_mock import MockerFixture
-
-import reconcile.gabi_authorized_users as gabi_u
-import reconcile.openshift_base as ob
-from reconcile.test.fixtures import Fixtures
-from reconcile.utils.aggregated_list import RunnerException
-from reconcile.utils.openshift_resource import OpenshiftResource as OR
-from reconcile.utils.openshift_resource import ResourceInventory
-
-fixture = Fixtures("gabi_authorized_users").get_anymarkup("api.yml")
-
-
-def test_gabi_authorized_users_apply(mocker: MockerFixture) -> None:
-    ri = ResourceInventory()
-    ri.initialize_resource_type("server", "gabi-db", "ConfigMap")
-    gabi_instance = fixture["gql_response"][0]
-    gabi_u.fetch_desired_state([gabi_instance], ri)
-    mock_apply = mocker.patch.object(ob, "apply", autospec=True)
-    oc_map = mocker.patch("reconcile.utils.oc_map.OCMap", autospec=True)
-    ob.realize_data(True, oc_map, ri, 1)
-    expected = OR(
-        fixture["desired"],
-        gabi_u.QONTRACT_INTEGRATION,
-        gabi_u.QONTRACT_INTEGRATION_VERSION,
-    )
-    args, _ = mock_apply.call_args
-    assert args[5] == expected
-
-
-def test_gabi_authorized_users_exist(mocker: MockerFixture) -> None:
-    ri = ResourceInventory()
-    ri.initialize_resource_type("server", "gabi-db", "ConfigMap")
-    current = OR(
-        fixture["current"],
-        gabi_u.QONTRACT_INTEGRATION,
-        gabi_u.QONTRACT_INTEGRATION_VERSION,
-    )
-    ri.add_current(
-        "server",
-        "gabi-db",
-        "ConfigMap",
-        current.name,
-        current,
-    )
-    gabi_instance = fixture["gql_response"][0]
-    gabi_u.fetch_desired_state([gabi_instance], ri)
-    mock_apply = mocker.patch.object(ob, "apply", autospec=True)
-    oc_map = mocker.patch("reconcile.utils.oc_map.OCMap", autospec=True)
-    ob.realize_data(True, oc_map, ri, 1)
-    mock_apply.assert_not_called()
-
-
-def test_gabi_authorized_users_exceed() -> None:
-    expiration_date = date.today() + timedelta(days=(gabi_u.EXPIRATION_DAYS_MAX + 1))
-    gabi_instance = fixture["gql_response"][0]
-    gabi_instance["expirationDate"] = str(expiration_date)
-    ri = ResourceInventory()
-    with pytest.raises(RunnerException):
-        gabi_u.fetch_desired_state([gabi_instance], ri)
-
-
-def test_gabi_authorized_users_rds_not_found() -> None:
-    gabi_instance = fixture["gql_response"][1]
-    ri = ResourceInventory()
-    with pytest.raises(RunnerException):
-        gabi_u.fetch_desired_state([gabi_instance], ri)