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

reconcile/test/test_openshift_upgrade_watcher.py

@@ -1,146 +0,0 @@
-from datetime import (
-    datetime,
-    timedelta,
-)
-
-import pytest
-
-from reconcile import openshift_upgrade_watcher as ouw
-from reconcile.gql_definitions.common.clusters import ClusterV1
-from reconcile.test.fixtures import Fixtures
-
-fxt = Fixtures("openshift_upgrade_watcher")
-
-
-def load_cluster(path: str) -> ClusterV1:
-    content = fxt.get_anymarkup(path)
-    return ClusterV1(**content)
-
-
-@pytest.fixture
-def state(mocker):
-    return mocker.patch("reconcile.utils.state.State", autospec=True).return_value
-
-
-@pytest.fixture
-def slack(mocker):
-    return mocker.patch(
-        "reconcile.utils.slack_api.SlackApi", autospec=True
-    ).return_value
-
-
-cluster_name = "cluster1"
-upgrade_at = datetime(2020, 6, 1, 0, 0, 0)
-old_version = "4.5.1"
-upgrade_version = "4.5.2"
-
-
-@pytest.fixture
-def oc_map(mocker):
-    map = mocker.patch("reconcile.utils.oc_map.OCMap", autospec=True).return_value
-    map.clusters.return_value = [cluster_name]
-    oc = mocker.patch("reconcile.utils.oc.OCNative", autospec=True)
-    oc.get.return_value = {"items": []}
-    map.get.return_value = oc
-    return map
-
-
-@pytest.fixture
-def upgrade_config():
-    return {
-        "items": [
-            {
-                "spec": {
-                    "upgradeAt": upgrade_at.strftime("%Y-%m-%dT%H:%M:%SZ"),
-                    "desired": {"version": upgrade_version},
-                }
-            }
-        ]
-    }
-
-
-@pytest.fixture
-def dt(mocker):
-    return mocker.patch(
-        "reconcile.openshift_upgrade_watcher.datetime",
-        mocker.Mock(datetime, wraps=datetime),
-    )
-
-
-def test_new_upgrade_no_op(mocker, state, slack, oc_map):
-    """There is no UpgradeConfig on the cluster"""
-    ouw.notify_upgrades_start(oc_map, state=state, slack=slack)
-    assert slack.chat_post_message.call_count == 0
-    assert state.add.call_count == 0
-
-
-def test_new_upgrade_pending(mocker, state, slack, oc_map, upgrade_config, dt):
-    """There is an UpgradeConfig on the cluster but its upgradeAt is in the future"""
-    dt.utcnow.return_value = upgrade_at - timedelta(hours=1)
-    oc = oc_map.get.return_value
-    oc.get.return_value = upgrade_config
-    ouw.notify_upgrades_start(oc_map, state=state, slack=slack)
-    assert slack.chat_post_message.call_count == 0
-    assert state.add.call_count == 0
-
-
-def test_new_upgrade_notify(mocker, state, slack, oc_map, upgrade_config, dt):
-    """There is an UpgradeConfig on the cluster, its upgradeAt is in the past,
-    and we did not already notify"""
-    dt.utcnow.return_value = upgrade_at + timedelta(hours=1)
-    oc = oc_map.get.return_value
-    oc.get.return_value = upgrade_config
-    state.exists.return_value = False
-    ouw.notify_upgrades_start(oc_map, state=state, slack=slack)
-    assert slack.chat_post_message.call_count == 1
-    assert state.add.call_count == 1
-
-
-def test_new_upgrade_already_notified(mocker, state, slack, oc_map, upgrade_config, dt):
-    """There is an UpgradeConfig on the cluster, its upgradeAt is in the past,
-    and we already notified"""
-    dt.utcnow.return_value = upgrade_at + timedelta(hours=1)
-    oc = oc_map.get.return_value
-    oc.get.return_value = upgrade_config
-    state.exists.return_value = True
-    state.get.return_value = None
-    ouw.notify_upgrades_start(oc_map, state=state, slack=slack)
-    assert slack.chat_post_message.call_count == 0
-    assert state.add.call_count == 0
-
-
-@pytest.fixture
-def clusters():
-    cluster = load_cluster("cluster1.yml")
-    cluster.name = cluster_name
-    if not cluster.spec:
-        raise RuntimeError("This test requires a cluster_spec. Check your fixture.")
-    cluster.spec.version = upgrade_version
-    return [cluster]
-
-
-def test_new_version_no_op(mocker, state, slack, clusters):
-    """We already notified for this cluster & version"""
-    state.exists.return_value = True
-    state.get.return_value = upgrade_version  # same version, already notified
-    ouw.notify_upgrades_done(clusters, state=state, slack=slack)
-    assert slack.chat_post_message.call_count == 0
-    assert state.add.call_count == 0
-
-
-def test_new_version_no_state(mocker, state, slack, clusters):
-    """We never notified for this cluster"""
-    state.exists.return_value = False  # never notified for this cluster
-    state.get.return_value = None
-    ouw.notify_upgrades_done(clusters, state=state, slack=slack)
-    assert slack.chat_post_message.call_count == 1
-    assert state.add.call_count == 1
-
-
-def test_new_version_notify(mocker, state, slack, clusters):
-    """We already notified for this cluster, but on an old version"""
-    state.exists.return_value = True
-    state.get.return_value = old_version  # different version
-    ouw.notify_upgrades_done(clusters, state=state, slack=slack)
-    assert slack.chat_post_message.call_count == 1
-    assert state.add.call_count == 1

