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

reconcile/test/test_jenkins_worker_fleets.py

@@ -1,57 +0,0 @@
-import logging
-
-import pytest
-from pytest_mock import MockerFixture
-
-from reconcile.jenkins_worker_fleets import (
-    act,
-    get_current_state,
-    get_desired_state,
-)
-from reconcile.test.fixtures import Fixtures
-from reconcile.utils.jenkins_api import JenkinsApi
-from reconcile.utils.terrascript_aws_client import TerrascriptClient as Terrascript
-
-fixture = Fixtures("jenkins_worker_fleets")
-
-
-def test_jenkins_worker_fleets(mocker: MockerFixture, caplog):
-    mock_get = mocker.patch.object(JenkinsApi, "get_jcasc_config")
-    mock_get.return_value = fixture.get_anymarkup("jcasc-export.yml")
-
-    mock_gql = mocker.patch("reconcile.utils.gql.get_api", autospec=True)
-    mock_gql.return_value.get_resource.return_value = fixture.get_anymarkup(
-        "gql-queries.yml"
-    )["gql_resource"]
-
-    mock_apply = mocker.patch.object(JenkinsApi, "apply_jcasc_config")
-
-    instance = fixture.get_anymarkup("gql-queries.yml")["gql_response"]["instances"][0]
-    jenkins = JenkinsApi("url", "user", "password")
-    terrascript = Terrascript(
-        "jenkins-worker-fleets", "", 1, accounts=[], settings=None
-    )
-    current_state = get_current_state(jenkins)
-    workerFleets = instance.get("workerFleets", [])
-    desired_state = get_desired_state(terrascript, workerFleets)
-    with caplog.at_level(logging.INFO):
-        act(False, instance["name"], current_state, desired_state, jenkins)
-    mock_apply.assert_called_with(fixture.get_anymarkup("jcasc-apply.yml"))
-
-    assert sorted([rec.message for rec in caplog.records]) == sorted([
-        "['create_jenkins_worker_fleet', 'ci-int', 'ci-int-jenkins-worker-app-interface']",
-        "['delete_jenkins_worker_fleet', 'ci-int', 'ci-int-jenkins-worker-rhel8']",
-        "['update_jenkins_worker_fleet', 'ci-int', 'ci-int-jenkins-worker-app-sre']",
-        "['update_jenkins_worker_fleet', 'ci-int', 'test-remove-sshConnector-attrs']",
-        "['update_jenkins_worker_fleet', 'ci-int', 'test-add-sshConnector-JVMOpts']",
-    ])
-
-
-def test_jenkins_worker_fleets_error():
-    instance = fixture.get_anymarkup("gql-queries.yml")["gql_response"]["instances"][1]
-    terrascript = Terrascript(
-        "jenkins-worker-fleets", "", 1, accounts=[], settings=None
-    )
-    workerFleets = instance.get("workerFleets", [])
-    with pytest.raises(ValueError):
-        get_desired_state(terrascript, workerFleets)

reconcile/test/test_jira_permissions_validator.py

