qontract-reconcile 0.9.1rc298__py3-none-any.whl → 0.10.1.dev1203__py3-none-any.whl

reconcile/utils/sentry_client.py

@@ -1,383 +0,0 @@
-import json
-from functools import lru_cache
-
-import parse
-import requests
-from sretoolbox.utils import retry
-
-
-class SentryClient:  # pylint: disable=too-many-public-methods
-    ORGANIZATION = "sentry"
-
-    def __init__(self, host, token):
-        self.host = host
-        self.auth_token = token
-        self.get_organizations = lru_cache()(self._get_organizations)
-        self.get_projects = lru_cache()(self._get_projects)
-        self.get_users = lru_cache()(self._get_users)
-
-    @retry()
-    def _do_sentry_api_call(self, method, path, slugs, payload=None):
-        url = f"{self.host}/api/0/{path}/"
-
-        if len(slugs) > 0:
-            url = f"{url}{'/'.join(slugs)}/"
-
-        headers = {"Authorization": "Bearer " + self.auth_token}
-        call = getattr(requests, method, None)
-        if call is None:
-            raise ValueError(f"invalid http method {method}")
-
-        response = call(url, headers=headers, json=payload)
-        response.raise_for_status()
-
-        try:
-            all_results = response.json()
-        except json.decoder.JSONDecodeError:
-            return
-
-        # there may be more pages if the response contains a link header
-        # link is a string of comma separated items
-        # with the following structure:
-        # <URL>; rel="previous/next"; results="false/true"; cursor="value"
-        item_format = '<{}>; rel="{}"; results="{}"; cursor="{}"'
-        while True:
-            link = response.headers.get("link")
-            if not link:
-                break
-            # 2nd item is the next page
-            next_item = link.split(", ")[1]
-            # copied with love from
-            # https://stackoverflow.com/questions/10663093/
-            # use-python-format-string-in-reverse-for-parsing
-            _, rel, results, cursor = parse.parse(item_format, next_item)
-            if rel != "next" or results != "true":
-                break
-            response = call(f"{url}?&cursor={cursor}", headers=headers, json=payload)
-            response.raise_for_status()
-            # if there are pages, each response is a list to extend
-            all_results += response.json()
-
-        return all_results
-
-    # Organization functions
-    def _get_organizations(self):
-        response = self._do_sentry_api_call("get", "organizations", [])
-        return response
-
-    def get_organization(self, slug):
-        response = self._do_sentry_api_call("get", "organizations", [slug])
-        return response
-
-    # Project functions
-    def _get_projects(self):
-        response = self._do_sentry_api_call("get", "projects", [])
-        return response
-
-    def get_project(self, slug):
-        response = self._do_sentry_api_call(
-            "get", "projects", [self.ORGANIZATION, slug]
-        )
-        return response
-
-    def create_project(self, team_slug, name, slug=None):
-        params = {"name": name}
-        if slug is not None:
-            params["slug"] = slug
-        response = self._do_sentry_api_call(
-            "post", "teams", [self.ORGANIZATION, team_slug, "projects"], payload=params
-        )
-        return response
-
-    def delete_project(self, slug):
-        response = self._do_sentry_api_call(
-            "delete", "projects", [self.ORGANIZATION, slug]
-        )
-        return response
-
-    def get_project_key(self, slug):
-        response = self._do_sentry_api_call(
-            "get", "projects", [self.ORGANIZATION, slug, "keys"]
-        )
-        keys = {
-            "dsn": response[0]["dsn"]["public"],
-            "deprecated": response[0]["dsn"]["secret"],
-        }
-        return keys
-
-    def update_project(self, slug, options):
-        params = {}
-        required_fields = self.required_project_fields()
-        for k, v in required_fields.items():
-            if v in options:
-                params[k] = options[v]
-
-        self.validate_project_options(options)
-        optional_fields = self.optional_project_fields()
-        for k, v in optional_fields.items():
-            if v in options:
-                params[k] = options[v]
-
-        response = self._do_sentry_api_call(
-            "put", "projects", [self.ORGANIZATION, slug], payload=params
-        )
-        return response
-
-    @staticmethod
-    def required_project_fields():
-        required_fields = {"platform": "platform", "subjectPrefix": "email_prefix"}
-        return required_fields
-
-    @staticmethod
-    def optional_project_fields():
-        optional_fields = {
-            "sensitiveFields": "sensitive_fields",
-            "safeFields": "safe_fields",
-            "resolveAge": "auto_resolve_age",
-            "allowedDomains": "allowed_domains",
-        }
-        return optional_fields
-
-    def validate_project_options(self, options):
-        # If the resolve age is not one of these then sentry will set to 0.
-        # These are the values selectable in the sentry UI in number of hours
-        valid_resolve_age = [
-            1,
-            2,
-            3,
-            4,
-            5,
-            6,
-            7,
-            8,
-            9,
-            10,
-            11,
-            12,
-            15,
-            18,
-            21,
-            24,
-            30,
-            36,
-            48,
-            72,
-            96,
-            120,
-            144,
-            168,
-            192,
-            216,
-            240,
-            288,
-            312,
-            336,
-            360,
-            384,
-            408,
-            432,
-            456,
-            480,
-            504,
-            528,
-            552,
-            576,
-            600,
-            624,
-            648,
-            672,
-            696,
-            720,
-        ]
-
-        optional_fields = self.optional_project_fields()
-        resolve_age_field = optional_fields["resolveAge"]
-        if (
-            resolve_age_field in options
-            and options[resolve_age_field] not in valid_resolve_age
-        ):
-            # If an option is set and invalid, raise exception rather than
-            # potentially destroying setting by trying to set invalid value
-            raise ValueError(
-                f"invalid {resolve_age_field} {options[resolve_age_field]}"
-            )
-
-    def get_project_alert_rules(self, slug):
-        response = self._do_sentry_api_call(
-            "get", "projects", [self.ORGANIZATION, slug, "rules"]
-        )
-        return response
-
-    def delete_project_alert_rule(self, slug, rule):
-        response = self._do_sentry_api_call(
-            "delete", "projects", [self.ORGANIZATION, slug, "rules", rule["id"]]
-        )
-        return response
-
-    def get_project_owners(self, slug):
-        teams = self._do_sentry_api_call(
-            "get", "projects", [self.ORGANIZATION, slug, "teams"]
-        )
-        return teams
-
-    def add_project_owner(self, project_slug, team_slug):
-        response = self._update_project_owner_("post", project_slug, team_slug)
-        return response
-
-    def delete_project_owner(self, project_slug, team_slug):
-        response = self._update_project_owner_("delete", project_slug, team_slug)
-        return response
-
-    def _update_project_owner_(self, method, pslug, tslug):
-        params = {
-            "organization_slug": self.ORGANIZATION,
-            "project_slug": pslug,
-            "team_slug": tslug,
-        }
-
-        response = self._do_sentry_api_call(
-            method,
-            "projects",
-            [self.ORGANIZATION, pslug, "teams", tslug],
-            payload=params,
-        )
-        return response
-
-    # Team functions
-    def get_teams(self):
-        response = self._do_sentry_api_call(
-            "get", "organizations", [self.ORGANIZATION, "teams"]
-        )
-        return response
-
-    def get_team_members(self, team_slug):
-        response = self._do_sentry_api_call(
-            "get", "teams", [self.ORGANIZATION, team_slug, "members"]
-        )
-        return response
-
-    def create_team(self, slug):
-        params = {"slug": slug}
-        response = self._do_sentry_api_call(
-            "post", "organizations", [self.ORGANIZATION, "teams"], payload=params
-        )
-        return response
-
-    def delete_team(self, slug):
-        response = self._do_sentry_api_call(
-            "delete", "teams", [self.ORGANIZATION, slug]
-        )
-        return response
-
-    def get_team_projects(self, slug):
-        response = self._do_sentry_api_call(
-            "get", "teams", [self.ORGANIZATION, slug, "projects"]
-        )
-        return response
-
-    # User/Member functions
-    def _get_users(self):
-        response = self._do_sentry_api_call(
-            "get", "organizations", [self.ORGANIZATION, "members"]
-        )
-        return response
-
-    def get_user(self, email):
-        users = self.get_users()
-        user_list = []
-        for u in users:
-            if u["email"] == email:
-                user_list.append(u)
-
-        response = []
-        for user in user_list:
-            resp = self._do_sentry_api_call(
-                "get", "organizations", [self.ORGANIZATION, "members", user["id"]]
-            )
-            if resp is not None:
-                response.append(resp)
-        return response
-
-    def create_user(self, email, role, teams=None):
-        if teams is None:
-            teams = []
-        params = {"email": email, "role": role, "teams": teams}
-        response = self._do_sentry_api_call(
-            "post", "organizations", [self.ORGANIZATION, "members"], payload=params
-        )
-        return response
-
-    def delete_user(self, email):
-        user_list = self.get_user(email)
-        resp = []
-        for user in user_list:
-            response = self._do_sentry_api_call(
-                "delete", "organizations", [self.ORGANIZATION, "members", user["id"]]
-            )
-            if response is not None and len(response) > 0:
-                resp.append(response)
-        return resp
-
-    def delete_user_by_id(self, id):
-        response = self._do_sentry_api_call(
-            "delete", "organizations", [self.ORGANIZATION, "members", id]
-        )
-        return response
-
-    def set_user_teams(self, email, teams):
-        user_list = self.get_user(email)
-        if len(user_list) > 1:
-            raise ValueError(
-                "set_user_teams will only work for 1 user per "
-                f"e-mail. E-mail {email} has {len(user_list)} "
-                "accounts"
-            )
-        user = user_list[0]
-        params = {"teams": teams}
-        response = self._do_sentry_api_call(
-            "put",
-            "organizations",
-            [self.ORGANIZATION, "members", user["id"]],
-            payload=params,
-        )
-        return response
-
-    def remove_user_from_teams(self, email, teams):
-        user_list = self.get_user(email)
-        if len(user_list) > 1:
-            raise ValueError(
-                "remove_user_from_teams will only work for 1 "
-                f"user per e-mail. E-mail {email} has "
-                f"{len(user_list)} accounts"
-            )
-        user = user_list[0]
-        user_teams = user["teams"]
-        for t in teams:
-            if t in user_teams:
-                user_teams.remove(t)
-        params = {"teams": user_teams}
-        response = self._do_sentry_api_call(
-            "put",
-            "organizations",
-            [self.ORGANIZATION, "members", user["id"]],
-            payload=params,
-        )
-        return response
-
-    def change_user_role(self, email, role):
-        user_list = self.get_user(email)
-        if len(user_list) > 1:
-            raise ValueError(
-                "change_user_role will only work for 1 user per "
-                f"e-mail. E-mail {email} has {len(user_list)} "
-                "accounts"
-            )
-        user = user_list[0]
-        params = {"role": role}
-        response = self._do_sentry_api_call(
-            "put",
-            "organizations",
-            [self.ORGANIZATION, "members", user["id"]],
-            payload=params,
-        )
-        return response

