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

reconcile/test/test_utils_disabled_integrations.py

@@ -1,86 +0,0 @@
-from collections.abc import Mapping
-from typing import (
-    Any,
-    Optional,
-    Union,
-)
-
-import pytest
-from pydantic import BaseModel
-from pytest_mock import MockerFixture
-
-from reconcile.utils.disabled_integrations import (
-    HasDisableIntegrations,
-    disabled_integrations,
-    integration_is_enabled,
-)
-
-
-class IntMandatory(BaseModel):
-    integrations: list[str]
-
-
-class IntOptional(BaseModel):
-    integrations: Optional[list[str]]
-
-
-class MandatoryIntMandatory(BaseModel):
-    disable: IntMandatory
-
-
-class OptionalIntOptional(BaseModel):
-    disable: Optional[IntOptional]
-
-
-class MandatoryIntOptional(BaseModel):
-    disable: IntOptional
-
-
-class OptionalIntMandatory(BaseModel):
-    disable: Optional[IntMandatory]
-
-
-INT_LIST = ["int1", "int2"]
-
-
-@pytest.mark.parametrize(
-    "disable_obj, expected",
-    [
-        # classes
-        (None, []),
-        (
-            MandatoryIntMandatory(disable=IntMandatory(integrations=INT_LIST)),
-            INT_LIST,
-        ),
-        (OptionalIntOptional(disable=None), []),
-        (OptionalIntOptional(disable=IntOptional(integrations=None)), []),
-        (OptionalIntOptional(disable=IntOptional(integrations=INT_LIST)), INT_LIST),
-        (MandatoryIntOptional(disable=IntOptional(integrations=None)), []),
-        (MandatoryIntOptional(disable=IntOptional(integrations=INT_LIST)), INT_LIST),
-        (OptionalIntMandatory(disable=None), []),
-        (OptionalIntMandatory(disable=IntMandatory(integrations=INT_LIST)), INT_LIST),
-        # dicts
-        ({}, []),
-        ({"disable": None}, []),
-        ({"disable": {}}, []),
-        ({"disable": {"integrations": None}}, []),
-        ({"disable": {"integrations": []}}, []),
-        ({"disable": {"integrations": INT_LIST}}, INT_LIST),
-    ],
-)
-def test_utils_disabled_integrations(
-    disable_obj: Optional[Union[Mapping[str, Any], HasDisableIntegrations]],
-    expected: list[str],
-) -> None:
-    assert disabled_integrations(disable_obj) == expected
-
-
-def test_utils_disabled_integrations_integration_is_enabled(
-    mocker: MockerFixture,
-) -> None:
-    mocker.patch(
-        "reconcile.utils.disabled_integrations.disabled_integrations",
-        return_value=["int1"],
-    )
-    assert not integration_is_enabled("int1", None)
-    assert integration_is_enabled("int2", None)

reconcile/test/test_utils_expiration.py

