qontract-reconcile 0.10.1rc1201__py3-none-any.whl → 0.10.2.dev1__py3-none-any.whl

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,172 +0,0 @@
-import os
-import tempfile
-from unittest.mock import create_autospec, patch
-
-import pytest
-import requests
-
-from reconcile.quay_mirror import (
-    CONTROL_FILE_NAME,
-    OrgKey,
-    QuayMirror,
-    queries,
-)
-
-from .fixtures import Fixtures
-
-NOW = 1662124612.995397
-
-fxt = Fixtures("quay_mirror")
-
-
-@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", encoding="locale"
-        ) 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),
-        (None, ["^sha256-.+sig$", "^main-.+"], "1.2.3", True),
-        # When both includes and excludes are explicitly given, exclude take precedence.
-        (["^sha256-.+sig$", "^main-.+"], ["main-755781cc"], "main-755781cc", False),
-        (["^sha256-.+sig$", "^main-.+"], ["main-755781cc"], "sha256-8b5.sig", True),
-        # both include and exclude are not set
-        (None, None, "main-755781cc", True),
-    ],
-)
-def test_sync_tag(tags, tags_exclude, candidate, result):
-    assert QuayMirror.sync_tag(tags, tags_exclude, candidate) == result
-
-
-def test_process_repos_query_ok(mocker):
-    repos_query = mocker.patch.object(queries, "get_quay_repos")
-    repos_query.return_value = fxt.get_anymarkup("get_quay_repos_ok.yaml")
-
-    cloudservices = OrgKey(instance="quay.io", org_name="cloudservices")
-    app_sre = OrgKey(instance="quay.io", org_name="app-sre")
-    session = create_autospec(requests.Session)
-    timeout = 30
-
-    summary = QuayMirror.process_repos_query()
-    assert len(summary) == 2
-    assert len(summary[cloudservices]) == 2
-    assert len(summary[app_sre]) == 1
-
-    mosquitto = "docker.io/library/eclipse-mosquitto"
-    redis = "docker.io/redis"
-
-    summary = QuayMirror.process_repos_query(
-        repository_urls=[mosquitto, redis],
-        session=session,
-        timeout=timeout,
-    )
-    cl = summary[cloudservices]
-    ap = summary[app_sre]
-    assert len(cl) == 2
-    assert len(ap) == 0
-    assert cl[0]["mirror"]["url"] == mosquitto
-    assert cl[1]["mirror"]["url"] == redis
-
-    summary = QuayMirror.process_repos_query(
-        exclude_repository_urls=[mosquitto, redis],
-        session=session,
-        timeout=timeout,
-    )
-    cl = summary[cloudservices]
-    ap = summary[app_sre]
-    assert len(cl) == 0
-    assert len(summary[app_sre]) == 1
-
-
-def test_process_repos_query_public_dockerhub(mocker, caplog):
-    repos_query = mocker.patch.object(queries, "get_quay_repos")
-    repos_query.return_value = fxt.get_anymarkup("get_quay_repos_public_dockerhub.yaml")
-
-    with pytest.raises(SystemExit):
-        QuayMirror.process_repos_query()
-
-    assert "can't be mirrored to a public quay repository" in caplog.text
-
-
-def test_quay_mirror_session(mocker):
-    mocker.patch("reconcile.quay_mirror.gql")
-    mocker.patch("reconcile.quay_mirror.queries")
-    mocked_request = mocker.patch("reconcile.quay_mirror.requests")
-
-    with QuayMirror() as quay_mirror:
-        assert quay_mirror.session == mocked_request.Session.return_value
-
-    mocked_request.Session.return_value.close.assert_called_once_with()

reconcile/test/test_quay_mirror_org.py

@@ -1,82 +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", encoding="locale"
-        ) 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
-
-
-def test_quay_mirror_org_session(mocker):
-    mocker.patch("reconcile.quay_mirror_org.get_quay_api_store")
-    mocked_request = mocker.patch("reconcile.quay_mirror_org.requests")
-
-    with QuayMirrorOrg() as quay_mirror_org:
-        assert quay_mirror_org.session == mocked_request.Session.return_value
-
-    mocked_request.Session.return_value.close.assert_called_once_with()

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)

reconcile/test/test_queries.py

