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

reconcile/test/test_utils_jsonpath.py

@@ -1,286 +0,0 @@
-from typing import Optional
-
-import pytest
-from jsonpath_ng import (
-    Child,
-    Fields,
-    Index,
-    Slice,
-    This,
-)
-from jsonpath_ng.ext import parse
-from jsonpath_ng.ext.filter import (
-    Expression,
-    Filter,
-)
-
-from reconcile.utils.jsonpath import (
-    apply_constraint_to_path,
-    jsonpath_parts,
-    narrow_jsonpath_node,
-    parse_jsonpath,
-    remove_prefix_from_path,
-    sortable_jsonpath_string_repr,
-)
-
-#
-# test jsonpath splitting
-#
-
-
-def test_jsonpath_parts():
-    path = parse("$.a.b.c")
-    assert jsonpath_parts(path) == [parse("$"), parse("a"), parse("b"), parse("c")]
-
-
-def test_jsonpath_parts_root_only():
-    path = parse("$")
-    assert jsonpath_parts(path) == [parse("$")]
-
-
-def test_jsonpath_parts_with_index():
-    path = parse("a[0]")
-    assert jsonpath_parts(path) == [parse("a"), Index(0)]
-
-
-def test_jsonpath_parts_with_slice_all():
-    path = parse("a[*]")
-    assert jsonpath_parts(path) == [parse("a"), Slice(None, None, None)]
-
-
-def test_jsonpath_parts_with_filter():
-    path = parse("a.b[?(@.c=='c')].d")
-    assert jsonpath_parts(path) == [
-        parse("a"),
-        parse("b"),
-        Filter(expressions=[Expression(Child(This(), Fields("c")), "==", "c")]),
-        parse("d"),
-    ]
-
-
-def test_jsonpath_parts_with_filter_ignore():
-    path = parse("a.b[?(@.c=='c')].d")
-    assert jsonpath_parts(path, ignore_filter=True) == [
-        parse("a"),
-        parse("b"),
-        parse("d"),
-    ]
-
-
-def test_jsonpath_parts_ignore_root():
-    path = parse("$.a.b")
-    assert jsonpath_parts(path, ignore_root=True) == [
-        parse("a"),
-        parse("b"),
-    ]
-
-
-def test_jsonpath_parts_without_ignore_root():
-    path = parse("$.a.b")
-    assert jsonpath_parts(path) == [
-        parse("$"),
-        parse("a"),
-        parse("b"),
-    ]
-
-
-#
-# test narrow jsonpath node
-#
-
-
-def test_narrow_jsonpath_node_field_equal():
-    assert narrow_jsonpath_node(parse("a"), parse("a")) == parse("a")
-
-
-def test_narrow_jsonpath_node_field_not_equal():
-    assert not narrow_jsonpath_node(parse("a"), parse("b"))
-
-
-def testnarrow_jsonpath_node_index_equal():
-    assert narrow_jsonpath_node(Index(0), Index(0)) == Index(0)
-
-
-def test_narrow_jsonpath_node_index_slice():
-    assert narrow_jsonpath_node(Index(0), Slice(None, None, None)) == Index(0)
-
-
-def test_narrow_jsonpath_node_slice_index():
-    assert narrow_jsonpath_node(Slice(None, None, None), Index(0)) == Index(0)
-
-
-def test_narrow_jsonpath_node_slice_slice():
-    assert narrow_jsonpath_node(
-        Slice(None, None, None), Slice(None, None, None)
-    ) == Slice(None, None, None)
-
-
-def test_narrow_jsonpath_node_filter_equal():
-    assert narrow_jsonpath_node(
-        Filter(expressions=[Expression(Child(This(), Fields("c")), "==", "c")]),
-        Filter(expressions=[Expression(Child(This(), Fields("c")), "==", "c")]),
-    ) == Filter(expressions=[Expression(Child(This(), Fields("c")), "==", "c")])
-
-
-def test_narrow_jsonpath_node_filter_not_equal():
-    assert (
-        narrow_jsonpath_node(
-            Filter(expressions=[Expression(Child(This(), Fields("c")), "==", "c")]),
-            Filter(expressions=[Expression(Child(This(), Fields("d")), "==", "d")]),
-        )
-        is None
-    )
-
-
-def test_narrow_jsonpath_node_filter_slice():
-    filter = Filter(expressions=[Expression(Child(This(), Fields("c")), "==", "c")])
-    assert (
-        narrow_jsonpath_node(
-            filter,
-            Slice(None, None, None),
-        )
-        == filter
-    )
-
-
-def test_narrow_jsonpath_node_silce_filter():
-    filter = Filter(expressions=[Expression(Child(This(), Fields("c")), "==", "c")])
-    assert (
-        narrow_jsonpath_node(
-            Slice(None, None, None),
-            filter,
-        )
-        == filter
-    )
-
-
-def test_narrow_jsonpath_node_index_filter():
-    assert narrow_jsonpath_node(
-        Index(0),
-        Filter(expressions=[Expression(Child(This(), Fields("c")), "==", "c")]),
-    ) == Index(0)
-
-
-def test_narrow_jsonpath_node_filter_index():
-    assert narrow_jsonpath_node(
-        Filter(expressions=[Expression(Child(This(), Fields("c")), "==", "c")]),
-        Index(0),
-    ) == Index(0)
-
-
-def test_narrow_jsonpath_node_field_wildcard():
-    assert narrow_jsonpath_node(parse("a"), parse("*")) == parse("a")
-
-
-def test_narrow_jsonpath_node_wildcard_field():
-    assert narrow_jsonpath_node(parse("*"), parse("a")) == parse("a")
-
-
-def test_narrow_jsonpath_node_wildcard_wildcard():
-    assert narrow_jsonpath_node(parse("*"), parse("*")) == parse("*")
-
-
-#
-# narrow jsonpath expression
-#
-
-
-def test_apply_constraint_to_path_equal():
-    assert apply_constraint_to_path(parse("a.b.c"), parse("a.b.c")) == parse("a.b.c")
-
-
-def test_apply_constraint_to_longer_path():
-    assert apply_constraint_to_path(parse("a.b[*].c.f"), parse("a.b[0].c")) == parse(
-        "a.b[0].c.f"
-    )
-
-
-def test_apply_constraint_to_shorter_path():
-    assert apply_constraint_to_path(parse("a.b[*]"), parse("a.b[0].c")) == parse(
-        "a.b[0]"
-    )
-
-
-def test_apply_constraint_to_unrelated_path():
-    assert not apply_constraint_to_path(parse("a.b[*]"), parse("d.e[0].f"))
-
-
-def test_apply_incompatible_constraint_to_path():
-    assert apply_constraint_to_path(parse("a.b[0].f"), parse("a.b[1].c")) == parse(
-        "a.b[0].f"
-    )
-
-
-def test_apply_partially_incompatible_constraint_to_path():
-    assert apply_constraint_to_path(
-        parse("a.b[*].c[0].d"), parse("a.b[1].c[1]")
-    ) == parse("a.b[1].c[0].d")
-
-
-def test_apply_field_constraint_to_wildcard_path():
-    assert apply_constraint_to_path(parse("a.*.c"), parse("a.b.c.d")) == parse("a.b.c")
-
-
-#
-# test sortable jsonpath representation
-#
-
-
-@pytest.mark.parametrize(
-    "jsonpath, sortable_jsonpath",
-    [
-        ("a.b[0].c", "a.b.[00000].c"),
-        ("a.b[10].c", "a.b.[00010].c"),
-        ("[10]", "[00010]"),
-        ("a.[10][*]", "a.[00010].*"),
-    ],
-)
-def test_sortable_jsonpath_string_repr(jsonpath: str, sortable_jsonpath: str):
-    assert sortable_jsonpath_string_repr(parse(jsonpath), 5) == sortable_jsonpath
-
-
-#
-# test remove prefix from path
-#
-
-
-@pytest.mark.parametrize(
-    "path, prefix, expected",
-    [
-        # simple prefix
-        ("a.b.c.d.e", "a.b.c", "d.e"),
-        # the path is has not the defined prefix
-        ("a.b.c.d.e", "f.g", None),
-        # path and prefix are the same
-        ("a.b.c.d.e", "a.b.c.d.e", None),
-        # path with index
-        ("a.b[1].c", "a", "b[1].c"),
-        # path with index after the prefix
-        ("a.b[1].c", "a.b", "[1].c"),
-        # prefix is root
-        ("a.b", "$", "a.b"),
-        # prefix and path are root
-        ("$", "$", None),
-    ],
-)
-def test_remove_prefix_from_path(path: str, prefix: str, expected: Optional[str]):
-    expected_path = parse(expected) if expected else None
-    assert remove_prefix_from_path(parse(path), parse(prefix)) == expected_path
-
-
-#
-# P A R S I N G
-#
-
-
-@pytest.mark.parametrize(
-    "path, rendered",
-    [
-        # simple path for the regular parser
-        ("a.b.c", "a.b.c"),
-        # this one requires the extended parser
-        ("a[?(@.b=='b')]", "a.[?[Expression(Child(This(), Fields('b')) == 'b')]]"),
-    ],
-)
-def test_parse_jsonpath(path: str, rendered: str):
-    assert str(parse_jsonpath(path)) == rendered

