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

reconcile/test/conftest.py

@@ -1,187 +0,0 @@
-import time
-from collections.abc import (
-    Callable,
-    Mapping,
-    MutableMapping,
-)
-from typing import (
-    Any,
-    Optional,
-)
-from unittest.mock import create_autospec
-
-import httpretty as _httpretty
-import pytest
-from pydantic import BaseModel
-from pydantic.error_wrappers import ValidationError
-
-from reconcile.gql_definitions.fragments.vault_secret import VaultSecret
-from reconcile.utils.state import State
-
-
-@pytest.fixture
-def patch_sleep(mocker):
-    yield mocker.patch.object(time, "sleep")
-
-
-@pytest.fixture()
-def httpretty():
-    with _httpretty.enabled(allow_net_connect=False):
-        _httpretty.reset()
-        yield _httpretty
-
-
-@pytest.fixture
-def secret_reader(mocker) -> None:
-    mock_secretreader = mocker.patch(
-        "reconcile.utils.secret_reader.SecretReader", autospec=True
-    )
-    mock_secretreader.read.return_value = "secret"
-    mock_secretreader.read_secret.return_value = "secret"
-    return mock_secretreader
-
-
-@pytest.fixture
-def s3_state_builder() -> Callable[[Mapping], State]:
-    """
-    Example input data:
-    {
-        "get": {
-            # This maps data being returned by get
-            "path/to/item": {
-                "some_key": "content",
-                "other_content": "content",
-            },
-            "other/path": {
-                "other": "data",
-            },
-        },
-        "ls": [
-            "/path/item1",
-            "/path/item2",
-        ]
-    }
-    """
-
-    def builder(data: Mapping) -> State:
-        def get(key: str) -> dict:
-            return data["get"][key]
-
-        state = create_autospec(spec=State)
-        state.get = get
-        state.ls.side_effect = [data["ls"]]
-        return state
-
-    return builder
-
-
-@pytest.fixture
-def vault_secret():
-    return VaultSecret(
-        path="path/test",
-        field="key",
-        format=None,
-        version=None,
-    )
-
-
-def data_default_none(
-    klass: type[BaseModel], data: MutableMapping[str, Any]
-) -> MutableMapping[str, Any]:
-    """Set default values to None for required but optional fields."""
-    for field in klass.__fields__.values():
-        if not field.required:
-            continue
-
-        if field.alias not in data:
-            # Settings defaults
-            if field.allow_none:
-                data[field.alias] = None
-            else:
-                if isinstance(field.type_, type) and issubclass(field.type_, str):
-                    data[field.alias] = "I was too lazy to define a string here"
-                elif isinstance(field.type_, type) and issubclass(field.type_, int):
-                    data[field.alias] = 42
-                elif isinstance(field.type_, type) and issubclass(field.type_, bool):
-                    data[field.alias] = False
-        else:
-            if isinstance(field.type_, type) and issubclass(field.type_, BaseModel):
-                if isinstance(data[field.alias], dict):
-                    data[field.alias] = data_default_none(
-                        field.type_, data[field.alias]
-                    )
-                if isinstance(data[field.alias], list):
-                    data[field.alias] = [
-                        data_default_none(field.type_, item)
-                        for item in data[field.alias]
-                    ]
-            elif field.sub_fields:
-                if all(
-                    isinstance(sub_field.type_, type)
-                    and issubclass(sub_field.type_, BaseModel)
-                    for sub_field in field.sub_fields
-                ):
-                    # Union[ClassA, ClassB] field
-                    for sub_field in field.sub_fields:
-                        if isinstance(data[field.alias], dict):
-                            try:
-                                d = dict(data[field.alias])
-                                d.update(data_default_none(sub_field.type_, d))
-                                # Lets confirm we found a matching union class
-                                sub_field.type_(**d)
-                                data[field.alias] = d
-                                break
-                            except ValidationError:
-                                continue
-                elif isinstance(data[field.alias], list) and len(field.sub_fields) == 1:
-                    # list[Union[ClassA, ClassB]] field
-                    for sub_data in data[field.alias]:
-                        for sub_field in field.sub_fields[0].sub_fields or []:
-                            try:
-                                d = dict(sub_data)
-                                d.update(data_default_none(sub_field.type_, d))
-                                # Lets confirm we found a matching union class
-                                sub_field.type_(**d)
-                                sub_data.update(d)
-                                break
-                            except ValidationError:
-                                continue
-
-    return data
-
-
-@pytest.fixture
-def data_factory() -> Callable[
-    [type[BaseModel], Optional[MutableMapping[str, Any]]], MutableMapping[str, Any]
-]:
-    """Set default values to None."""
-
-    def _data_factory(
-        klass: type[BaseModel], data: Optional[MutableMapping[str, Any]] = None
-    ) -> MutableMapping[str, Any]:
-        return data_default_none(klass, data or {})
-
-    return _data_factory
-
-
-class GQLClassFactoryError(Exception):
-    pass
-
-
-@pytest.fixture
-def gql_class_factory() -> Callable[
-    [type[BaseModel], Optional[MutableMapping[str, Any]]], BaseModel
-]:
-    """Create a GQL class from a fixture and set default values to None."""
-
-    def _gql_class_factory(
-        klass: type[BaseModel], data: Optional[MutableMapping[str, Any]] = None
-    ) -> BaseModel:
-        try:
-            return klass(**data_default_none(klass, data or {}))
-        except ValidationError as e:
-            msg = "[gql_class_factory] Your given data does not match the class ...\n"
-            msg += "\n".join([str(m) for m in list(e.raw_errors)])
-            raise GQLClassFactoryError(msg) from e
-
-    return _gql_class_factory