reconcile/test/test_prometheus_rules_tester.py

@@ -1,151 +0,0 @@
-from typing import Any
-from unittest.mock import (
-    create_autospec,
-    patch,
-)
-
-import pytest
-
-from reconcile.gql_definitions.common.app_interface_vault_settings import (
-    AppInterfaceSettingsV1,
-)
-from reconcile.openshift_resources_base import NAMESPACES_QUERY
-from reconcile.prometheus_rules_tester.integration import Test as PTest
-from reconcile.prometheus_rules_tester.integration import (
-    check_rules_and_tests,
-    run,
-)
-from reconcile.status import ExitCodes
-from reconcile.utils import gql
-
-from .fixtures import Fixtures
-
-THREAD_POOL_SIZE = 2
-
-
-class TstUnsupportedGqlQueryError(Exception):
-    pass
-
-
-class TestPrometheusRulesTester:
-    def mock_gql_get_resource(self, path: str) -> dict[str, str]:
-        """Mock for GqlApi.get_resources using fixtures. Namespace fixtures have paths
-        that refer to files in fixture dir so that this methos loads them."""
-        content = self.fxt.get(path)
-        return {
-            "path": path,
-            "content": content,
-            "sha256sum": "",
-        }
-
-    def mock_gql_query(self, query: str) -> dict[str, Any]:
-        """Mock for GqlApi.query using test_data set in setup_method."""
-        if query == NAMESPACES_QUERY:
-            return {"namespaces": self.ns_data}
-
-        raise TstUnsupportedGqlQueryError("Unsupported query")
-
-    def setup_method(self) -> None:
-        self.ns_data: dict[str, Any] = {}
-
-        self.fxt = Fixtures("prometheus_rules_tester")
-        self.alerting_services = {"yak-shaver"}
-        self.vault_settings = AppInterfaceSettingsV1(vault=False)
-
-        # Patcher for GqlApi methods
-        self.gql_patcher = patch.object(gql, "get_api", autospec=True)
-        self.gql = self.gql_patcher.start()
-        gqlapi_mock = create_autospec(gql.GqlApi)
-        self.gql.return_value = gqlapi_mock
-        gqlapi_mock.query.side_effect = self.mock_gql_query
-        gqlapi_mock.get_resource.side_effect = self.mock_gql_get_resource
-
-    def teardown_method(self) -> None:
-        """cleanup patches created in setup_method"""
-        self.gql_patcher.stop()
-
-    def run_check(self, cluster_name=None) -> list[PTest]:
-        return check_rules_and_tests(
-            vault_settings=self.vault_settings,
-            alerting_services=self.alerting_services,
-            thread_pool_size=THREAD_POOL_SIZE,
-            cluster_name=cluster_name,
-        )
-
-    def test_ok_non_templated(self) -> None:
-        self.ns_data = self.fxt.get_anymarkup("ns-ok-non-templated.yaml")
-        assert self.run_check() == []
-
-    def test_ok_templated(self) -> None:
-        self.ns_data = self.fxt.get_anymarkup("ns-ok-templated.yaml")
-        assert self.run_check() == []
-
-    # Bad rule syntax should me caught by schema, but since we check it, we test it."
-    def test_bad_rule(self) -> None:
-        self.ns_data = self.fxt.get_anymarkup("ns-bad-rule.yaml")
-        failed = self.run_check()
-        assert len(failed) == 1
-        assert "Error running promtool command" in str(failed[0].result)
-
-    def test_bad_alerting_service(self) -> None:
-        self.ns_data = self.fxt.get_anymarkup("ns-ok-templated.yaml")
-        self.alerting_services = {"not-a-yak-shaver"}
-        failed = self.run_check()
-        assert len(failed) == 1
-        assert "services are missing from alertingServices" in str(failed[0].result)
-
-    @patch("reconcile.prometheus_rules_tester.integration.MAX_CONFIGMAP_SIZE", 1)
-    def test_rule_too_long(self) -> None:
-        self.ns_data = self.fxt.get_anymarkup("ns-ok-non-templated.yaml")
-        failed = self.run_check()
-        assert len(failed) == 1
-        assert "Rules spec is larger than 1 bytes" in str(failed[0].result)
-
-    def test_bad_test(self) -> None:
-        self.ns_data = self.fxt.get_anymarkup("ns-bad-test.yaml")
-        failed = self.run_check()
-        assert len(failed) == 1
-        assert "Error running promtool command" in str(failed[0].result)
-
-    # Tests regarding filtering by cluster name.
-    def test_2_ns_bad_alerting_service_unfiltered(self) -> None:
-        self.ns_data = self.fxt.get_anymarkup("2-ns-ok-non-templated.yaml")
-        self.alerting_services = {"not-a-yak-shaver"}
-        assert len(self.run_check()) == 2
-
-    def test_2_ns_bad_alerting_service_filtered(self) -> None:
-        self.ns_data = self.fxt.get_anymarkup("2-ns-ok-non-templated.yaml")
-        self.alerting_services = {"not-a-yak-shaver"}
-
-        failed = self.run_check(cluster_name="appint-ex-01")
-        assert len(failed) == 1
-
-        failed = self.run_check(cluster_name="appint-ex-02")
-        assert len(failed) == 1
-
-        failed = self.run_check(cluster_name="no-such-cluster")
-        assert len(failed) == 0
-
-    @patch("reconcile.prometheus_rules_tester.integration.get_alerting_services")
-    @patch(
-        "reconcile.prometheus_rules_tester.integration.get_app_interface_vault_settings"
-    )
-    def test_run_logs_error(
-        self, mocker_vault_settings, mocker_alerting_services, caplog
-    ) -> None:
-        self.ns_data = self.fxt.get_anymarkup("ns-bad-test.yaml")
-        mocker_alerting_services.return_value = {"yak-shaver"}
-        mocker_vault_settings.return_value = AppInterfaceSettingsV1(vault=False)
-        cluster_name = "appint-ex-01"
-
-        with pytest.raises(SystemExit) as exc:
-            run(False, THREAD_POOL_SIZE, cluster_name=cluster_name)
-
-        assert exc.value.code == ExitCodes.ERROR
-
-        error_msg = (
-            "Error checking rule bad-test.prometheusrules.yaml "
-            "from namespace openshift-customer-monitoring in "
-            f"cluster {cluster_name}: Error running promtool command"
-        )
-        assert error_msg in caplog.text