@@ -1,53 +0,0 @@
-from copy import deepcopy
-from typing import Any
-from unittest.mock import (
-    create_autospec,
-    patch,
-)
-
-from reconcile import queries
-from reconcile.utils import gql
-
-from .fixtures import Fixtures
-
-
-class TestQueries:
-    def setup_method(self) -> None:
-        """This starts a patch on gql.query method which will answer with the
-        contents of self.fixture_data."""
-
-        # Resetting this to make sure it is set from every test
-        self.fixture_data: dict[str, Any] = {}
-
-        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
-
-    def teardown_method(self) -> None:
-        """Cleanup patches created in self.setup_method"""
-        self.gql_patcher.stop()
-
-    def mock_gql_query(self, query: str) -> dict[str, Any]:
-        return self.fixture_data
-
-    def test_get_pipelines_providers_all_defaults(self) -> None:
-        data = Fixtures("queries").get_json("pipelines_providers_all_defaults.json")
-        self.fixture_data = deepcopy(data)
-        pps = queries.get_pipelines_providers()
-
-        for k in ["retention", "taskTemplates", "pipelineTemplates", "deployResources"]:
-            assert data["pipelines_providers"][0]["defaults"][k] == pps[0][k]
-
-    def test_get_pipelines_providers_mixed(self) -> None:
-        data = Fixtures("queries").get_json("pipelines_providers_mixed.json")
-        self.fixture_data = deepcopy(data)
-        pps = queries.get_pipelines_providers()
-
-        # the fixture has some keys overriden from the defaults
-        for k in ["taskTemplates", "pipelineTemplates"]:
-            assert data["pipelines_providers"][0]["defaults"][k] == pps[0][k]
-
-        for k in ["retention", "deployResources"]:
-            assert data["pipelines_providers"][0][k] == pps[0][k]

reconcile/test/test_repo_owners.py

@@ -1,47 +0,0 @@
-from reconcile.utils import repo_owners
-
-
-def test_repo_owners_subpath() -> None:
-    def _mock_get_owners_map():
-        return {
-            "/foo": {
-                "approvers": ["foo_approver"],
-                "reviewers": ["foo_reviewer"],
-            },
-            "/foobar": {
-                "approvers": ["foobar_approver"],
-                "reviewers": ["foobar_reviewer"],
-            },
-            "/bar": {
-                "approvers": ["bar_approver"],
-                "reviewers": ["bar_reviewer"],
-            },
-        }
-
-    owners = repo_owners.RepoOwners(None)
-    owners._get_owners_map = _mock_get_owners_map  # type: ignore
-    assert owners.get_path_owners("/foobar/baz") == {
-        "approvers": ["foobar_approver"],
-        "reviewers": ["foobar_reviewer"],
-    }
-
-
-def test_repo_owners_subpath_closest() -> None:
-    def _mock_get_owners_map():
-        return {
-            "/": {
-                "approvers": ["root_approver"],
-                "reviewers": ["root_reviewer"],
-            },
-            "/foo": {
-                "approvers": ["foo_approver"],
-                "reviewers": ["foo_reviewer"],
-            },
-        }
-
-    owners = repo_owners.RepoOwners(None)
-    owners._get_owners_map = _mock_get_owners_map  # type: ignore
-    assert owners.get_path_closest_owners("/foobar/baz") == {
-        "approvers": ["root_approver"],
-        "reviewers": ["root_reviewer"],
-    }

reconcile/test/test_requests_sender.py