reconcile/test/test_utils_ldap_client.py

@@ -1,51 +0,0 @@
-import ldap3
-import pytest
-
-from reconcile.utils.ldap_client import LdapClient
-
-
-@pytest.fixture
-def connection_search_result():
-    result = [
-        {"attributes": {"uid": ["user1"]}},
-        {"attributes": {"uid": ["user2"]}},
-        {"attributes": {"uid": ["user3"]}},
-    ]
-    return result
-
-
-def test_ldap_client_from_settings(mocker):
-    mock_connection_bind = mocker.patch(
-        "reconcile.utils.ldap_client.Connection", autospec=True
-    )
-
-    settings = {"ldap": {"baseDn": "test", "serverUrl": "testUrl"}}
-    with LdapClient.from_settings(settings) as ldap_client:
-        assert ldap_client.base_dn == "test"
-        assert mock_connection_bind.call_args.args[0].host == "testUrl"
-
-
-def test_ldap_client(mocker, connection_search_result):
-    mocked_connection = mocker.Mock(spec=ldap3.Connection)
-    mocked_connection.search.return_value = None, None, connection_search_result, None
-
-    with LdapClient("test", mocked_connection) as ldap_client:
-        assert ldap_client.base_dn == "test"
-
-    mocked_connection.bind.assert_called_once_with()
-    mocked_connection.unbind.assert_called_once_with()
-
-
-def test_ldap_client_get_users(mocker, connection_search_result):
-    mocked_connection = mocker.Mock(spec=ldap3.Connection)
-    mocked_connection.search.return_value = None, None, connection_search_result, None
-
-    with LdapClient("test", mocked_connection) as ldap_client:
-        uids = ["user1", "user2", "user3"]
-        ldap_client.get_users(uids)
-
-    mocked_connection.search.assert_called_once_with(
-        "test",
-        "(&(objectclass=person)(|(uid=user1)(uid=user2)(uid=user3)))",
-        attributes=["uid"],
-    )

