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

reconcile/test/test_gitlab_housekeeping.py

@@ -1,333 +0,0 @@
-from datetime import (
-    datetime,
-    timedelta,
-)
-from unittest.mock import (
-    Mock,
-    create_autospec,
-    patch,
-)
-
-import pytest
-from gitlab import Gitlab
-from gitlab.v4.objects import (
-    Project,
-    ProjectCommit,
-    ProjectCommitManager,
-    ProjectIssue,
-    ProjectMergeRequest,
-    ProjectMergeRequestResourceLabelEvent,
-)
-from pytest_mock import MockerFixture
-
-import reconcile.gitlab_housekeeping as gl_h
-from reconcile.test.fixtures import Fixtures
-from reconcile.utils.gitlab_api import GitLabApi
-from reconcile.utils.secret_reader import SecretReader
-
-DATE_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
-
-fixture = Fixtures("gitlab_housekeeping").get_anymarkup("api.yml")
-
-
-def get_mock(path, query_data=None, streamed=False, raw=False, **kwargs):
-    path = path[1:]
-    data = fixture.get("gitlab").get(path)
-    return data
-
-
-class TestGitLabHousekeeping:
-    @staticmethod
-    @patch.object(SecretReader, "read")
-    @patch.object(Gitlab, "http_get")
-    @patch.object(Gitlab, "http_post")
-    def test_clean_pipelines_happy_path(http_post, http_get, secret_read):
-        http_get.side_effect = get_mock
-        now = datetime.utcnow()
-
-        ten_minutes_ago = now - timedelta(minutes=10)
-        two_hours_ago = now - timedelta(minutes=120)
-
-        pipelines = [
-            {
-                "id": 46,
-                "iid": 11,
-                "project_id": 1,
-                "status": "canceled",
-                "ref": "new-pipeline",
-                "sha": "dddd9c1e5c9015edee04321e423429d2f8924609",
-                "web_url": "https://example.com/foo/bar/pipelines/46",
-                "created_at": two_hours_ago.strftime(DATE_FORMAT),
-                "updated_at": two_hours_ago.strftime(DATE_FORMAT),
-            },
-            {
-                "id": 47,
-                "iid": 12,
-                "project_id": 1,
-                "status": "pending",
-                "ref": "new-pipeline",
-                "sha": "a91957a858320c0e17f3a0eca7cfacbff50ea29a",
-                "web_url": "https://example.com/foo/bar/pipelines/47",
-                "created_at": two_hours_ago.strftime(DATE_FORMAT),
-                "updated_at": two_hours_ago.strftime(DATE_FORMAT),
-            },
-            {
-                "id": 48,
-                "iid": 13,
-                "project_id": 1,
-                "status": "running",
-                "ref": "new-pipeline",
-                "sha": "eb94b618fb5865b26e80fdd8ae531b7a63ad851a",
-                "web_url": "https://example.com/foo/bar/pipelines/48",
-                "created_at": ten_minutes_ago.strftime(DATE_FORMAT),
-                "updated_at": ten_minutes_ago.strftime(DATE_FORMAT),
-            },
-        ]
-        instance = {"url": "http://localhost", "sslVerify": False, "token": "token"}
-
-        dry_run = False
-        timeout = 60
-
-        timeout_pipelines = gl_h.get_timed_out_pipelines(pipelines, timeout)
-        gl_h.clean_pipelines(dry_run, instance, "1", "", timeout_pipelines)
-
-        # Test if mock have this exact calls
-        http_post.assert_called_once_with("/projects/1/pipelines/47/cancel")
-
-
-def test_calculate_time_since_approval():
-    one_hour_ago = (datetime.utcnow() - timedelta(minutes=60)).strftime(DATE_FORMAT)
-
-    time_since_merge = gl_h._calculate_time_since_approval(one_hour_ago)
-
-    assert round(time_since_merge) == 60
-
-
-def test_is_rebase():
-    expected_ref = "master"
-    mr = create_autospec(ProjectMergeRequest)
-    mr.target_branch = expected_ref
-    expected_sha = "some-sha"
-    mr.sha = expected_sha
-
-    mocked_gitlab_api = create_autospec(GitLabApi)
-    mocked_gitlab_api.project = create_autospec(Project)
-    mocked_gitlab_api.project.commits = create_autospec(ProjectCommitManager)
-    mocked_commit = create_autospec(ProjectCommit)
-    expected_head = "some-id"
-    mocked_commit.id = expected_head
-    mocked_gitlab_api.project.commits.list.return_value = [mocked_commit]
-
-    mocked_gitlab_api.project.repository_compare.return_value = {"commits": []}
-
-    result = gl_h.is_rebased(mr, mocked_gitlab_api)
-
-    assert result is True
-    mocked_gitlab_api.project.commits.list.assert_called_once_with(
-        ref_name=expected_ref,
-        per_page=1,
-        page=1,
-    )
-    mocked_gitlab_api.project.repository_compare.assert_called_once_with(
-        expected_sha,
-        expected_head,
-    )
-
-
-@pytest.fixture
-def repo_gitlab_housekeeping() -> dict:
-    return {
-        "url": "https://gitlab.com/org/repo",
-        "housekeeping": {
-            "enabled": True,
-            "rebase": False,
-            "enable_closing": True,
-        },
-    }
-
-
-def test_dry_run(
-    mocker: MockerFixture,
-    repo_gitlab_housekeeping: dict,
-) -> None:
-    mocked_queries = mocker.patch("reconcile.gitlab_housekeeping.queries")
-    mocked_queries.get_repos_gitlab_housekeeping.return_value = [
-        repo_gitlab_housekeeping,
-    ]
-    mocked_gitlab_api = mocker.patch(
-        "reconcile.gitlab_housekeeping.GitLabApi", autospec=True
-    ).return_value.__enter__.return_value
-
-    gl_h.run(True, False)
-
-    mocked_gitlab_api.get_issues.assert_called_once_with(state="opened")
-    mocked_gitlab_api.get_merge_requests.assert_called_once_with(state="opened")
-    mocked_gitlab_api.get_app_sre_group_users.assert_called_once_with()
-
-
-@pytest.fixture
-def project() -> Project:
-    project = create_autospec(Project)
-    project.id = "some-id"
-    project.name = "some-name"
-    return project
-
-
-@pytest.fixture
-def can_be_merged_merge_request() -> Mock:
-    mr = create_autospec(ProjectMergeRequest)
-    mr.merge_status = "can_be_merged"
-    mr.draft = False
-    mr.commits.return_value = [create_autospec(ProjectCommit)]
-    mr.labels = ["lgtm"]
-    mr.iid = 1
-    mr.target_project_id = 3
-    mr.author = {"username": "user"}
-    return mr
-
-
-@pytest.fixture
-def add_lgtm_merge_request_resource_label_event() -> (
-    ProjectMergeRequestResourceLabelEvent
-):
-    event = create_autospec(ProjectMergeRequestResourceLabelEvent)
-    event.action = "add"
-    event.label = {"name": "lgtm"}
-    event.user = {"username": "user"}
-    event.created_at = "2023-01-01T00:00:00.0Z"
-    return event
-
-
-@pytest.fixture
-def success_merge_request_pipeline() -> dict:
-    return {
-        "status": "success",
-    }
-
-
-def test_merge_merge_requests(
-    project: Project,
-    can_be_merged_merge_request: Mock,
-    add_lgtm_merge_request_resource_label_event: ProjectMergeRequestResourceLabelEvent,
-    success_merge_request_pipeline: dict,
-) -> None:
-    mocked_gl = create_autospec(GitLabApi)
-    mocked_gl.project = project
-    mocked_gl.get_merge_request_label_events.return_value = [
-        add_lgtm_merge_request_resource_label_event
-    ]
-    mocked_gl.get_merge_request_pipelines.return_value = [
-        success_merge_request_pipeline
-    ]
-
-    gl_h.merge_merge_requests(
-        False,
-        mocked_gl,
-        [can_be_merged_merge_request],
-        gl_h.ReloadToggle(reload=False),
-        1,
-        False,
-        app_sre_usernames=set(),
-        pipeline_timeout=None,
-        insist=True,
-        wait_for_pipeline=False,
-        gl_instance=None,
-        gl_settings=None,
-        users_allowed_to_label=None,
-    )
-
-    can_be_merged_merge_request.merge.assert_called_once()
-
-
-@pytest.fixture
-def running_merge_request_pipeline() -> dict:
-    return {
-        "status": "running",
-    }
-
-
-def test_merge_merge_requests_with_retry(
-    mocker: MockerFixture,
-    project: Project,
-    can_be_merged_merge_request: ProjectMergeRequest,
-    add_lgtm_merge_request_resource_label_event: ProjectMergeRequestResourceLabelEvent,
-    running_merge_request_pipeline: dict,
-) -> None:
-    mocker.patch("time.sleep")
-    mocked_gl = create_autospec(GitLabApi)
-    mocked_gl.project = project
-    mocked_gl.get_merge_requests.return_value = [can_be_merged_merge_request]
-    mocked_gl.get_merge_request_label_events.return_value = [
-        add_lgtm_merge_request_resource_label_event
-    ]
-    mocked_gl.get_merge_request_pipelines.return_value = [
-        running_merge_request_pipeline
-    ]
-
-    with pytest.raises(gl_h.InsistOnPipelineError) as e:
-        gl_h.merge_merge_requests(
-            False,
-            mocked_gl,
-            [can_be_merged_merge_request],
-            gl_h.ReloadToggle(reload=False),
-            1,
-            False,
-            app_sre_usernames=set(),
-            pipeline_timeout=None,
-            insist=True,
-            wait_for_pipeline=True,
-            gl_instance=None,
-            gl_settings=None,
-            users_allowed_to_label=None,
-        )
-
-    assert (
-        f"Pipelines for merge request in project 'some-name' have not completed yet: {can_be_merged_merge_request.iid}"
-        == str(e.value)
-    )
-
-    assert mocked_gl.get_merge_requests.call_count == 9
-
-
-def test_close_item_with_enable_closing(
-    mocker: MockerFixture,
-    project: Project,
-) -> None:
-    mocked_gl = create_autospec(GitLabApi)
-    mocked_gl.project = project
-    mocked_logging = mocker.patch("reconcile.gitlab_housekeeping.logging")
-    mocked_issue = create_autospec(ProjectIssue)
-    mocked_issue.attributes = {"iid": 1}
-
-    gl_h.close_item(False, mocked_gl, True, "issue", mocked_issue)
-
-    mocked_gl.close.assert_called_once_with(mocked_issue)
-    mocked_logging.info.assert_called_once_with([
-        "close_item",
-        project.name,
-        "issue",
-        1,
-    ])
-    mocked_logging.debug.assert_not_called()
-
-
-def test_close_item_without_enable_closing(
-    mocker: MockerFixture,
-    project: Project,
-) -> None:
-    mocked_gl = create_autospec(GitLabApi)
-    mocked_gl.project = project
-    mocked_logging = mocker.patch("reconcile.gitlab_housekeeping.logging")
-    mocked_issue = create_autospec(ProjectIssue)
-    mocked_issue.attributes = {"iid": 1}
-
-    gl_h.close_item(False, mocked_gl, False, "issue", mocked_issue)
-
-    mocked_gl.close.assert_not_called()
-    mocked_logging.debug.assert_called_once_with([
-        "'enable_closing' is not enabled to close item",
-        project.name,
-        "issue",
-        1,
-    ])
-    mocked_logging.info.assert_not_called()