reconcile/test/test_prometheus_rules_tester_old.py

@@ -1,77 +0,0 @@
-import reconcile.prometheus_rules_tester_old as prt
-
-GOOD_YAML = """
----
-$schema: /app-interface/prometheus-rule-test-1.yml
-rule_files:
-- /kiss.yml
-evaluation_interval: 1m
-"""
-
-BAD_YAML_PARSEABLE_1 = """
-$schema: /app-interface/prometheus-rule-test-1.yml
-target_clusters:
-- /mr.yml
-- /jack.yml
-rule_files:
-- /smooth.yml
-- /criminal.yml
-evaluation_interval: 1m
-{{% if lol %}}
-lol_key: lol_value
-{{% end %}}
-"""
-
-BAD_YAML_PARSEABLE_2 = """
-$schema: /app-interface/prometheus-rule-test-1.yml
-rule_files:
-  - /let.yml
-  - /love.yml
-  - /rule.yml
-evaluation_interval: 1m
-{{% if lol %}}
-lol_key: lol_value
-{{% end %}}
-"""
-
-BAD_YAML_NON_PARSEABLE = """
-$schema: /app-interface/prometheus-rule-test-1.yml
-rule_files: ['rata.yml', 'de.yml', 'dos.yml', 'patas.yml']
-evaluation_interval: 1m
-{{% if lol %}}
-lol_key: lol_value
-{{% end %}}
-"""
-
-
-class TestGetRuleFilesFromJinjaTestTemplate:
-    @staticmethod
-    def test_good_yaml():
-        data = prt.get_data_from_jinja_test_template(
-            GOOD_YAML, ["rule_files", "target_clusters"]
-        )
-        assert data["rule_files"] == ["/kiss.yml"]
-        assert data["target_clusters"] == []
-
-    @staticmethod
-    def test_bad_yaml_parseable_1():
-        data = prt.get_data_from_jinja_test_template(
-            BAD_YAML_PARSEABLE_1, ["rule_files", "target_clusters"]
-        )
-        assert data["rule_files"] == ["/smooth.yml", "/criminal.yml"]
-        assert data["target_clusters"] == ["/mr.yml", "/jack.yml"]
-
-    @staticmethod
-    def test_bad_yaml_parseable_2():
-        data = prt.get_data_from_jinja_test_template(
-            BAD_YAML_PARSEABLE_2, ["rule_files"]
-        )
-
-        assert data["rule_files"] == ["/let.yml", "/love.yml", "/rule.yml"]
-
-    @staticmethod
-    def test_bad_yaml_non_parseable():
-        data = prt.get_data_from_jinja_test_template(
-            BAD_YAML_NON_PARSEABLE, ["rule_files"]
-        )
-        assert data["rule_files"] == []