reconcile/test/test_utils_mr.py

@@ -1,226 +0,0 @@
-from typing import (
-    Any,
-    Optional,
-)
-from unittest import TestCase
-from unittest.mock import MagicMock
-
-import pytest
-import yaml
-from gitlab.exceptions import GitlabError
-
-from reconcile.utils.gitlab_api import GitLabApi
-from reconcile.utils.mr.base import (
-    MergeRequestBase,
-    MergeRequestProcessingError,
-    app_interface_email,
-)
-
-
-class DummyMergeRequest(MergeRequestBase):
-    def __init__(self, process_error: Optional[Exception] = None):
-        super().__init__()
-        self.process_error = process_error
-
-    @property
-    def title(self):
-        return "xxx"
-
-    @property
-    def description(self):
-        return "xxx"
-
-    def process(self, gitlab_cli):
-        if self.process_error:
-            raise self.process_error
-
-
-def build_gitlab_cli_mock(
-    mr_exists: bool = False,
-    diffs: Optional[list] = None,
-    create_branch_error: Optional[Exception] = None,
-) -> GitLabApi:
-    cli = MagicMock(spec=GitLabApi)
-    cli.mr_exists.return_value = mr_exists
-    if create_branch_error:
-        cli.create_branch.side_effect = create_branch_error
-    cli.project = MagicMock()
-    cli.project.mergerequests = MagicMock()
-    if diffs is not None:
-        cli.project.repository_compare.return_value = {"diffs": diffs}
-    return cli
-
-
-class TestMergeRequestBaseProcessContractTests(TestCase):
-    """
-    These testcases are here to ensure that
-    MergeRequestBase.process() is raises an exception
-    when the PR was not opened for a valid reason like
-    communication errors, gitlab errors, bugs :)
-    """
-
-    @staticmethod
-    def test_mr_opened():
-        cli = build_gitlab_cli_mock()
-        mr = DummyMergeRequest()
-        mr.submit_to_gitlab(cli)
-        cli.project.mergerequests.create.assert_called()
-
-    def test_cancellation_on_duplicate_mr(self):
-        cli = build_gitlab_cli_mock(mr_exists=True)
-        mr = DummyMergeRequest()
-        mr.submit_to_gitlab(cli)
-        self.assertTrue(mr.cancelled)
-        cli.project.mergerequests.create.assert_not_called()
-
-    def test_cancellation_on_empty_mr(self):
-        cli = build_gitlab_cli_mock(diffs=[])
-        mr = DummyMergeRequest()
-        mr.submit_to_gitlab(cli)
-        self.assertTrue(mr.cancelled)
-        cli.project.mergerequests.create.assert_not_called()
-
-    def test_failure_during_branching(self):
-        cli = build_gitlab_cli_mock(create_branch_error=GitlabError())
-        mr = DummyMergeRequest()
-        with self.assertRaises(MergeRequestProcessingError):
-            mr.submit_to_gitlab(cli)
-        self.assertFalse(cli.project.mergerequests.create.called)
-
-    def test_failure_during_processing(self):
-        cli = build_gitlab_cli_mock()
-        mr = DummyMergeRequest(process_error=GitlabError())
-        with self.assertRaises(MergeRequestProcessingError):
-            mr.submit_to_gitlab(cli)
-        cli.project.mergerequests.create.assert_not_called()
-
-
-@pytest.mark.parametrize(
-    "aliases, expected_aliases",
-    [
-        pytest.param(
-            {},
-            {"aliases": []},
-            marks=pytest.mark.xfail(strict=True, raises=(KeyError, TypeError)),
-        ),
-        pytest.param(
-            {"aliases": []},
-            {"aliases": []},
-            marks=pytest.mark.xfail(strict=True, raises=(KeyError, TypeError)),
-        ),
-        (
-            {"aliases": ["alias1", "alias2"]},
-            {"aliases": ["alias1", "alias2"]},
-        ),
-    ],
-)
-@pytest.mark.parametrize(
-    "users, expected_users",
-    [
-        pytest.param(
-            {},
-            {"users": []},
-            marks=pytest.mark.xfail(strict=True, raises=(KeyError, TypeError)),
-        ),
-        pytest.param(
-            {"users": []},
-            {"users": []},
-            marks=pytest.mark.xfail(strict=True, raises=(KeyError, TypeError)),
-        ),
-        (
-            {"users": ["/path/to/user1", "/path/to/user2"]},
-            {
-                "users": [
-                    {"$ref": "/path/to/user1"},
-                    {"$ref": "/path/to/user2"},
-                ]
-            },
-        ),
-    ],
-)
-@pytest.mark.parametrize(
-    "aws_accounts, expected_aws_accounts",
-    [
-        pytest.param(
-            {},
-            {"aws_accounts": []},
-            marks=pytest.mark.xfail(strict=True, raises=(KeyError, TypeError)),
-        ),
-        pytest.param(
-            {"aws_accounts": []},
-            {"aws_accounts": []},
-            marks=pytest.mark.xfail(strict=True, raises=(KeyError, TypeError)),
-        ),
-        (
-            {"aws_accounts": ["/path/to/aws_account1", "/path/to/aws_account2"]},
-            {
-                "aws_accounts": [
-                    {"$ref": "/path/to/aws_account1"},
-                    {"$ref": "/path/to/aws_account2"},
-                ]
-            },
-        ),
-    ],
-)
-@pytest.mark.parametrize(
-    "services, expected_services",
-    [
-        pytest.param(
-            {},
-            {"services": []},
-            marks=pytest.mark.xfail(strict=True, raises=(KeyError, TypeError)),
-        ),
-        pytest.param(
-            {"apps": []},
-            {"services": []},
-            marks=pytest.mark.xfail(strict=True, raises=(KeyError, TypeError)),
-        ),
-        (
-            {"apps": ["/path/to/aws_account1", "/path/to/aws_account2"]},
-            {
-                "services": [
-                    {"$ref": "/path/to/aws_account1"},
-                    {"$ref": "/path/to/aws_account2"},
-                ]
-            },
-        ),
-    ],
-)
-def test_email_template(
-    aliases: dict[str, Any],
-    expected_aliases: dict[str, Any],
-    users: dict[str, Any],
-    expected_users: dict[str, Any],
-    aws_accounts: dict[str, Any],
-    expected_aws_accounts: dict[str, Any],
-    services: dict[str, Any],
-    expected_services: dict[str, Any],
-) -> None:
-    """Test email template"""
-
-    content = app_interface_email(
-        name="test-name",
-        subject="test-subject",
-        body="test-body",
-        **aliases,
-        **users,
-        **aws_accounts,
-        **services,
-    )
-
-    email = yaml.safe_load(content)
-    email["NAME"] = "test-name"
-    email["SUBJECT"] = "test-subject"
-    email["BODY"] = "test-body"
-
-    if not aliases and not users and not aws_accounts and not services:
-        assert not email["to"]
-
-    for key, value in expected_aliases.items():
-        assert email["to"][key] == value
-    for key, value in expected_users.items():
-        assert email["to"][key] == value
-    for key, value in expected_aws_accounts.items():
-        assert email["to"][key] == value
-    for key, value in expected_services.items():
-        assert email["to"][key] == value