@@ -1,109 +0,0 @@
-from datetime import (
-    datetime,
-    timedelta,
-)
-from typing import Optional
-
-import pytest
-from pydantic import BaseModel
-
-from reconcile.utils import expiration
-
-TODAY = datetime.utcnow().date()
-YESTERDAY = TODAY - timedelta(days=1)
-TOMORROW = TODAY + timedelta(days=1)
-NEXT_WEEK = TODAY + timedelta(days=7)
-LAST_WEEK = TODAY - timedelta(days=7)
-
-
-class MyRole(BaseModel):
-    just_another_attr: int = 0
-    expiration_date: Optional[str]
-
-
-@pytest.mark.parametrize(
-    "in_date, expired",
-    [
-        (LAST_WEEK.strftime(expiration.DATE_FORMAT), True),
-        (YESTERDAY.strftime(expiration.DATE_FORMAT), True),
-        (TODAY.strftime(expiration.DATE_FORMAT), True),
-        (TOMORROW.strftime(expiration.DATE_FORMAT), False),
-        (NEXT_WEEK.strftime(expiration.DATE_FORMAT), False),
-    ],
-)
-def test_date_expired(in_date: str, expired: bool):
-    assert expiration.date_expired(in_date) == expired
-
-
-def test_date_expired_invalid_format():
-    with pytest.raises(ValueError):
-        expiration.date_expired("garbage")
-
-
-@pytest.mark.parametrize(
-    "roles, expected",
-    [
-        # valid roles (dict)
-        (
-            [
-                {"expirationDate": "2500-01-01"},
-                {"expirationDate": "1990-01-01"},
-            ],
-            [{"expirationDate": "2500-01-01"}],
-        ),
-        # valid roles (classes)
-        (
-            [
-                MyRole(expiration_date="2500-01-01"),
-                MyRole(expiration_date="1900-01-01"),
-            ],
-            [MyRole(expiration_date="2500-01-01")],
-        ),
-        # all roles are expired (dict)
-        (
-            [
-                {"expirationDate": "1990-01-01"},
-            ],
-            [],
-        ),
-        # all roles are expired (classes)
-        (
-            [
-                MyRole(expiration_date="1900-01-01"),
-            ],
-            [],
-        ),
-        # empty input lists
-        ([], []),
-        (None, []),
-        # no expiration date or None (dict)
-        (
-            [{"another_key": "foobar"}],
-            [{"another_key": "foobar"}],
-        ),
-        # no expiration date or None (classes)
-        (
-            [
-                MyRole(just_another_attr=1),
-                MyRole(expiration_date=None),
-            ],
-            [MyRole(just_another_attr=1), MyRole(expiration_date=None)],
-        ),
-    ],
-)
-def test_filter(roles, expected):
-    assert expiration.filter(roles) == expected
-
-
-@pytest.mark.parametrize(
-    "roles",
-    [
-        # dict
-        [{"expirationDate": "garbage"}],
-        # class
-        [MyRole(expiration_date="garbage")],
-    ],
-)
-def test_filter_invalid_format(roles):
-    with pytest.raises(ValueError):
-        expiration.filter(roles)

reconcile/test/test_utils_external_resource_spec.py