reconcile/test/test_gitlab_labeler.py

@@ -1,126 +0,0 @@
-from typing import Any
-from unittest.mock import (
-    create_autospec,
-    patch,
-)
-
-import reconcile.gitlab_labeler as gl
-from reconcile.queries import APPS_QUERY
-from reconcile.utils import gql
-
-from .fixtures import Fixtures
-
-
-class StubData:
-    """Class to add data to tests in setUp. It will be used by mocks"""
-
-    def __init__(self):
-        self._apps = []
-
-    @property
-    def apps(self) -> list[dict]:
-        return self._apps
-
-    @apps.setter
-    def apps(self, apps: list[dict]) -> None:
-        if not isinstance(apps, list):
-            raise TypeError(f"Expecting list, have {type(apps)}")
-        self._apps = apps
-
-
-# This was originally written in unittest, hence the use of xunit-style
-# setup/teardown methods instead of pytest fixtures.
-class TestOnboardingGuesser:
-    def setup_method(self) -> None:
-        self.test_data = StubData()
-
-        self.fxt = Fixtures("apps")
-        self.app1 = self.fxt.get_json("app1.json")
-        self.app2 = self.fxt.get_json("app2.json")
-        self.app3 = self.fxt.get_json("childapp.json")
-        self.app4 = self.fxt.get_json("parentapp.json")
-
-        # 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
-
-    def mock_gql_query(self, query: str) -> dict[str, Any] | None:
-        """Mock for GqlApi.query using test_data set in setUp"""
-        if query == APPS_QUERY:
-            return {"apps": self.test_data.apps}
-        return None
-
-    def teardown_method(self) -> None:
-        """cleanup patches created in self.setUp"""
-        self.gql_patcher.stop()
-
-    def test_get_app_list(self):
-        self.test_data.apps = [self.app1]
-        t = gl.get_app_list()
-        assert t == {"normalapp": {"onboardingStatus": "BestEffort", "parentApp": None}}
-
-    def test_get_app_list_2(self):
-        self.test_data.apps = [self.app1, self.app2]
-        t = gl.get_app_list()
-        assert t, {
-            "normalapp": {"onboardingStatus": "BestEffort", "parentApp": None},
-            "normalapp2": {"onboardingStatus": "BestEffort", "parentApp": None},
-        }
-
-    def test_get_parents_list(self):
-        self.test_data.apps = [self.app1, self.app2, self.app3]
-        t = gl.get_parents_list()
-        assert t == {"parentapp"}
-
-    def test_get_parents_list_empty(self):
-        self.test_data.apps = [self.app1, self.app2]
-        t = gl.get_parents_list()
-        assert t == set()
-
-    def test_guess_onboarding_status_child(self):
-        self.test_data.apps = [self.app1, self.app2, self.app3]
-        parents = gl.get_parents_list()
-        apps = gl.get_app_list()
-        changed_paths = ["data/services/parentapp/childapp"]
-
-        t = gl.guess_onboarding_status(changed_paths, apps, parents)
-        assert t == "BestEffort"
-
-    def test_guess_onboarding_status_parent(self):
-        self.test_data.apps = [self.app1, self.app2, self.app3, self.app4]
-        parents = gl.get_parents_list()
-        apps = gl.get_app_list()
-        changed_paths = ["data/services/parentapp/test"]
-
-        t = gl.guess_onboarding_status(changed_paths, apps, parents)
-        assert t == "OnBoarded"
-
-    def test_guess_onboarding_status_normal(self):
-        self.test_data.apps = [self.app1, self.app2, self.app3]
-        parents = gl.get_parents_list()
-        apps = gl.get_app_list()
-        changed_paths = ["data/services/normalapp2"]
-
-        t = gl.guess_onboarding_status(changed_paths, apps, parents)
-        assert t == "BestEffort"
-
-    def test_guess_onboarding_status_no_app(self):
-        self.test_data.apps = [self.app1, self.app2, self.app3]
-        parents = gl.get_parents_list()
-        apps = gl.get_app_list()
-        changed_paths = ["data/test/test"]
-
-        t = gl.guess_onboarding_status(changed_paths, apps, parents)
-        assert t is None
-
-    def test_guess_onboarding_status_key_error(self):
-        self.test_data.apps = [self.app1, self.app2, self.app3]
-        parents = gl.get_parents_list()
-        apps = gl.get_app_list()
-        changed_paths = ["data/services/normalapp3"]
-
-        t = gl.guess_onboarding_status(changed_paths, apps, parents)
-        assert t is None