reconcile/test/test_utils_mr_clusters_updates.py

@@ -1,77 +0,0 @@
-from io import StringIO
-from unittest import TestCase
-from unittest.mock import (
-    MagicMock,
-    patch,
-)
-
-import reconcile.utils.mr.clusters_updates as sut
-
-from .fixtures import Fixtures
-
-fxt = Fixtures("clusters")
-
-
-@patch.object(sut.CreateClustersUpdates, "cancel")
-class TestProcess(TestCase):
-    def setUp(self):
-        self.clusters = [fxt.get_anymarkup("cluster1.yml")]
-        self.raw_clusters = fxt.get("cluster1.yml")
-
-    def test_no_changes(self, cancel):
-        cli = MagicMock()
-        c = sut.CreateClustersUpdates({})
-        c.branch = "abranch"
-        c.main_branch = "main"
-        c.process(cli)
-        cancel.assert_called_once()
-
-        cli.project.files.get.assert_not_called()
-
-    def test_changes_to_spec(self, cancel):
-        cli = MagicMock()
-        cli.project.files.get.return_value = self.raw_clusters.encode()
-        c = sut.CreateClustersUpdates(
-            {"cluster1": {"spec": {"id": "42"}, "root": {}, "path": "/a/path"}}
-        )
-        c.branch = "abranch"
-        c.main_branch = "main"
-        c.process(cli)
-        self.clusters[0]["spec"]["id"] = "42"
-
-        cnt = StringIO()
-        sut.yaml.dump(self.clusters[0], cnt)
-        cli.update_file.assert_called_once_with(
-            branch_name="abranch",
-            file_path="/a/path",
-            commit_message="update cluster cluster1 spec fields",
-            content=cnt.getvalue(),
-        )
-        cancel.assert_not_called()
-
-    def test_changes_to_root(self, cancel):
-        cli = MagicMock()
-        cli.project.files.get.return_value = self.raw_clusters.encode()
-        c = sut.CreateClustersUpdates(
-            {
-                "cluster1": {
-                    "spec": {},
-                    "root": {"prometheusUrl": "aprometheusurl"},
-                    "path": "/a/path",
-                }
-            }
-        )
-        c.branch = "abranch"
-        c.main_branch = "main"
-        c.process(cli)
-        self.clusters[0]["prometheusUrl"] = "aprometheusurl"
-
-        cnt = StringIO()
-        sut.yaml.dump(self.clusters[0], cnt)
-        cli.update_file.assert_called_once_with(
-            branch_name="abranch",
-            file_path="/a/path",
-            commit_message="update cluster cluster1 spec fields",
-            content=cnt.getvalue(),
-        )
-        cancel.assert_not_called()