@@ -1,383 +0,0 @@
-from typing import Any
-
-import pytest
-from pydantic import ValidationError
-
-from reconcile.utils.external_resource_spec import (
-    ExternalResourceSpec,
-    ExternalResourceUniqueKey,
-)
-from reconcile.utils.openshift_resource import (
-    SECRET_MAX_KEY_LENGTH,
-    base64_encode_secret_field_value,
-)
-
-
-def test_identifier_creation_from_spec():
-    id = ExternalResourceUniqueKey.from_spec(
-        ExternalResourceSpec(
-            provision_provider="p",
-            provisioner={"name": "a"},
-            resource={
-                "identifier": "i",
-                "provider": "p",
-            },
-            namespace={},
-        )
-    )
-    assert id.identifier == "i"
-    assert id.provider == "p"
-    assert id.provisioner_name == "a"
-
-
-def test_identifier_missing():
-    with pytest.raises(ValidationError):
-        ExternalResourceUniqueKey.from_spec(
-            ExternalResourceSpec(
-                provision_provider="p",
-                provisioner={"name": "a"},
-                resource={
-                    "identifier": None,
-                    "provider": "p",
-                },
-                namespace={},
-            )
-        )
-    with pytest.raises(KeyError):
-        ExternalResourceUniqueKey.from_spec(
-            ExternalResourceSpec(
-                provision_provider="p",
-                provisioner={"name": "a"},
-                resource={
-                    "provider": "p",
-                },
-                namespace={},
-            )
-        )
-
-
-def test_identifier_account_missing():
-    with pytest.raises(ValidationError):
-        ExternalResourceUniqueKey.from_spec(
-            ExternalResourceSpec(
-                provision_provider="p",
-                provisioner={"name": None},
-                resource={
-                    "identifier": "i",
-                    "provider": "p",
-                },
-                namespace={},
-            )
-        )
-    with pytest.raises(KeyError):
-        ExternalResourceUniqueKey.from_spec(
-            ExternalResourceSpec(
-                provision_provider="p",
-                provisioner={},
-                resource={
-                    "identifier": "i",
-                    "provider": "p",
-                },
-                namespace={},
-            )
-        )
-
-
-def test_identifier_provider_missing():
-    with pytest.raises(ValidationError):
-        ExternalResourceUniqueKey.from_spec(
-            ExternalResourceSpec(
-                provision_provider="p",
-                provisioner={"name": "a"},
-                resource={
-                    "identifier": "i",
-                    "provider": None,
-                },
-                namespace={},
-            )
-        )
-    with pytest.raises(KeyError):
-        ExternalResourceUniqueKey.from_spec(
-            ExternalResourceSpec(
-                provision_provider="p",
-                provisioner={"name": "a"},
-                resource={
-                    "identifier": "i",
-                },
-                namespace={},
-            )
-        )
-
-
-@pytest.mark.parametrize(
-    "external_resource,output_prefix",
-    [
-        (
-            ExternalResourceSpec(
-                provision_provider="aws",
-                provisioner={"name": "a"},
-                resource={"identifier": "i", "provider": "p"},
-                namespace={},
-            ),
-            "i-p",
-        ),
-        (
-            ExternalResourceSpec(
-                provision_provider="aws",
-                provisioner={"name": "a"},
-                resource={"identifier": "i", "provider": "hyphen-ated"},
-                namespace={},
-            ),
-            "i-hyphen-ated",
-        ),
-        (
-            ExternalResourceSpec(
-                provision_provider="aws",
-                provisioner={"name": "a"},
-                resource={"identifier": "i", "provider": "under_score"},
-                namespace={},
-            ),
-            "i-under-score",
-        ),
-    ],
-)
-def test_spec_output_prefix(external_resource, output_prefix):
-    assert external_resource.output_prefix == output_prefix
-
-
-def test_spec_implicit_output_resource_name():
-    s = ExternalResourceSpec(
-        provision_provider="aws",
-        provisioner={"name": "a"},
-        resource={"identifier": "i", "provider": "p"},
-        namespace={},
-    )
-    assert s.output_resource_name == "i-p"
-
-
-def test_spec_explicit_output_resource_name():
-    s = ExternalResourceSpec(
-        provision_provider="aws",
-        provisioner={"name": "a"},
-        resource={
-            "identifier": "i",
-            "provider": "p",
-            "output_resource_name": "explicit",
-        },
-        namespace={},
-    )
-    assert s.output_resource_name == "explicit"
-
-
-def test_spec_annotation_parsing():
-    s = ExternalResourceSpec(
-        provision_provider="aws",
-        provisioner={"name": "a"},
-        resource={
-            "identifier": "i",
-            "provider": "p",
-            "annotations": '{"key": "value"}',
-        },
-        namespace={},
-    )
-    assert s.annotations() == {"key": "value"}
-
-
-def test_spec_annotation_parsing_none_present():
-    s = ExternalResourceSpec(
-        provision_provider="aws",
-        provisioner={"name": "a"},
-        resource={
-            "identifier": "i",
-            "provider": "p",
-        },
-        namespace={},
-    )
-    assert s.annotations() == {}
-
-
-def test_spec_tags():
-    s = ExternalResourceSpec(
-        provision_provider="aws",
-        provisioner={"name": "a"},
-        resource={
-            "identifier": "i",
-            "provider": "p",
-        },
-        namespace={
-            "name": "ns",
-            "cluster": {
-                "name": "c",
-            },
-            "environment": {
-                "name": "env",
-            },
-            "app": {
-                "name": "app",
-            },
-        },
-    )
-    expected = {
-        "managed_by_integration": "int",
-        "cluster": "c",
-        "namespace": "ns",
-        "environment": "env",
-        "app": "app",
-    }
-    assert s.tags("int") == expected
-
-
-@pytest.fixture
-def resource_secret() -> dict[str, Any]:
-    return {"yakk_name": "Furry", "visual_characteristics": "furry", "mood": "grumpy"}
-
-
-@pytest.fixture
-def spec() -> ExternalResourceSpec:
-    return ExternalResourceSpec(
-        provision_provider="aws",
-        provisioner={"name": "a"},
-        resource={
-            "identifier": "i",
-            "provider": "p",
-        },
-        namespace={},
-    )
-
-
-#
-# tests for terraform output format
-#
-
-
-def test_terraform_output_with_when_no_secret(spec: ExternalResourceSpec):
-    output_secret = spec.build_oc_secret("int", "1.0")
-    assert output_secret.body["data"] == {}
-
-
-def test_terraform_generic_secret_output_format(
-    spec: ExternalResourceSpec, resource_secret: dict[str, Any]
-):
-    spec.resource["output_format"] = {
-        "provider": "generic-secret",
-        "data": """
-            motd: The {{ mood }} Yakk {{ yakk_name }} is {{ visual_characteristics }}.
-        """,
-    }
-    spec.secret = resource_secret
-
-    output_secret = spec.build_oc_secret("int", "1.0")
-    assert output_secret.body["data"]["motd"] == base64_encode_secret_field_value(
-        "The grumpy Yakk Furry is furry."
-    )
-
-
-def test_terraform_generic_secret_output_format_no_data(
-    spec: ExternalResourceSpec, resource_secret: dict[str, Any]
-):
-    """
-    this test shows backwards compatibility with the simple dict output when
-    no data is given but the provider is specified
-    """
-    spec.resource["output_format"] = {
-        "provider": "generic-secret",
-    }
-    spec.secret = resource_secret
-
-    output_secret = spec.build_oc_secret("int", "1.0")
-    assert len(output_secret.body["data"]) == len(resource_secret)
-    for k, v in resource_secret.items():
-        assert output_secret.body["data"][k] == base64_encode_secret_field_value(v)
-
-
-def test_terraform_no_output_format_provider(
-    spec: ExternalResourceSpec, resource_secret: dict[str, Any]
-):
-    """
-    this test shows full backwards compatibility when no provider has been specified
-    """
-    spec.secret = resource_secret
-
-    output_secret = spec.build_oc_secret("int", "1.0")
-    assert len(output_secret.body["data"]) == len(resource_secret)
-    for k, v in resource_secret.items():
-        assert output_secret.body["data"][k] == base64_encode_secret_field_value(v)
-
-
-def test_terraform_unknown_output_format_provider(spec: ExternalResourceSpec):
-    """
-    this test expects the secret generation to fail when an unknown provider is
-    given. while the schema usually protects against such cases, additional protection
-    in code is a good thing.
-    """
-    spec.resource["output_format"] = {"provider": "unknown-provider"}
-    with pytest.raises(ValueError):
-        spec.build_oc_secret("int", "1.0")
-
-
-def test_terraform_generic_secret_output_format_not_a_dict(
-    spec: ExternalResourceSpec, resource_secret: dict[str, Any]
-):
-    """
-    this test shows how a data template for a generic-secret provider must result
-    in a valid dict and fails otherwise
-    """
-    spec.resource["output_format"] = {
-        "provider": "generic-secret",
-        "data": "not_a_dict",
-    }
-    spec.secret = resource_secret
-
-    with pytest.raises(ValueError):
-        spec.build_oc_secret("int", "1.0")
-
-
-def test_terraform_generic_secret_output_format_not_str_keys(
-    spec: ExternalResourceSpec, resource_secret: dict[str, Any]
-):
-    """
-    this test shows how a data template for a generic-secret provider must produce
-    string keys
-    """
-    spec.resource["output_format"] = {
-        "provider": "generic-secret",
-        "data": "1: value",
-    }
-    spec.secret = resource_secret
-
-    with pytest.raises(ValueError):
-        spec.build_oc_secret("int", "1.0")
-
-
-def test_terraform_generic_secret_output_format_not_str_val(
-    spec: ExternalResourceSpec, resource_secret: dict[str, Any]
-):
-    """
-    this test shows how a data template for a generic-secret provider must produce
-    string values
-    """
-    spec.resource["output_format"] = {
-        "provider": "generic-secret",
-        "data": "key: 1",
-    }
-    spec.secret = resource_secret
-
-    with pytest.raises(ValueError):
-        spec.build_oc_secret("int", "1.0")
-
-
-def test_terraform_generic_secret_output_key_too_long(
-    spec: ExternalResourceSpec, resource_secret: dict[str, Any]
-):
-    """
-    tests for too long secret keys (max length in kubernetes is 253 characters )
-    """
-    long_key = "a" * (SECRET_MAX_KEY_LENGTH + 1)
-    spec.resource["output_format"] = {
-        "provider": "generic-secret",
-        "data": f"{ long_key }: value",
-    }
-    spec.secret = resource_secret
-
-    with pytest.raises(ValueError):
-        spec.build_oc_secret("int", "1.0")