release/test_version.py

@@ -1,50 +0,0 @@
-import packaging.version as pep440
-
-from reconcile.utils.semver_helper import parse_semver
-from release import version
-
-
-def test_version_semver():
-    assert version.semver("0.4.0") == "0.4.0"
-    assert version.semver("0.4.0-6-gaaaaaaa") == "0.4.1-6+aaaaaaa"
-
-
-def test_semver_ordering():
-    # 6 commits after 0.4.0
-    assert parse_semver("0.4.1-6+aaaaaaa") > parse_semver("0.4.0")
-    # prerelease version are lower than release ones
-    assert parse_semver("0.4.0") > parse_semver("0.4.0-6+aaaaaaa")
-    # build info (after '+') don't count in semver comparisons
-    assert parse_semver("0.4.0-6+bbbbbbb") == parse_semver("0.4.0-6+aaaaaa")
-    # 7 commits after 0.4.0 is a higher version than 6 commits after 0.4.0
-    assert parse_semver("0.4.1-7+aaaaaaa") > parse_semver("0.4.1-6+aaaaaaa")
-    # number of commits (prerelease) is treated as a number, not as a string: 50 > 6
-    assert parse_semver("0.4.1-50+aaaaaaa") > parse_semver("0.4.1-6+aaaaaaa")
-
-
-def test_version_pip():
-    assert version.pip("0.4.0") == "0.4.0"
-    assert version.pip("0.4.0-6-gaaaaaaa") == "0.4.1.pre6"
-    # assert version.pip("0.4.0-6-gaaaaaaa") == "0.4.0.post6"
-
-
-def test_pep440_ordering():
-    assert pep440.Version("0.4.1") > pep440.Version("0.4.0")
-
-    # using pre-releases
-    assert pep440.Version("0.4.1.pre6") > pep440.Version("0.4.0")
-    assert pep440.Version("0.4.1.pre6") < pep440.Version("0.4.1")
-    assert pep440.Version("0.4.1.pre6") > pep440.Version("0.4.1.pre5")
-    assert pep440.Version("0.4.1.pre50") > pep440.Version("0.4.1.pre6")
-
-    # using post-releases
-    assert pep440.Version("0.4.0.post6") > pep440.Version("0.4.0")
-    assert pep440.Version("0.4.0.post6") < pep440.Version("0.4.1")
-    assert pep440.Version("0.4.0.post6") > pep440.Version("0.4.0.post5")
-    assert pep440.Version("0.4.0.post50") > pep440.Version("0.4.0.post6")
-
-
-def test_version_docker():
-    assert version.docker("0.4.0") == "0.4.0"
-    assert version.docker("0.4.0-6-gaaaaaaa") == "0.4.1.pre6"
-    # assert version.docker("0.4.0-6-gaaaaaaa") == "0.4.0.post6"