@@ -1,139 +0,0 @@
-import os
-import sys
-from subprocess import CalledProcessError
-from unittest import TestCase
-from unittest.mock import patch
-
-import reconcile.requests_sender as integ
-from reconcile import (
-    queries,
-    typed_queries,
-)
-
-
-class TestRunInteg(TestCase):
-    def setUp(self):
-        os.environ["APP_INTERFACE_STATE_BUCKET_ACCOUNT"] = "anaccount"
-        self.user = {
-            "org_username": "myorg",
-            "public_gpg_key": "mykey",
-        }
-
-        self.requests = [
-            {
-                "user": self.user,
-                "credentials": "credentials_name",
-                "name": "aname",
-            }
-        ]
-
-        self.exit_patcher = patch.object(sys, "exit", autospec=True)
-        self.get_encrypted_creds_patcher = patch.object(
-            integ, "get_encrypted_credentials"
-        )
-        self.smtpclient_patcher = patch.object(integ, "SmtpClient", autospec=True)
-        self.get_settings_patcher = patch.object(
-            queries, "get_app_interface_settings", autospec=True
-        )
-        self.get_smtp_credentials_patcher = patch.object(
-            integ, "get_smtp_server_connection", autospec=True
-        )
-        self.smtp_settings_patcher = patch.object(
-            typed_queries.smtp, "settings", autospec=True
-        )
-        self.get_aws_accounts_patcher = patch.object(
-            queries, "get_aws_accounts", autospec=True
-        )
-        self.get_credentials_requests_patcher = patch.object(
-            queries, "get_credentials_requests", autospec=True
-        )
-        self.state_patcher = patch.object(integ, "init_state", autospec=True)
-        self.vault_settings_patcher = patch.object(
-            integ,
-            "get_app_interface_vault_settings",
-            autospec=True,
-        )
-
-        self.do_exit = self.exit_patcher.start()
-        self.get_encrypted_credentials = self.get_encrypted_creds_patcher.start()
-        self.smtpclient = self.smtpclient_patcher.start()
-        self.get_app_interface_settings = self.get_settings_patcher.start()
-        self.get_smtp_credentials = self.get_smtp_credentials_patcher.start()
-        self.smtp_settings = self.smtp_settings_patcher.start()
-        self.get_aws_accounts = self.get_aws_accounts_patcher.start()
-        self.get_credentials_requests = self.get_credentials_requests_patcher.start()
-        self.get_credentials_requests.return_value = self.requests
-        self.get_encrypted_credentials.return_value = "anencryptedcred"
-        self.state = self.state_patcher.start()
-        self.vault_settings_patcher.start()
-        self.settings = {
-            "smtp": {
-                "secret_path": "asecretpath",
-                "server": "aserver",
-                "password": "apassword",
-                "port": 993,
-                "require_tls": True,
-                "username": "asmtpuser",
-            }
-        }
-        self.get_app_interface_settings.return_value = self.settings
-        self.get_aws_accounts.return_value = ["anaccount"]
-
-    def tearDown(self):
-        for p in (
-            self.exit_patcher,
-            self.get_encrypted_creds_patcher,
-            self.smtpclient_patcher,
-            self.get_settings_patcher,
-            self.get_smtp_credentials_patcher,
-            self.smtp_settings_patcher,
-            self.get_credentials_requests_patcher,
-            self.get_aws_accounts_patcher,
-            self.state_patcher,
-            self.vault_settings_patcher,
-        ):
-            p.stop()
-
-    def test_valid_credentials(self):
-        # Yeah, yeah, whatever
-        self.state.return_value.exists.return_value = False
-        integ.run(False)
-        # This has succeeded
-        self.do_exit.assert_not_called()
-        self.get_encrypted_credentials.assert_called_once_with(
-            "credentials_name", self.user, self.settings
-        )
-        calls = self.smtpclient.return_value.send_mail.call_args_list
-        self.assertEqual(len(calls), 1)
-        # I don't care too much about the body of the email, TBH
-        self.assertEqual(calls[0][0][:-1], (["myorg"], "aname"))
-        # Just check that we're still sending the encrypted credential
-        # in the body. This assertion is backwards with regards to all
-        # other assertions :(
-        self.assertIn("anencryptedcred", calls[0][0][-1])
-
-    def test_existing_credentials(self):
-        self.state.return_value.exists.return_value = True
-        integ.run(False)
-        self.do_exit.assert_not_called()
-        self.get_encrypted_credentials.assert_not_called()
-        self.smtpclient.return_value.send_mail.assert_not_called()
-
-    def test_invalid_credentials(self):
-        self.get_encrypted_credentials.side_effect = CalledProcessError(
-            stderr="iadaiada", returncode=1, cmd="a command"
-        )
-        self.state.return_value.exists.return_value = False
-        integ.run(False)
-        self.do_exit.assert_called_once()
-        self.get_encrypted_credentials.assert_called_once()
-        self.smtpclient.return_value.send_mail.assert_not_called()
-
-    def test_dry_run_honored(self):
-        self.state.return_value.exists.return_value = False
-        integ.run(True)
-
-        self.get_encrypted_credentials.assert_called_once()
-        self.do_exit.assert_not_called()
-        self.smtpclient.return_value.send_mail.assert_not_called()
-        self.state.return_value.add.assert_not_called()