reconcile/test/test_quay_membership.py

@@ -1,86 +0,0 @@
-from unittest.mock import patch
-
-from reconcile import quay_membership
-from reconcile.utils import (
-    config,
-    gql,
-)
-from reconcile.utils.aggregated_list import AggregatedList
-
-from .fixtures import Fixtures
-
-fxt = Fixtures("quay_membership")
-
-
-def get_items_by_params(state, params):
-    h = AggregatedList.hash_params(params)
-    for group in state:
-        this_h = AggregatedList.hash_params(group["params"])
-
-        if h == this_h:
-            return sorted(group["items"])
-    return False
-
-
-class QuayApiMock:
-    def __init__(self, list_team_members_response):
-        self.list_team_members_response = list_team_members_response
-
-    def list_team_members(self, team):
-        return self.list_team_members_response[team]
-
-
-class TestQuayMembership:
-    @staticmethod
-    def setup_method(method):
-        config.init_from_toml(fxt.path("config.toml"))
-        gql.init_from_config(autodetect_sha=False)
-
-    @staticmethod
-    def do_current_state_test(path):
-        fixture = fxt.get_anymarkup(path)
-
-        quay_org_catalog = fixture["quay_org_catalog"]
-        quay_org_teams = fixture["quay_org_teams"]
-
-        store = {}
-        for org_data in quay_org_catalog:
-            name = org_data["name"]
-            store[name] = {
-                "api": QuayApiMock(quay_org_teams[name]),
-                "teams": org_data["managedTeams"],
-            }
-
-        current_state = quay_membership.fetch_current_state(store)
-        current_state = current_state.dump()
-
-        expected_current_state = fixture["state"]
-
-        assert len(current_state) == len(expected_current_state)
-        for group in current_state:
-            params = group["params"]
-            items = sorted(group["items"])
-            assert items == get_items_by_params(expected_current_state, params)
-
-    @staticmethod
-    def do_desired_state_test(path):
-        fixture = fxt.get_anymarkup(path)
-
-        with patch("reconcile.utils.gql.GqlApi.query") as m_gql:
-            m_gql.return_value = fixture["gql_response"]
-
-            desired_state = quay_membership.fetch_desired_state().dump()
-
-            expected_desired_state = fixture["state"]
-
-            assert len(desired_state) == len(expected_desired_state)
-            for group in desired_state:
-                params = group["params"]
-                items = sorted(group["items"])
-                assert items == get_items_by_params(expected_desired_state, params)
-
-    def test_current_state_simple(self):
-        self.do_current_state_test("current_state_simple.yml")
-
-    def test_desired_state_simple(self):
-        self.do_desired_state_test("desired_state_simple.yml")