release/version.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-import re
-import subprocess
-import sys
-from subprocess import PIPE
-from typing import Optional
-
-GIT_VERSION_FILE = "GIT_VERSION"
-
-
-def git() -> str:
-    """get the version from git. Can be
-    - X.Y.Z if a tag is set on the current HEAD
-    - X.Y.Z-<count>-g<commitid> otherwise where
-        - X.Y.Z is the latest version tag found
-        - <count> is the number of commits since then
-        - <commitid> is the current HEAD commitid
-    """
-    cmd = "git describe --tags --match=[0-9]*.[0-9]*.[0-9]*"
-    try:
-        p = subprocess.run(cmd.split(" "), stdout=PIPE, stderr=PIPE, check=True)
-        v = p.stdout.decode("utf-8").strip()
-        # tox is running setup.py sdist from the git repo, and then runs again outside
-        # of the git repo. At this second step, we cannot run git commands.
-        # So we save the git version in a file and include it in the source distribution
-        with open(GIT_VERSION_FILE, "w") as f:
-            f.write(v)
-        return v
-    except subprocess.CalledProcessError as e:
-        # if we're not in a git repo, try reading out from the GIT_VERSION file
-        if os.path.exists(GIT_VERSION_FILE):
-            with open(GIT_VERSION_FILE, "r") as f:
-                return f.read()
-        print(e.stderr)
-        raise e
-
-
-def commit(length: int = 7) -> str:
-    """get the current git commitid"""
-    cmd = f"git rev-parse --short={length} HEAD"
-    p = subprocess.run(cmd.split(" "), stdout=PIPE, stderr=PIPE, check=True)
-    return p.stdout.decode("utf-8").strip()
-
-
-def semver(git_version: Optional[str] = None) -> str:
-    """get a semantic version out of the input git version (see git())
-    - if a X.Y.Z tag is set on the current HEAD, we'll use this
-    - else we'll use X.Y.<Z+1>-<count>+<commitid> to respect semver and version
-      ordering. <count> is the prerelease id, <commitid> is a buildinfo
-    """
-    v = git_version or git()
-    m = re.match(r"(\d+)\.(\d+)\.(\d+)-(\d+)-g(.+)", v)
-    if m:
-        major, minor, patch, prerelease, buildinfo = m.groups()
-        # semver prerelase are supposed to show build increments *prior* to a release.
-        # So we're bumping the patch number to show what the next release would be.
-        # this allows correct version ordering
-        patch = str(int(patch) + 1)
-        # X.Y.Z-<count>-g<commitid> is not a valid as <count>-g<commitid> would be
-        # compared as a string, leading to (count=50) < (count=6)
-        # X.Y.Z-<count>+<commitid> is valid .
-        #   <count> is then the prerelease field, treated as a numeric.
-        #   <commitid> is then a buildinfo string, not used in version comparisons
-        v = f"{major}.{minor}.{patch}-{prerelease}+{buildinfo}"
-    return str(v)
-
-
-def pip(git_version: Optional[str] = None) -> str:
-    """get a pip version out of the input git version (see git()),
-    according to https://peps.python.org/pep-0440/
-    - if a X.Y.Z tag is set on the current HEAD, we'll use this
-    - else we'll use X.Y.(Z+1).pre<count>+<commitid> to respect PEP-0440 versioning
-    """
-    return semver(git_version).replace("-", ".pre").split("+", maxsplit=1)[0]
-    # Alternatively, use postreleases
-    # v = git_version or git()
-    # m = re.match(r"(\d+)\.(\d+)\.(\d+)-(\d+)-g(.+)", v)
-    # if m:
-    #     major, minor, patch, count, commitid = m.groups()
-    #     v = f"{major}.{minor}.{patch}.post{count}+{commitid}"
-    # return str(v)
-
-
-def docker(git_version: Optional[str] = None) -> str:
-    # docker tags don't like '+' characters, let's remove the buildinfo/commitid
-    return pip(git_version)
-
-
-if __name__ == "__main__":
-    type_param = sys.argv[1] if len(sys.argv) > 1 else "--git"
-    v = {
-        "--git": git(),
-        "--commit": commit(),
-        "--semver": semver(),
-        "--pip": pip(),
-        "--docker": docker(),
-    }[type_param]
-    print(v)