reconcile/test/test_gitlab_members.py

@@ -1,219 +0,0 @@
-from typing import Any
-from unittest.mock import create_autospec
-
-import pytest
-from gitlab.v4.objects import (
-    Group,
-    GroupMember,
-)
-from pytest_mock import MockerFixture
-
-from reconcile import gitlab_members
-from reconcile.gitlab_members import (
-    CurrentState,
-    CurrentStateSpec,
-    DesiredState,
-    DesiredStateSpec,
-    GitlabUser,
-    add_or_update_user,
-    get_permissions,
-)
-from reconcile.gql_definitions.fragments.user import User
-from reconcile.gql_definitions.fragments.vault_secret import VaultSecret
-from reconcile.gql_definitions.gitlab_members.gitlab_instances import GitlabInstanceV1
-from reconcile.gql_definitions.gitlab_members.permissions import (
-    PermissionGitlabGroupMembershipV1,
-)
-from reconcile.test.fixtures import Fixtures
-from reconcile.utils.gitlab_api import GitLabApi
-from reconcile.utils.pagerduty_api import PagerDutyMap
-
-
-@pytest.fixture()
-def instance(vault_secret: VaultSecret) -> GitlabInstanceV1:
-    return GitlabInstanceV1(
-        name="gitlab",
-        description="gitlab",
-        url="http://foobar.com",
-        token=vault_secret,
-        sslVerify=False,
-        managedGroups=["group1", "group2"],
-    )
-
-
-@pytest.fixture()
-def gitlab_groups_map() -> dict[str, Group]:
-    group1 = create_autospec(Group, name="group1", id="123")
-    group1.name = "group1"
-    group2 = create_autospec(Group, name="group2", id="124")
-    group2.name = "group2"
-    return {
-        "group1": group1,
-        "group2": group2,
-    }
-
-
-@pytest.fixture()
-def all_users() -> list[GroupMember]:
-    user1 = create_autospec(GroupMember, username="user1", id="123", access_level=30)
-    user2 = create_autospec(GroupMember, username="user2", id="124", access_level=40)
-    user3 = create_autospec(GroupMember, username="user3", id="125", access_level=30)
-    user4 = create_autospec(GroupMember, username="user4", id="126", access_level=40)
-    return [user1, user2, user3, user4]
-
-
-@pytest.fixture()
-def current_state(all_users: list[GroupMember]) -> CurrentState:
-    return {
-        "group1": CurrentStateSpec(
-            members={
-                "user1": all_users[0],
-                "user2": all_users[1],
-            },
-        ),
-        "group2": CurrentStateSpec(
-            members={
-                "user3": all_users[2],
-                "user4": all_users[3],
-            },
-        ),
-    }
-
-
-@pytest.fixture
-def permissions() -> list[PermissionGitlabGroupMembershipV1]:
-    def q(*args: Any, **kwargs: Any) -> dict[Any, Any]:
-        return fxt.get_anymarkup("permissions.yml")
-
-    fxt = Fixtures("gitlab_members")
-    return get_permissions(q)
-
-
-@pytest.fixture
-def user() -> User:
-    return User(
-        org_username="org_username",
-        slack_username="slack_username",
-        github_username="github_username",
-        name="name",
-        pagerduty_username="pagerduty_username",
-        tag_on_merge_requests=None,
-    )
-
-
-def test_gitlab_members_get_current_state(
-    mocker: MockerFixture,
-    instance: GitlabInstanceV1,
-    current_state: CurrentState,
-    gitlab_groups_map: dict[str, Group],
-    all_users: list[GroupMember],
-) -> None:
-    gl_mock = mocker.create_autospec(GitLabApi)
-    gl_mock.get_group_members.side_effect = [
-        [
-            all_users[0],
-            all_users[1],
-        ],
-        [
-            all_users[2],
-            all_users[3],
-        ],
-    ]
-    assert (
-        gitlab_members.get_current_state(instance, gl_mock, gitlab_groups_map)
-        == current_state
-    )
-
-
-def test_gitlab_members_get_desired_state(
-    mocker: MockerFixture,
-    instance: GitlabInstanceV1,
-    permissions: list[PermissionGitlabGroupMembershipV1],
-    user: User,
-) -> None:
-    mock_pagerduty_map = mocker.create_autospec(PagerDutyMap)
-    mock_pagerduty_map.get.return_value.get_pagerduty_users.return_value = [
-        "pagerduty+foobar",
-        "nobody",
-        "nobody+foobar",
-    ]
-    assert gitlab_members.get_desired_state(
-        instance, mock_pagerduty_map, permissions, [user]
-    ) == {
-        "group1": DesiredStateSpec(
-            members={"devtools-bot": GitlabUser(user="devtools-bot", access_level=50)},
-        ),
-        "group2": DesiredStateSpec(
-            members={
-                "devtools-bot": GitlabUser(user="devtools-bot", access_level=50),
-                "user1": GitlabUser(user="user1", access_level=50),
-                "user2": GitlabUser(user="user2", access_level=50),
-                "user3": GitlabUser(user="user3", access_level=50),
-                "user4": GitlabUser(user="user4", access_level=50),
-                "another-bot": GitlabUser(user="another-bot", access_level=50),
-            },
-        ),
-    }
-
-
-def test_gitlab_members_reconcile_gitlab_members(
-    gitlab_groups_map: dict[str, Group],
-    mocker: MockerFixture,
-    all_users: list[GroupMember],
-) -> None:
-    gl_mock = mocker.create_autospec(GitLabApi)
-    current_state: CurrentState = {
-        "group1": CurrentStateSpec(
-            members={
-                "user1": all_users[0],
-                "user3": all_users[2],
-                "user4": all_users[3],
-            },
-        )
-    }
-    new_user = GitlabUser(user="new_user", access_level=40)
-    desired_state: DesiredState = {
-        "group1": DesiredStateSpec(
-            members={
-                "user1": GitlabUser(user="user1", access_level=30),
-                "new_user": new_user,
-                "user3": GitlabUser(user="user3", access_level=50),
-            }
-        )
-    }
-    group = gitlab_groups_map.get("group1")
-    gitlab_members.reconcile_gitlab_members(
-        current_state_spec=current_state.get("group1"),
-        desired_state_spec=desired_state.get("group1"),
-        group=group,
-        dry_run=False,
-        gl=gl_mock,
-    )
-    gl_mock.add_group_member.assert_called_once_with(group, new_user)
-    gl_mock.change_access.assert_called_once_with(all_users[2], 50)
-    gl_mock.remove_group_member.assert_called_once_with(group, all_users[3].id)
-
-
-def test_add_or_update_user_add():
-    desired_state_spec: DesiredStateSpec = DesiredStateSpec(members={})
-    gu = GitlabUser(user="u", access_level=50, id="1234")
-    add_or_update_user(desired_state_spec, gu)
-    assert desired_state_spec == DesiredStateSpec(members={"u": gu})
-
-
-def test_add_or_update_user_update_higher():
-    desired_state_spec: DesiredStateSpec = DesiredStateSpec(members={})
-    gu1 = GitlabUser(user="u", access_level=40)
-    gu2 = GitlabUser(user="u", access_level=50)
-    add_or_update_user(desired_state_spec, gu1)
-    add_or_update_user(desired_state_spec, gu2)
-    assert desired_state_spec == DesiredStateSpec(members={"u": gu2})
-
-
-def test_add_or_update_user_update_lower():
-    desired_state_spec: DesiredStateSpec = DesiredStateSpec(members={})
-    gu1 = GitlabUser(user="u", access_level=50)
-    gu2 = GitlabUser(user="u", access_level=40)
-    add_or_update_user(desired_state_spec, gu1)
-    add_or_update_user(desired_state_spec, gu2)
-    assert desired_state_spec == DesiredStateSpec(members={"u": gu1})