reconcile/test/test_quay_mirror.py

@@ -1,109 +0,0 @@
-import os
-import tempfile
-from unittest.mock import patch
-
-import pytest
-
-from reconcile.quay_mirror import (
-    CONTROL_FILE_NAME,
-    QuayMirror,
-)
-
-NOW = 1662124612.995397
-
-
-@patch("reconcile.utils.gql.get_api", autospec=True)
-@patch("reconcile.queries.get_app_interface_settings", return_value={})
-class TestControlFile:
-    def test_check_compare_tags_no_control_file(self, mock_gql, mock_settings):
-        assert QuayMirror.check_compare_tags_elapsed_time("/no-such-file", 100)
-
-    @patch("time.time", return_value=NOW)
-    def test_check_compare_tags_with_file(self, mock_gql, mock_settings, mock_time):
-        with tempfile.NamedTemporaryFile() as fp:
-            fp.write(str(NOW - 100.0).encode())
-            fp.seek(0)
-
-            assert QuayMirror.check_compare_tags_elapsed_time(fp.name, 10)
-            assert not QuayMirror.check_compare_tags_elapsed_time(fp.name, 1000)
-
-    def test_control_file_dir_does_not_exist(self, mock_gql, mock_settings):
-        with pytest.raises(FileNotFoundError):
-            QuayMirror(control_file_dir="/no-such-dir")
-
-    def test_control_file_path_from_given_dir(self, mock_gql, mock_settings):
-        with tempfile.TemporaryDirectory() as tmp_dir_name:
-            qm = QuayMirror(control_file_dir=tmp_dir_name)
-            assert qm.control_file_path == os.path.join(tmp_dir_name, CONTROL_FILE_NAME)
-
-
-@patch("reconcile.utils.gql.get_api", autospec=True)
-@patch("reconcile.queries.get_app_interface_settings", return_value={})
-@patch("time.time", return_value=NOW)
-class TestIsCompareTags:
-    def setup_method(self):
-        self.tmp_dir = (
-            tempfile.TemporaryDirectory()  # pylint: disable=consider-using-with
-        )
-        with open(os.path.join(self.tmp_dir.name, CONTROL_FILE_NAME), "w") as fh:
-            fh.write(str(NOW - 100.0))
-
-    def teardown_method(self):
-        self.tmp_dir.cleanup()
-
-    # Last run was in NOW - 100s, we run compare tags every 10s.
-    def test_is_compare_tags_elapsed(self, mock_gql, mock_settings, mock_time):
-        qm = QuayMirror(control_file_dir=self.tmp_dir.name, compare_tags_interval=10)
-        assert qm.is_compare_tags
-
-    # Same as before, but now we force no compare with the option.
-    def test_is_compare_tags_force_no_compare(self, mock_gql, mock_settings, mock_time):
-        qm = QuayMirror(
-            control_file_dir=self.tmp_dir.name,
-            compare_tags_interval=10,
-            compare_tags=False,
-        )
-        assert not qm.is_compare_tags
-
-    # Last run was in NOW - 100s, we run compare tags every 1000s.
-    def test_is_compare_tags_not_elapsed(self, mock_gql, mock_settings, mock_time):
-        qm = QuayMirror(control_file_dir=self.tmp_dir.name, compare_tags_interval=1000)
-        assert not qm.is_compare_tags
-
-    # Same as before, but now we force compare with the option.
-    def test_is_compare_tags_force_compare(self, mock_gql, mock_settings, mock_time):
-        qm = QuayMirror(
-            control_file_dir=self.tmp_dir.name,
-            compare_tags_interval=1000,
-            compare_tags=True,
-        )
-        assert qm.is_compare_tags
-
-
-@pytest.mark.parametrize(
-    "tags, tags_exclude, candidate, result",
-    [
-        # Tags include tests.
-        (["^sha256-.+sig$", "^main-.+"], None, "main-755781cc", True),
-        (["^sha256-.+sig$", "^main-.+"], None, "sha256-8b5.sig", True),
-        (["^sha256-.+sig$", "^main-.+"], None, "1.2.3", False),
-        # Tags exclude tests.
-        (None, ["^sha256-.+sig$", "^main-.+"], "main-755781cc", False),
-        (None, ["^sha256-.+sig$", "^main-.+"], "sha256-8b5.sig", False),
-        # When both includes and excludes are explicitly given, includes take precedence.
-        (
-            ["^sha256-.+sig$", "^main-.+"],
-            ["^sha256-.+sig$", "^main-.+"],
-            "main-755781cc",
-            True,
-        ),
-        (
-            ["^sha256-.+sig$", "^main-.+"],
-            ["^sha256-.+sig$", "^main-.+"],
-            "sha256-8b5.sig",
-            True,
-        ),
-    ],
-)
-def test_sync_tag(tags, tags_exclude, candidate, result):
-    assert QuayMirror.sync_tag(tags, tags_exclude, candidate) == result