tools/test/test_qontract_cli.py

@@ -1,60 +0,0 @@
-import pytest
-from click.testing import CliRunner
-
-from tools import qontract_cli
-
-
-@pytest.fixture
-def env_vars(monkeypatch):
-    monkeypatch.setenv("APP_INTERFACE_STATE_BUCKET", "some-bucket")
-    monkeypatch.setenv("APP_INTERFACE_STATE_BUCKET_ACCOUNT", "some-account")
-
-
-@pytest.fixture
-def mock_queries(mocker):
-    mocker.patch("tools.qontract_cli.queries", autospec=True)
-
-
-@pytest.fixture
-def mock_state(mocker):
-    return mocker.patch("tools.qontract_cli.init_state", autospec=True)
-
-
-def test_state_ls_with_integration(env_vars, mock_queries, mock_state):
-    runner = CliRunner()
-
-    mock_state.return_value.ls.return_value = [
-        "/key1",
-        "/nested/key2",
-    ]
-
-    result = runner.invoke(qontract_cli.state, "ls integration")
-    assert result.exit_code == 0
-    assert (
-        result.output
-        == """INTEGRATION    KEY
--------------  -----------
-integration    key1
-integration    nested/key2
-"""
-    )
-
-
-def test_state_ls_without_integration(env_vars, mock_queries, mock_state):
-    runner = CliRunner()
-
-    mock_state.return_value.ls.return_value = [
-        "/integration1/key1",
-        "/integration2/nested/key2",
-    ]
-
-    result = runner.invoke(qontract_cli.state, "ls")
-    assert result.exit_code == 0
-    assert (
-        result.output
-        == """INTEGRATION    KEY
--------------  -----------
-integration1   key1
-integration2   nested/key2
-"""
-    )