reconcile/test/fixtures.py

@@ -1,24 +0,0 @@
-import json
-import os
-
-import anymarkup
-
-
-class Fixtures:
-    def __init__(self, base_path):
-        self.base_path = base_path
-
-    def path(self, fixture):
-        return os.path.join(
-            os.path.dirname(__file__), "fixtures", self.base_path, fixture
-        )
-
-    def get(self, fixture):
-        with open(self.path(fixture), "r") as f:
-            return f.read().strip()
-
-    def get_anymarkup(self, fixture):
-        return anymarkup.parse(self.get(fixture), force_types=None)
-
-    def get_json(self, fixture):
-        return json.loads(self.get(fixture))

reconcile/test/saas_auto_promotions_manager/conftest.py

@@ -1,69 +0,0 @@
-from collections.abc import (
-    Callable,
-    Iterable,
-    Mapping,
-    MutableMapping,
-)
-from unittest.mock import (
-    MagicMock,
-    create_autospec,
-)
-
-import pytest
-
-from reconcile.saas_auto_promotions_manager.utils.vcs import VCS
-from reconcile.typed_queries.saas_files import SaasFile
-from reconcile.utils.gitlab_api import GitLabApi
-
-
-@pytest.fixture
-def saas_files_builder(
-    gql_class_factory: Callable[[type[SaasFile], Mapping], SaasFile]
-) -> Callable[[Iterable[MutableMapping]], list[SaasFile]]:
-    def builder(data: Iterable[MutableMapping]) -> list[SaasFile]:
-        for d in data:
-            if "app" not in d:
-                d["app"] = {}
-            if "pipelinesProvider" not in d:
-                d["pipelinesProvider"] = {}
-            if "managedResourceTypes" not in d:
-                d["managedResourceTypes"] = []
-            if "imagePatterns" not in d:
-                d["imagePatterns"] = []
-            for rt in d.get("resourceTemplates", []):
-                for t in rt.get("targets", []):
-                    ns = t["namespace"]
-                    if "name" not in ns:
-                        ns["name"] = "some_name"
-                    if "environment" not in ns:
-                        ns["environment"] = {}
-                    if "app" not in ns:
-                        ns["app"] = {}
-                    if "cluster" not in ns:
-                        ns["cluster"] = {}
-        return [gql_class_factory(SaasFile, d) for d in data]
-
-    return builder
-
-
-@pytest.fixture
-def vcs_builder() -> Callable[..., VCS]:
-    def builder() -> VCS:
-        vcs = create_autospec(spec=VCS)
-        vcs.get_commit_sha.side_effect = ["new_sha"] * 100
-        vcs._app_interface_api = MagicMock()
-        return vcs
-
-    return builder
-
-
-@pytest.fixture
-def gql_client_builder() -> Callable[..., GitLabApi]:
-    def builder() -> GitLabApi:
-        api = create_autospec(spec=GitLabApi)
-        api.project = MagicMock()
-        api.project.mergerequests = MagicMock()
-        api.project.mergerequests.create.side_effect = []
-        return api
-
-    return builder