reconcile/test/test_quay_mirror_org.py

@@ -1,70 +0,0 @@
-import os
-import tempfile
-from unittest.mock import patch
-
-import pytest
-
-from reconcile.quay_mirror_org import (
-    CONTROL_FILE_NAME,
-    QuayMirrorOrg,
-)
-
-NOW = 1662124612.995397
-
-
-@patch("reconcile.utils.gql.get_api", autospec=True)
-@patch("reconcile.queries.get_app_interface_settings", return_value={})
-class TestControlFile:
-    def test_control_file_dir_does_not_exist(self, mock_gql, mock_settings):
-        with pytest.raises(FileNotFoundError):
-            QuayMirrorOrg(control_file_dir="/no-such-dir")
-
-    def test_control_file_path_from_given_dir(self, mock_gql, mock_settings):
-        with tempfile.TemporaryDirectory() as tmp_dir_name:
-            qm = QuayMirrorOrg(control_file_dir=tmp_dir_name)
-            assert qm.control_file_path == os.path.join(tmp_dir_name, CONTROL_FILE_NAME)
-
-
-@patch("reconcile.utils.gql.get_api", autospec=True)
-@patch("reconcile.queries.get_app_interface_settings", return_value={})
-@patch("time.time", return_value=NOW)
-class TestIsCompareTags:
-    def setup_method(self):
-        self.tmp_dir = (
-            tempfile.TemporaryDirectory()  # pylint: disable=consider-using-with
-        )
-        with open(os.path.join(self.tmp_dir.name, CONTROL_FILE_NAME), "w") as fh:
-            fh.write(str(NOW - 100.0))
-
-    def teardown_method(self):
-        self.tmp_dir.cleanup()
-
-    # Last run was in NOW - 100s, we run compare tags every 10s.
-    def test_is_compare_tags_elapsed(self, mock_gql, mock_settings, mock_time):
-        qm = QuayMirrorOrg(control_file_dir=self.tmp_dir.name, compare_tags_interval=10)
-        assert qm.is_compare_tags
-
-    # Same as before, but now we force no compare with the option.
-    def test_is_compare_tags_force_no_compare(self, mock_gql, mock_settings, mock_time):
-        qm = QuayMirrorOrg(
-            control_file_dir=self.tmp_dir.name,
-            compare_tags_interval=10,
-            compare_tags=False,
-        )
-        assert not qm.is_compare_tags
-
-    # Last run was in NOW - 100s, we run compare tags every 1000s.
-    def test_is_compare_tags_not_elapsed(self, mock_gql, mock_settings, mock_time):
-        qm = QuayMirrorOrg(
-            control_file_dir=self.tmp_dir.name, compare_tags_interval=1000
-        )
-        assert not qm.is_compare_tags
-
-    # Same as before, but now we force compare with the option.
-    def test_is_compare_tags_force_compare(self, mock_gql, mock_settings, mock_time):
-        qm = QuayMirrorOrg(
-            control_file_dir=self.tmp_dir.name,
-            compare_tags_interval=1000,
-            compare_tags=True,
-        )
-        assert qm.is_compare_tags