@@ -1,519 +0,0 @@
-from collections.abc import Callable, Mapping
-from typing import Any
-from unittest.mock import Mock
-
-import pytest
-from jira import JIRAError
-from pytest_mock import MockerFixture
-
-from reconcile.gql_definitions.jira_permissions_validator.jira_boards_for_permissions_validator import (
-    JiraBoardV1,
-)
-from reconcile.jira_permissions_validator import (
-    ValidationError,
-    board_is_valid,
-    get_jira_boards,
-    validate_boards,
-)
-from reconcile.test.fixtures import Fixtures
-from reconcile.utils import metrics
-from reconcile.utils.jira_client import IssueType, JiraClient, SecurityLevel
-
-
-@pytest.fixture
-def fx() -> Fixtures:
-    return Fixtures("jira_permissions_validator")
-
-
-@pytest.fixture
-def raw_fixture_data(fx: Fixtures) -> dict[str, Any]:
-    return fx.get_anymarkup("boards.yml")
-
-
-@pytest.fixture
-def query_func(
-    data_factory: Callable[[type[JiraBoardV1], Mapping[str, Any]], Mapping[str, Any]],
-    raw_fixture_data: dict[str, Any],
-) -> Callable:
-    return lambda *args, **kwargs: {
-        "jira_boards": [
-            data_factory(JiraBoardV1, item) for item in raw_fixture_data["jira_boards"]
-        ]
-    }
-
-
-@pytest.fixture
-def boards(query_func: Callable) -> list[JiraBoardV1]:
-    return get_jira_boards(query_func)
-
-
-def test_jira_permissions_validator_get_jira_boards(
-    query_func: Callable, gql_class_factory: Callable
-) -> None:
-    default = {
-        "name": "jira-board-default",
-        "server": {
-            "serverUrl": "https://jira-server.com",
-            "token": {"path": "vault/path/token", "field": "token"},
-        },
-        "issueResolveState": "Closed",
-        "severityPriorityMappings": {
-            "name": "major-major",
-            "mappings": [
-                {"priority": "Minor"},
-                {"priority": "Major"},
-                {"priority": "Critical"},
-            ],
-        },
-    }
-    custom = {
-        "name": "jira-board-custom",
-        "server": {
-            "serverUrl": "https://jira-server.com",
-            "token": {"path": "vault/path/token", "field": "token"},
-        },
-        "issueType": "bug",
-        "issueResolveState": "Closed",
-        "issueReopenState": "Open",
-        "issueSecurityId": 32168,
-        "severityPriorityMappings": {
-            "name": "major-major",
-            "mappings": [
-                {"priority": "Minor"},
-                {"priority": "Major"},
-                {"priority": "Major"},
-                {"priority": "Critical"},
-            ],
-        },
-    }
-    assert get_jira_boards(query_func) == [
-        gql_class_factory(JiraBoardV1, default),
-        gql_class_factory(JiraBoardV1, custom),
-    ]
-
-
-@pytest.mark.parametrize(
-    "board_is_valid, dry_run, error_returned, metric_set",
-    [
-        (0, True, False, False),
-        (ValidationError.CANT_CREATE_ISSUE, True, True, False),
-        (ValidationError.CANT_TRANSITION_ISSUES, True, True, False),
-        (ValidationError.INVALID_ISSUE_TYPE, True, True, False),
-        (ValidationError.INVALID_ISSUE_STATE, True, True, False),
-        (ValidationError.INVALID_SECURITY_LEVEL, True, True, False),
-        (ValidationError.INVALID_PRIORITY, True, True, False),
-        (ValidationError.PUBLIC_PROJECT_NO_SECURITY_LEVEL, True, True, False),
-        (ValidationError.PERMISSION_ERROR, True, True, True),
-        (ValidationError.PROJECT_ARCHIVED, True, True, False),
-        # no dry-run
-        (ValidationError.CANT_CREATE_ISSUE, False, False, False),
-        (ValidationError.PERMISSION_ERROR, False, False, True),
-        (ValidationError.PROJECT_ARCHIVED, False, False, False),
-        # test with another error
-        (
-            ValidationError.INVALID_PRIORITY | ValidationError.PERMISSION_ERROR,
-            True,
-            True,
-            False,
-        ),
-        (
-            ValidationError.INVALID_PRIORITY | ValidationError.PERMISSION_ERROR,
-            False,
-            True,
-            False,
-        ),
-    ],
-)
-def test_jira_permissions_validator_validate_boards(
-    mocker: MockerFixture,
-    boards: list[JiraBoardV1],
-    secret_reader: Mock,
-    board_is_valid: ValidationError,
-    dry_run: bool,
-    error_returned: bool,
-    metric_set: bool,
-) -> None:
-    board_is_valid_mock = mocker.patch(
-        "reconcile.jira_permissions_validator.board_is_valid"
-    )
-    board_is_valid_mock.return_value = board_is_valid
-    metrics_container_mock = mocker.create_autospec(spec=metrics.MetricsContainer)
-    jira_client_class = mocker.create_autospec(spec=JiraClient)
-    assert (
-        validate_boards(
-            metrics_container=metrics_container_mock,
-            secret_reader=secret_reader,
-            jira_client_settings=None,
-            jira_boards=boards,
-            default_issue_type="task",
-            default_reopen_state="new",
-            dry_run=dry_run,
-            jira_client_class=jira_client_class,
-        )
-        == error_returned
-    )
-    if metric_set:
-        metrics_container_mock.set_gauge.assert_called()
-    else:
-        metrics_container_mock.set_gauge.assert_not_called()
-
-
-def test_jira_permissions_validator_board_is_valid_happy_path(
-    mocker: MockerFixture, gql_class_factory: Callable
-) -> None:
-    board = gql_class_factory(
-        JiraBoardV1,
-        {
-            "name": "jira-board-default",
-            "server": {
-                "serverUrl": "https://jira-server.com",
-                "token": {"path": "vault/path/token", "field": "token"},
-            },
-            "issueType": "bug",
-            "issueResolveState": "Closed",
-            "issueReopenState": "Open",
-            "issueSecurityId": "32168",
-            "severityPriorityMappings": {
-                "name": "major-major",
-                "mappings": [
-                    {"priority": "Minor"},
-                    {"priority": "Major"},
-                    {"priority": "Critical"},
-                ],
-            },
-        },
-    )
-    jira_client = mocker.create_autospec(spec=JiraClient)
-    jira_client.is_archived = False
-    jira_client.can_create_issues.return_value = True
-    jira_client.can_transition_issues.return_value = True
-    jira_client.project_issue_types.return_value = [
-        IssueType(id="1", name="task", statuses=["open", "closed"]),
-        IssueType(id="2", name="bug", statuses=["open", "closed"]),
-    ]
-    jira_client.security_levels.return_value = [
-        SecurityLevel(id="32168", name="foo"),
-        SecurityLevel(id="1", name="bar"),
-    ]
-    jira_client.project_priority_scheme.return_value = ["1", "2", "3"]
-    assert board_is_valid(
-        jira=jira_client,
-        board=board,
-        default_issue_type="task",
-        default_reopen_state="new",
-        jira_server_priorities={"Minor": "1", "Major": "2", "Critical": "3"},
-        public_projects=[],
-    ) == ValidationError(0)
-
-
-def test_jira_permissions_validator_board_is_valid_all_errors(
-    mocker: MockerFixture, gql_class_factory: Callable
-) -> None:
-    board = gql_class_factory(
-        JiraBoardV1,
-        {
-            "name": "jira-board-default",
-            "server": {
-                "serverUrl": "https://jira-server.com",
-                "token": {"path": "vault/path/token", "field": "token"},
-            },
-            "issueType": "bug",
-            "issueResolveState": "Closed",
-            "issueReopenState": "Open",
-            "issueSecurityId": "32168",
-            "severityPriorityMappings": {
-                "name": "major-major",
-                "mappings": [
-                    {"priority": "Minor"},
-                    {"priority": "Major"},
-                    {"priority": "Critical"},
-                ],
-            },
-        },
-    )
-    jira_client = mocker.create_autospec(spec=JiraClient)
-    jira_client.is_archived = False
-    jira_client.can_create_issues.return_value = False
-    jira_client.can_transition_issues.return_value = False
-    jira_client.project_issue_types.return_value = []
-    jira_client.security_levels.return_value = [
-        SecurityLevel(id="1", name="bar"),
-    ]
-    jira_client.project_priority_scheme.return_value = ["1", "2"]
-    assert (
-        board_is_valid(
-            jira=jira_client,
-            board=board,
-            default_issue_type="task",
-            default_reopen_state="new",
-            jira_server_priorities={"Minor": "1", "Major": "2", "Critical": "3"},
-            public_projects=[],
-        )
-        == ValidationError.CANT_CREATE_ISSUE
-        | ValidationError.CANT_TRANSITION_ISSUES
-        | ValidationError.INVALID_ISSUE_TYPE
-        | ValidationError.INVALID_ISSUE_STATE
-        | ValidationError.INVALID_SECURITY_LEVEL
-        | ValidationError.INVALID_PRIORITY
-    )
-
-
-def test_jira_permissions_validator_board_is_valid_bad_issue_status(
-    mocker: MockerFixture, gql_class_factory: Callable
-) -> None:
-    board = gql_class_factory(
-        JiraBoardV1,
-        {
-            "name": "jira-board-default",
-            "server": {
-                "serverUrl": "https://jira-server.com",
-                "token": {"path": "vault/path/token", "field": "token"},
-            },
-            "issueType": "bug",
-            "issueResolveState": "Closed",
-            "issueReopenState": "Open",
-            "issueSecurityId": "32168",
-            "severityPriorityMappings": {
-                "name": "major-major",
-                "mappings": [
-                    {"priority": "Minor"},
-                    {"priority": "Major"},
-                    {"priority": "Critical"},
-                ],
-            },
-        },
-    )
-    jira_client = mocker.create_autospec(spec=JiraClient)
-    jira_client.is_archived = False
-    jira_client.can_create_issues.return_value = True
-    jira_client.can_transition_issues.return_value = True
-    jira_client.project_issue_types.return_value = [
-        IssueType(id="1", name="task", statuses=["not - open", "closed"]),
-        IssueType(id="2", name="bug", statuses=["not - open", "closed"]),
-    ]
-    jira_client.security_levels.return_value = [
-        SecurityLevel(id="32168", name="foo"),
-        SecurityLevel(id="1", name="bar"),
-    ]
-    jira_client.project_priority_scheme.return_value = ["1", "2", "3"]
-    assert (
-        board_is_valid(
-            jira=jira_client,
-            board=board,
-            default_issue_type="task",
-            default_reopen_state="new",
-            jira_server_priorities={"Minor": "1", "Major": "2", "Critical": "3"},
-            public_projects=[],
-        )
-        == ValidationError.INVALID_ISSUE_STATE
-    )
-
-
-def test_jira_permissions_validator_board_is_valid_public_project(
-    mocker: MockerFixture, gql_class_factory: Callable
-) -> None:
-    board = gql_class_factory(
-        JiraBoardV1,
-        {
-            "name": "jira-board-default",
-            "server": {
-                "serverUrl": "https://jira-server.com",
-                "token": {"path": "vault/path/token", "field": "token"},
-            },
-            "issueType": "bug",
-            "issueResolveState": "Closed",
-            "issueReopenState": "Open",
-            "issueSecurityId": None,
-            "severityPriorityMappings": {
-                "name": "major-major",
-                "mappings": [
-                    {"priority": "Minor"},
-                    {"priority": "Major"},
-                    {"priority": "Critical"},
-                ],
-            },
-        },
-    )
-    jira_client = mocker.create_autospec(spec=JiraClient)
-    jira_client.is_archived = False
-    jira_client.can_create_issues.return_value = True
-    jira_client.can_transition_issues.return_value = True
-    jira_client.project_issue_types.return_value = [
-        IssueType(id="1", name="task", statuses=["open", "closed"]),
-        IssueType(id="2", name="bug", statuses=["open", "closed"]),
-    ]
-    jira_client.security_levels.return_value = [
-        SecurityLevel(id="32168", name="foo"),
-        SecurityLevel(id="1", name="bar"),
-    ]
-    jira_client.project_priority_scheme.return_value = ["1", "2", "3"]
-    assert (
-        board_is_valid(
-            jira=jira_client,
-            board=board,
-            default_issue_type="task",
-            default_reopen_state="new",
-            jira_server_priorities={"Minor": "1", "Major": "2", "Critical": "3"},
-            public_projects=["jira-board-default"],
-        )
-        == ValidationError.PUBLIC_PROJECT_NO_SECURITY_LEVEL
-    )
-
-
-def test_jira_permissions_validator_board_is_valid_permission_error(
-    mocker: MockerFixture, gql_class_factory: Callable
-) -> None:
-    board = gql_class_factory(
-        JiraBoardV1,
-        {
-            "name": "jira-board-default",
-            "server": {
-                "serverUrl": "https://jira-server.com",
-                "token": {"path": "vault/path/token", "field": "token"},
-            },
-            "issueType": "bug",
-            "issueResolveState": "Closed",
-            "issueReopenState": "Open",
-            "issueSecurityId": "32168",
-            "severityPriorityMappings": {
-                "name": "major-major",
-                "mappings": [
-                    {"priority": "Minor"},
-                    {"priority": "Major"},
-                    {"priority": "Critical"},
-                ],
-            },
-        },
-    )
-    jira_client = mocker.create_autospec(spec=JiraClient)
-    jira_client.is_archived = False
-    jira_client.can_create_issues.side_effect = JIRAError(status_code=403)
-    assert (
-        board_is_valid(
-            jira=jira_client,
-            board=board,
-            default_issue_type="task",
-            default_reopen_state="new",
-            jira_server_priorities={"Minor": "1", "Major": "2", "Critical": "3"},
-            public_projects=[],
-        )
-        == ValidationError.PERMISSION_ERROR
-    )
-
-
-def test_jira_permissions_validator_board_is_valid_exception(
-    mocker: MockerFixture, gql_class_factory: Callable
-) -> None:
-    board = gql_class_factory(
-        JiraBoardV1,
-        {
-            "name": "jira-board-default",
-            "server": {
-                "serverUrl": "https://jira-server.com",
-                "token": {"path": "vault/path/token", "field": "token"},
-            },
-            "issueType": "bug",
-            "issueResolveState": "Closed",
-            "issueReopenState": "Open",
-            "issueSecurityId": "32168",
-            "severityPriorityMappings": {
-                "name": "major-major",
-                "mappings": [
-                    {"priority": "Minor"},
-                    {"priority": "Major"},
-                    {"priority": "Critical"},
-                ],
-            },
-        },
-    )
-    jira_client = mocker.create_autospec(spec=JiraClient)
-    jira_client.is_archived = False
-    jira_client.can_create_issues.side_effect = JIRAError(status_code=500)
-    with pytest.raises(JIRAError):
-        board_is_valid(
-            jira=jira_client,
-            board=board,
-            default_issue_type="task",
-            default_reopen_state="new",
-            jira_server_priorities={"Minor": "1", "Major": "2", "Critical": "3"},
-            public_projects=[],
-        )
-
-
-def test_jira_permissions_validator_board_is_valid_exception_401(
-    mocker: MockerFixture, gql_class_factory: Callable
-) -> None:
-    board = gql_class_factory(
-        JiraBoardV1,
-        {
-            "name": "jira-board-default",
-            "server": {
-                "serverUrl": "https://jira-server.com",
-                "token": {"path": "vault/path/token", "field": "token"},
-            },
-            "issueType": "bug",
-            "issueResolveState": "Closed",
-            "issueReopenState": "Open",
-            "issueSecurityId": "32168",
-            "severityPriorityMappings": {
-                "name": "major-major",
-                "mappings": [
-                    {"priority": "Minor"},
-                    {"priority": "Major"},
-                    {"priority": "Critical"},
-                ],
-            },
-        },
-    )
-    jira_client = mocker.create_autospec(spec=JiraClient)
-    jira_client.is_archived = False
-    jira_client.can_create_issues.side_effect = JIRAError(status_code=401)
-    # no error for 401
-    board_is_valid(
-        jira=jira_client,
-        board=board,
-        default_issue_type="task",
-        default_reopen_state="new",
-        jira_server_priorities={"Minor": "1", "Major": "2", "Critical": "3"},
-        public_projects=[],
-    )
-
-
-def test_jira_permissions_validator_board_is_valid_archived(
-    mocker: MockerFixture, gql_class_factory: Callable
-) -> None:
-    board = gql_class_factory(
-        JiraBoardV1,
-        {
-            "name": "jira-board-default",
-            "server": {
-                "serverUrl": "https://jira-server.com",
-                "token": {"path": "vault/path/token", "field": "token"},
-            },
-            "issueType": "bug",
-            "issueResolveState": "Closed",
-            "issueReopenState": "Open",
-            "issueSecurityId": "32168",
-            "severityPriorityMappings": {
-                "name": "major-major",
-                "mappings": [
-                    {"priority": "Minor"},
-                    {"priority": "Major"},
-                    {"priority": "Critical"},
-                ],
-            },
-        },
-    )
-    jira_client = mocker.create_autospec(spec=JiraClient)
-    jira_client.is_archived = True
-    assert (
-        board_is_valid(
-            jira=jira_client,
-            board=board,
-            default_issue_type="task",
-            default_reopen_state="new",
-            jira_server_priorities={"Minor": "1", "Major": "2", "Critical": "3"},
-            public_projects=[],
-        )
-        == ValidationError.PROJECT_ARCHIVED
-    )