reconcile/test/saas_auto_promotions_manager/merge_request_manager/merge_request_manager/conftest.py

@@ -1,110 +0,0 @@
-from collections.abc import (
-    Callable,
-    Mapping,
-)
-from unittest.mock import create_autospec
-
-import pytest
-from gitlab.v4.objects import ProjectMergeRequest
-
-from reconcile.saas_auto_promotions_manager.merge_request_manager.renderer import (
-    CHANNELS_REF,
-    CONTENT_HASH,
-    PROMOTION_DATA_SEPARATOR,
-    SAPM_LABEL,
-    SAPM_VERSION,
-    VERSION_REF,
-    Renderer,
-)
-from reconcile.saas_auto_promotions_manager.subscriber import (
-    Channel,
-    Subscriber,
-)
-from reconcile.saas_auto_promotions_manager.utils.vcs import VCS
-
-from .data_keys import (
-    DESCRIPTION,
-    HAS_CONFLICTS,
-    LABELS,
-    OPEN_MERGE_REQUESTS,
-    SUBSCRIBER_CHANNELS,
-    SUBSCRIBER_CONTENT_HASH,
-    SUBSCRIBER_DESIRED_CONFIG_HASHES,
-    SUBSCRIBER_DESIRED_REF,
-    SUBSCRIBER_NAMESPACE_REF,
-    SUBSCRIBER_TARGET_PATH,
-)
-
-
-@pytest.fixture
-def mr_builder() -> Callable[[Mapping], ProjectMergeRequest]:
-    def builder(data: Mapping) -> ProjectMergeRequest:
-        mr = create_autospec(spec=ProjectMergeRequest)
-        if CONTENT_HASH in data:
-            # Generate with valid defaults
-            mr.attributes = {
-                "labels": [SAPM_LABEL],
-                "description": f"""
-                {PROMOTION_DATA_SEPARATOR}
-                {VERSION_REF}: {data.get(VERSION_REF, SAPM_VERSION)}
-                {CHANNELS_REF}: {data.get(SUBSCRIBER_CHANNELS, "some_channel")}
-                {CONTENT_HASH}: {data.get(SUBSCRIBER_CONTENT_HASH, "content_hash")}
-                """,
-                "web_url": "http://localhost",
-                "has_conflicts": False,
-            }
-        else:
-            mr.attributes = {
-                "labels": data.get(LABELS, []),
-                "description": data.get(DESCRIPTION, ""),
-                "web_url": "http://localhost",
-                "has_conflicts": data.get(HAS_CONFLICTS, False),
-            }
-        return mr
-
-    return builder
-
-
-@pytest.fixture
-def vcs_builder(
-    mr_builder: Callable[[Mapping], ProjectMergeRequest]
-) -> Callable[[Mapping], VCS]:
-    def builder(data: Mapping) -> VCS:
-        vcs = create_autospec(spec=VCS)
-        open_mrs: list[ProjectMergeRequest] = []
-        for d in data.get(OPEN_MERGE_REQUESTS, []):
-            open_mrs.append(mr_builder(d))
-        vcs.get_open_app_interface_merge_requests.side_effect = [open_mrs]
-        return vcs
-
-    return builder
-
-
-@pytest.fixture
-def subscriber_builder() -> Callable[[Mapping], Subscriber]:
-    def builder(data: Mapping) -> Subscriber:
-        subscriber = Subscriber(
-            saas_name="",
-            template_name="",
-            namespace_file_path=data.get(SUBSCRIBER_NAMESPACE_REF, ""),
-            ref="",
-            target_file_path=data.get(SUBSCRIBER_TARGET_PATH, ""),
-            use_target_config_hash=True,
-        )
-        subscriber.desired_hashes = data.get(SUBSCRIBER_DESIRED_CONFIG_HASHES, [])
-        subscriber.desired_ref = data.get(SUBSCRIBER_DESIRED_REF, "")
-        for channel in data.get(SUBSCRIBER_CHANNELS, []):
-            subscriber.channels.append(
-                Channel(
-                    name=channel,
-                    publishers=[],
-                )
-            )
-        return subscriber
-
-    return builder
-
-
-@pytest.fixture
-def renderer() -> Renderer:
-    return create_autospec(spec=Renderer)