reconcile/test/test_quay_repos.py

@@ -1,59 +0,0 @@
-from unittest.mock import patch
-
-from reconcile.quay_base import OrgKey
-from reconcile.quay_repos import (
-    RepoInfo,
-    act,
-)
-
-from .fixtures import Fixtures
-
-fxt = Fixtures("quay_repos")
-
-
-def build_state(fixture_state):
-    return [
-        RepoInfo(
-            org_key=OrgKey("instance", "org"),
-            name=item[0],
-            public=item[1],
-            description=item[2],
-        )
-        for item in fixture_state
-    ]
-
-
-def get_test_repo_from_state(state, name):
-    for item in state:
-        if item.name == name:
-            return item
-    return None
-
-
-class TestQuayRepos:
-    @staticmethod
-    @patch("reconcile.quay_repos.act_public")
-    @patch("reconcile.quay_repos.act_description")
-    @patch("reconcile.quay_repos.act_delete")
-    @patch("reconcile.quay_repos.act_create")
-    def test_act(act_create, act_delete, act_description, act_public):
-        fixture = fxt.get_anymarkup("state.yml")
-
-        current_state = build_state(fixture["current_state"])
-        desired_state = build_state(fixture["desired_state"])
-
-        quay_api_store = {}
-        dry_run = True
-        act(dry_run, quay_api_store, current_state, desired_state)
-
-        repo_delete = get_test_repo_from_state(current_state, "repo_delete")
-        act_delete.assert_called_once_with(dry_run, quay_api_store, repo_delete)
-
-        repo_create = get_test_repo_from_state(desired_state, "repo_create")
-        act_create.assert_called_once_with(dry_run, quay_api_store, repo_create)
-
-        repo_desc = get_test_repo_from_state(desired_state, "repo_desc")
-        act_description.assert_called_once_with(dry_run, quay_api_store, repo_desc)
-
-        repo_public = get_test_repo_from_state(desired_state, "repo_public")
-        act_public.assert_called_once_with(dry_run, quay_api_store, repo_public)