tools/test/test_sre_checkpoints.py

@@ -1,79 +0,0 @@
-from unittest.mock import patch
-
-from tools.qontract_cli import sre_checkpoints
-
-# from reconcile import queries
-from tools.sre_checkpoints import (
-    full_name,
-    get_latest_sre_checkpoints,
-)
-
-
-class TestFullName:
-    @staticmethod
-    def test_with_parent():
-        app = {
-            "parentApp": {"name": "app1"},
-            "name": "app2",
-        }
-        assert full_name(app) == "app1/app2"
-
-    @staticmethod
-    def test_without_parent():
-        app = {
-            "name": "app2",
-        }
-        assert full_name(app) == "app2"
-
-
-class TestLatestSRECheckpoints:
-    @staticmethod
-    @patch("reconcile.queries.get_sre_checkpoints")
-    def test_latest(get_sre_checkpoints):
-        get_sre_checkpoints.return_value = [
-            {"date": "2020-01-01", "app": {"name": "app_single"}},
-            {"date": "2021-01-01", "app": {"name": "app_single"}},
-            {"date": "2020-03-01", "app": {"name": "app_single"}},
-            {
-                "date": "2020-01-02",
-                "app": {"parentApp": {"name": "app1"}, "name": "app2"},
-            },
-        ]
-
-        latest_sre_checkpoints = get_latest_sre_checkpoints()
-        assert latest_sre_checkpoints["app_single"] == "2021-01-01"
-        assert latest_sre_checkpoints["app1/app2"] == "2020-01-02"
-
-
-class TestGetSRECheckpoints:
-    @staticmethod
-    @patch("tools.qontract_cli.print_output")
-    @patch("reconcile.queries.get_sre_checkpoints")
-    @patch("reconcile.queries.get_apps")
-    def test_sre_checkpoints(get_apps, get_sre_checkpoints, print_output):
-        get_apps.return_value = [
-            {"name": "app1", "path": "/app1", "onboardingStatus": "OnBoarded"},
-            {"name": "app2", "path": "/app2", "onboardingStatus": "OnBoarded"},
-            {"name": "app3", "path": "/app3", "onboardingStatus": "OnBoarded"},
-            {"name": "app4", "path": "/app4", "onboardingStatus": "InProgress"},
-        ]
-
-        get_sre_checkpoints.return_value = [
-            {"app": {"name": "app1"}, "date": "2021-01-02"},
-            {"app": {"name": "app1"}, "date": "2021-01-01"},
-        ]
-
-        expected_data = [
-            {"name": "app1", "latest": "2021-01-02"},
-            {"name": "app2", "latest": ""},
-            {"name": "app3", "latest": ""},
-        ]
-
-        with sre_checkpoints.make_context(info_name="info", args=[]) as ctx:
-            ctx.obj = {"options": {"output": "json"}}
-            sre_checkpoints.invoke(ctx)
-
-            cols = ["name", "latest"]
-            print_output.assert_called_once_with(
-                {"output": "json"}, expected_data, cols
-            )