reconcile/test/saas_auto_promotions_manager/merge_request_manager/merge_request_manager/data_keys.py

@@ -1,10 +0,0 @@
-OPEN_MERGE_REQUESTS = "open_merge_requests"
-LABELS = "labels"
-DESCRIPTION = "description"
-SUBSCRIBER_CONTENT_HASH = "content_hash"
-SUBSCRIBER_NAMESPACE_REF = "namespace_ref"
-SUBSCRIBER_TARGET_PATH = "target_path"
-SUBSCRIBER_DESIRED_CONFIG_HASHES = "config_hashes"
-SUBSCRIBER_DESIRED_REF = "desired_ref"
-SUBSCRIBER_CHANNELS = "sub_channels"
-HAS_CONFLICTS = "has_conflicts"

reconcile/test/saas_auto_promotions_manager/merge_request_manager/merge_request_manager/test_housekeeping.py

@@ -1,200 +0,0 @@
-from collections.abc import (
-    Callable,
-    Mapping,
-)
-
-from reconcile.saas_auto_promotions_manager.merge_request_manager.merge_request_manager import (
-    MergeRequestManager,
-)
-from reconcile.saas_auto_promotions_manager.merge_request_manager.renderer import (
-    CHANNELS_REF,
-    CONTENT_HASH,
-    PROMOTION_DATA_SEPARATOR,
-    SAPM_LABEL,
-    SAPM_VERSION,
-    VERSION_REF,
-    Renderer,
-)
-from reconcile.saas_auto_promotions_manager.utils.vcs import VCS
-
-from .data_keys import (
-    DESCRIPTION,
-    HAS_CONFLICTS,
-    LABELS,
-    OPEN_MERGE_REQUESTS,
-)
-
-
-def test_labels_filter(vcs_builder: Callable[[Mapping], VCS], renderer: Renderer):
-    vcs = vcs_builder(
-        {
-            OPEN_MERGE_REQUESTS: [
-                {
-                    LABELS: ["OtherLabel"],
-                    DESCRIPTION: "Some desc",
-                },
-                {
-                    LABELS: [SAPM_LABEL, "OtherLabel"],
-                    DESCRIPTION: "Some desc",
-                },
-            ]
-        }
-    )
-    merge_request_manager = MergeRequestManager(
-        vcs=vcs,
-        renderer=renderer,
-    )
-    merge_request_manager.fetch_sapm_managed_open_merge_requests()
-    assert len(merge_request_manager._open_raw_mrs) == 1
-
-
-def test_valid_description(vcs_builder: Callable[[Mapping], VCS], renderer: Renderer):
-    vcs = vcs_builder(
-        {
-            OPEN_MERGE_REQUESTS: [
-                {
-                    LABELS: [SAPM_LABEL],
-                    DESCRIPTION: f"""
-                    Blabla
-                    {PROMOTION_DATA_SEPARATOR}
-                    {VERSION_REF}: {SAPM_VERSION}
-                    {CHANNELS_REF}: some-channel
-                    {CONTENT_HASH}: some_hash
-                """,
-                }
-            ]
-        }
-    )
-    merge_request_manager = MergeRequestManager(
-        vcs=vcs,
-        renderer=renderer,
-    )
-    merge_request_manager.fetch_sapm_managed_open_merge_requests()
-    merge_request_manager.housekeeping()
-    vcs.close_app_interface_mr.assert_not_called()  # type: ignore[attr-defined]
-    assert len(merge_request_manager._open_mrs) == 1
-
-
-def test_bad_mrs(vcs_builder: Callable[[Mapping], VCS], renderer: Renderer):
-    vcs = vcs_builder(
-        {
-            OPEN_MERGE_REQUESTS: [
-                {
-                    LABELS: [SAPM_LABEL],
-                    DESCRIPTION: f"""
-                    Blabla
-                    {PROMOTION_DATA_SEPARATOR}
-                    missing-version: some_version
-                    {CHANNELS_REF}: some-channel
-                    {CONTENT_HASH}: hash_1
-                """,
-                },
-                {
-                    LABELS: [SAPM_LABEL],
-                    DESCRIPTION: f"""
-                    Blabla
-                    {PROMOTION_DATA_SEPARATOR}
-                    {VERSION_REF}: {SAPM_VERSION}
-                    {CHANNELS_REF}: some-channel
-                    missing-content-hash-key: some_hash
-                """,
-                },
-                {
-                    LABELS: [SAPM_LABEL],
-                    DESCRIPTION: f"""
-                    Blabla
-                    missing-data-separator
-                    {VERSION_REF}: {SAPM_VERSION}
-                    {CONTENT_HASH}: hash_3
-                """,
-                },
-                {
-                    LABELS: [SAPM_LABEL],
-                    DESCRIPTION: f"""
-                    bad order
-                    {VERSION_REF}: {SAPM_VERSION}
-                    {PROMOTION_DATA_SEPARATOR}
-                    {CHANNELS_REF}: some-channel
-                    {CONTENT_HASH}: hash_4
-                """,
-                },
-                {
-                    # We have merge conflicts here
-                    HAS_CONFLICTS: True,
-                    LABELS: [SAPM_LABEL],
-                    DESCRIPTION: f"""
-                    Blabla
-                    {PROMOTION_DATA_SEPARATOR}
-                    {VERSION_REF}: {SAPM_VERSION}
-                    {CHANNELS_REF}: some-channel
-                    {CONTENT_HASH}: hash_5
-                """,
-                },
-                {
-                    LABELS: [SAPM_LABEL],
-                    DESCRIPTION: f"""
-                    Blabla
-                    {PROMOTION_DATA_SEPARATOR}
-                    {VERSION_REF}: outdated-version
-                    {CHANNELS_REF}: some-channel
-                    {CONTENT_HASH}: hash_6
-                """,
-                },
-                {
-                    LABELS: [SAPM_LABEL],
-                    DESCRIPTION: f"""
-                    Blabla
-                    {PROMOTION_DATA_SEPARATOR}
-                    {VERSION_REF}: {SAPM_VERSION}
-                    bad_channel_ref: some-channel
-                    {CONTENT_HASH}: hash_7
-                """,
-                },
-            ]
-        }
-    )
-    merge_request_manager = MergeRequestManager(
-        vcs=vcs,
-        renderer=renderer,
-    )
-    merge_request_manager.fetch_sapm_managed_open_merge_requests()
-    merge_request_manager.housekeeping()
-    vcs.close_app_interface_mr.assert_called()  # type: ignore[attr-defined]
-    assert len(merge_request_manager._open_mrs) == 0
-
-
-def test_remove_duplicates(vcs_builder: Callable[[Mapping], VCS], renderer: Renderer):
-    vcs = vcs_builder(
-        {
-            OPEN_MERGE_REQUESTS: [
-                {
-                    LABELS: [SAPM_LABEL],
-                    DESCRIPTION: f"""
-                    Blabla
-                    {PROMOTION_DATA_SEPARATOR}
-                    {VERSION_REF}: {SAPM_VERSION}
-                    {CHANNELS_REF}: some_channel
-                    {CONTENT_HASH}: same_hash
-                """,
-                },
-                {
-                    LABELS: [SAPM_LABEL],
-                    DESCRIPTION: f"""
-                    Some other blabla
-                    {PROMOTION_DATA_SEPARATOR}
-                    {VERSION_REF}: {SAPM_VERSION}
-                    {CHANNELS_REF}: some_channel
-                    {CONTENT_HASH}: same_hash
-                """,
-                },
-            ]
-        }
-    )
-    merge_request_manager = MergeRequestManager(
-        vcs=vcs,
-        renderer=renderer,
-    )
-    merge_request_manager.fetch_sapm_managed_open_merge_requests()
-    merge_request_manager.housekeeping()
-    vcs.close_app_interface_mr.assert_called_once()  # type: ignore[attr-defined]
-    assert len(merge_request_manager._open_mrs) == 1