reconcile/test/test_jump_host.py

@@ -1,114 +0,0 @@
-import os
-from typing import Any
-from unittest.mock import create_autospec
-
-import pytest
-
-from reconcile.utils import gql
-from reconcile.utils.jump_host import (
-    JumpHostBase,
-    JumphostParameters,
-    JumpHostSSH,
-)
-
-EXPECTED_USER = "test-user"
-EXPECTED_HOSTNAME = "test"
-EXPECTED_KNOWN_HOSTS_PATH = "path/to/known-hosts"
-EXPECTED_KNOWN_HOSTS_CONTENT = "known-hosts-file-content"
-
-
-@pytest.mark.parametrize(
-    "parameters, expected_port",
-    [
-        (
-            # Jumphost with default port
-            JumphostParameters(
-                hostname=EXPECTED_HOSTNAME,
-                key="ABC",
-                known_hosts=EXPECTED_KNOWN_HOSTS_PATH,
-                local_port=None,
-                port=None,
-                remote_port=None,
-                user=EXPECTED_USER,
-            ),
-            22,
-        ),
-        (
-            # Jumphost with non-default port
-            JumphostParameters(
-                hostname=EXPECTED_HOSTNAME,
-                key="ABC",
-                known_hosts=EXPECTED_KNOWN_HOSTS_PATH,
-                local_port=None,
-                port=25,
-                remote_port=None,
-                user=EXPECTED_USER,
-            ),
-            25,
-        ),
-    ],
-)
-def test_base_jumphost(fs: Any, parameters: JumphostParameters, expected_port: int):
-    jumphost = JumpHostBase(parameters=parameters)
-    assert os.path.exists(jumphost._identity_file)
-
-    with open(jumphost._identity_file, encoding="locale") as f:
-        assert f.read() == parameters.key
-
-    assert jumphost._port == expected_port
-    assert jumphost._user == EXPECTED_USER
-    assert jumphost._hostname == EXPECTED_HOSTNAME
-
-
-@pytest.mark.parametrize(
-    "parameters, local_port, remote_port",
-    [
-        (
-            # Jumphost without remote or local port set
-            JumphostParameters(
-                hostname=EXPECTED_HOSTNAME,
-                key="ABC",
-                known_hosts=EXPECTED_KNOWN_HOSTS_PATH,
-                local_port=None,
-                port=None,
-                remote_port=None,
-                user=EXPECTED_USER,
-            ),
-            None,
-            None,
-        ),
-        (
-            # Jumphost with remote and local port
-            JumphostParameters(
-                hostname=EXPECTED_HOSTNAME,
-                key="ABC",
-                known_hosts=EXPECTED_KNOWN_HOSTS_PATH,
-                local_port=25,
-                port=None,
-                remote_port=30,
-                user=EXPECTED_USER,
-            ),
-            25,
-            30,
-        ),
-    ],
-)
-def test_ssh_jumphost(
-    fs: Any,
-    parameters: JumphostParameters,
-    local_port: int | None,
-    remote_port: int | None,
-):
-    gql_mock = create_autospec(spec=gql.GqlApi)
-    gql_mock.get_resource.side_effect = [{"content": EXPECTED_KNOWN_HOSTS_CONTENT}]
-    jumphost = JumpHostSSH(parameters=parameters, gql_api=gql_mock)
-    known_hosts_file = jumphost._identity_dir + "/known_hosts"
-
-    assert os.path.exists(known_hosts_file)
-    assert jumphost._remote_port == remote_port
-    assert isinstance(jumphost._local_port, int)
-    if local_port:
-        assert jumphost._local_port == local_port
-
-    with open(known_hosts_file, encoding="locale") as f:
-        assert f.read() == EXPECTED_KNOWN_HOSTS_CONTENT