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

reconcile/test/test_unleash.py

@@ -1,138 +0,0 @@
-import json
-import os
-
-import httpretty
-import pytest
-from UnleashClient.features import Feature
-
-import reconcile.utils.unleash
-from reconcile.utils.unleash import (
-    _get_unleash_api_client,
-    _shutdown_client,
-    get_feature_toggle_default,
-    get_feature_toggle_state,
-    get_feature_toggles,
-)
-
-
-@pytest.fixture
-def reset_client():
-    reconcile.utils.unleash.client = None
-
-
-def test__get_unleash_api_client(mocker):
-    a = mocker.patch("UnleashClient.UnleashClient.initialize_client")
-    c = _get_unleash_api_client("https://u/api", "foo")
-
-    assert a.call_count == 1
-    assert reconcile.utils.unleash.client == c
-
-
-def test__get_unleash_api_client_skip_create(mocker):
-    u = mocker.patch("UnleashClient.UnleashClient")
-    reconcile.utils.unleash.client = u
-    a = mocker.patch("UnleashClient.UnleashClient.initialize_client")
-    c = _get_unleash_api_client("https://u/api", "foo")
-
-    assert a.call_count == 0
-    assert reconcile.utils.unleash.client == c == u
-
-
-def test_get_feature_toggle_default():
-    assert get_feature_toggle_default(None, None)
-
-
-def test_get_feature_toggle_state_env_missing():
-    assert get_feature_toggle_state("foo")
-
-
-def test_get_feature_toggle_state(mocker, monkeypatch):
-    def enabled_func(feature, context, fallback_function):
-        return feature == "enabled"
-
-    os.environ["UNLEASH_API_URL"] = "foo"
-    os.environ["UNLEASH_CLIENT_ACCESS_TOKEN"] = "bar"
-
-    defaultfunc = mocker.patch(
-        "reconcile.utils.unleash.get_feature_toggle_default", return_value=True
-    )
-    monkeypatch.setattr(
-        "reconcile.utils.unleash.client",
-        mocker.patch("UnleashClient.UnleashClient", autospec=True),
-    )
-    mocker.patch(
-        "UnleashClient.UnleashClient.is_enabled",
-        side_effect=enabled_func,
-    )
-
-    assert get_feature_toggle_state("enabled")
-    assert get_feature_toggle_state("disabled") is False
-    assert defaultfunc.call_count == 0
-
-
-def test_get_feature_toggles(mocker, monkeypatch):
-    c = mocker.patch("UnleashClient.UnleashClient")
-    c.features = {
-        "foo": Feature("foo", False, []),
-        "bar": Feature("bar", True, []),
-    }
-
-    monkeypatch.setattr("reconcile.utils.unleash.client", c)
-    toggles = get_feature_toggles("api", "token")
-
-    assert toggles["foo"] == "disabled"
-    assert toggles["bar"] == "enabled"
-
-
-def setup_unleash_httpretty(enabled: bool):
-    features = {
-        "version": 2,
-        "features": [
-            {
-                "strategies": [
-                    {
-                        "name": "disableCluster",
-                        "constraints": [],
-                        "parameters": {"cluster_name": "foo"},
-                    }
-                ],
-                "impressionData": False,
-                "enabled": enabled,
-                "name": "test-strategies",
-                "description": "",
-                "project": "default",
-                "stale": False,
-                "type": "release",
-                "variants": [],
-            }
-        ],
-    }
-
-    feature_param = (httpretty.GET, "http://unleash/api/client/features")
-    httpretty.register_uri(*feature_param, body=json.dumps(features), status=200)
-
-    register_param = (httpretty.POST, "http://unleash/api/client/register")
-    httpretty.register_uri(*register_param, status=202)
-
-
-@httpretty.activate(allow_net_connect=False)
-def test_get_feature_toggle_state_with_strategy(reset_client):
-    os.environ["UNLEASH_API_URL"] = "http://unleash/api"
-    os.environ["UNLEASH_CLIENT_ACCESS_TOKEN"] = "bar"
-    setup_unleash_httpretty(True)
-    assert not get_feature_toggle_state(
-        "test-strategies", context={"cluster_name": "foo"}
-    )
-    assert get_feature_toggle_state("test-strategies", context={"cluster_name": "bar"})
-    _shutdown_client()
-
-
-@httpretty.activate(allow_net_connect=False)
-def test_get_feature_toggle_state_disabled_with_strategy(reset_client):
-    os.environ["UNLEASH_API_URL"] = "http://unleash/api"
-    os.environ["UNLEASH_CLIENT_ACCESS_TOKEN"] = "bar"
-    setup_unleash_httpretty(False)
-    assert not get_feature_toggle_state(
-        "test-strategies", context={"cluster_name": "bar"}
-    )
-    _shutdown_client()

reconcile/test/test_utils_aws_api.py

@@ -1,240 +0,0 @@
-import boto3
-import pytest
-from moto import (
-    mock_ec2,
-    mock_iam,
-    mock_route53,
-)
-
-from reconcile.utils.aws_api import (
-    AmiTag,
-    AWSApi,
-)
-
-
-@pytest.fixture
-def accounts():
-    return [
-        {
-            "name": "some-account",
-            "automationToken": {
-                "path": "path",
-            },
-            "resourcesDefaultRegion": "default-region",
-        }
-    ]
-
-
-@pytest.fixture
-def aws_api(accounts, mocker):
-    mock_secret_reader = mocker.patch(
-        "reconcile.utils.aws_api.SecretReader", autospec=True
-    )
-    mock_secret_reader.return_value.read_all.return_value = {
-        "aws_access_key_id": "key_id",
-        "aws_secret_access_key": "access_key",
-        "region": "tf_state_bucket_region",
-    }
-    return AWSApi(1, accounts, init_users=False)
-
-
-@pytest.fixture
-def iam_client():
-    with mock_iam():
-        iam_client = boto3.client("iam")
-        yield iam_client
-
-
-def test_get_user_key_list(aws_api, iam_client):
-    iam_client.create_user(UserName="user")
-    iam_client.create_access_key(UserName="user")
-    key_list = aws_api._get_user_key_list(iam_client, "user")
-    assert key_list != []
-
-
-def test_get_user_key_list_empty(aws_api, iam_client):
-    iam_client.create_user(UserName="user")
-    key_list = aws_api._get_user_key_list(iam_client, "user")
-    assert key_list == []
-
-
-def test_get_user_key_list_missing_user(aws_api, iam_client):
-    iam_client.create_user(UserName="user1")
-    key_list = aws_api._get_user_key_list(iam_client, "user2")
-    assert key_list == []
-
-
-def test_get_user_keys(aws_api, iam_client):
-    iam_client.create_user(UserName="user")
-    iam_client.create_access_key(UserName="user")
-    keys = aws_api.get_user_keys(iam_client, "user")
-    assert keys != []
-
-
-def test_get_user_keys_empty(aws_api, iam_client):
-    iam_client.create_user(UserName="user")
-    keys = aws_api.get_user_keys(iam_client, "user")
-    assert keys == []
-
-
-def test_get_user_key_status(aws_api, iam_client):
-    iam_client.create_user(UserName="user")
-    iam_client.create_access_key(UserName="user")
-    key = aws_api.get_user_keys(iam_client, "user")[0]
-    status = aws_api.get_user_key_status(iam_client, "user", key)
-    assert status == "Active"
-
-
-def test_default_region(aws_api, accounts):
-    for a in accounts:
-        assert aws_api.sessions[a["name"]].region_name == a["resourcesDefaultRegion"]
-
-
-def test_filter_amis_regex(aws_api):
-    regex = "^match.*$"
-    images = [
-        {"Name": "match-regex", "ImageId": "id1", "State": "available", "Tags": []},
-        {"Name": "no-match-regex", "ImageId": "id2", "State": "available", "Tags": []},
-    ]
-    results = aws_api._filter_amis(images, regex)
-    expected = {"image_id": "id1", "tags": []}
-    assert results == [expected]
-
-
-def test_filter_amis_state(aws_api):
-    regex = "^match.*$"
-    images = [
-        {"Name": "match-regex-1", "ImageId": "id1", "State": "available", "Tags": []},
-        {"Name": "match-regex-2", "ImageId": "id2", "State": "pending", "Tags": []},
-    ]
-    results = aws_api._filter_amis(images, regex)
-    expected = {"image_id": "id1", "tags": []}
-    assert results == [expected]
-
-
-@pytest.fixture
-def route53_client():
-    with mock_route53():
-        route53_client = boto3.client("route53")
-        yield route53_client
-
-
-def test_get_hosted_zone_id(aws_api):
-    zone_id = "THISISTHEZONEID"
-    zone = {"Id": f"/hostedzone/{zone_id}"}
-    result = aws_api._get_hosted_zone_id(zone)
-    assert result == zone_id
-
-
-def test_get_hosted_zone_record_sets_empty(aws_api, route53_client):
-    zone_name = "test.example.com."
-    results = aws_api._get_hosted_zone_record_sets(route53_client, zone_name)
-    assert results == []
-
-
-def test_get_hosted_zone_record_sets_exists(aws_api, route53_client):
-    zone_name = "test.example.com."
-    route53_client.create_hosted_zone(Name=zone_name, CallerReference="test")
-    zones = route53_client.list_hosted_zones_by_name(DNSName=zone_name)["HostedZones"]
-    zone_id = aws_api._get_hosted_zone_id(zones[0])
-    record_set = {"Name": zone_name, "Type": "NS", "ResourceRecords": [{"Value": "ns"}]}
-    change_batch = {"Changes": [{"Action": "CREATE", "ResourceRecordSet": record_set}]}
-    route53_client.change_resource_record_sets(
-        HostedZoneId=zone_id, ChangeBatch=change_batch
-    )
-    results = aws_api._get_hosted_zone_record_sets(route53_client, zone_name)
-    assert results == [record_set]
-
-
-def test_filter_record_sets(aws_api):
-    zone_name = "a"
-    record_type = "NS"
-    expected = {"Name": f"{zone_name}.", "Type": record_type}
-    record_sets = [
-        expected,
-        {"Name": f"{zone_name}.", "Type": "SOA"},
-        {"Name": f"not-{zone_name}.", "Type": record_type},
-    ]
-    results = aws_api._filter_record_sets(record_sets, zone_name, "NS")
-    assert results == [expected]
-
-
-def test_extract_records(aws_api):
-    record = "ns.example.com"
-    resource_records = [
-        {"Value": f"{record}."},
-    ]
-    results = aws_api._extract_records(resource_records)
-    assert results == [record]
-
-
-@pytest.fixture
-def ec2_client():
-    with mock_ec2():
-        yield boto3.client("ec2", region_name="us-east-1")
-
-
-def test_get_image_id(ec2_client, aws_api: AWSApi):
-    # RHEL7 ami from moto/ec2/resources/amis.json
-    reservation = ec2_client.run_instances(
-        ImageId="ami-bb9a6bc2", MinCount=1, MaxCount=1
-    )
-    instance_id = reservation["Instances"][0]["InstanceId"]
-
-    # just another image which shouldn't be returned
-    ec2_client.create_image(InstanceId=instance_id, Name="image-1")
-    # arch=x86_64 image
-    ami_x86_64 = ec2_client.create_image(
-        InstanceId=instance_id,
-        Name="x86_64",
-        TagSpecifications=[
-            {
-                "ResourceType": "image",
-                "Tags": [
-                    {"Key": "foo", "Value": "bar"},
-                    {"Key": "commit", "Value": "sha-123456"},
-                    {"Key": "arch", "Value": "x86_64"},
-                ],
-            },
-        ],
-    )["ImageId"]
-    # arch=aarch64 image
-    ami_aarch64 = ec2_client.create_image(
-        InstanceId=instance_id,
-        Name="aarch64",
-        TagSpecifications=[
-            {
-                "ResourceType": "image",
-                "Tags": [
-                    {"Key": "foo", "Value": "bar"},
-                    {"Key": "commit", "Value": "sha-123456"},
-                    {"Key": "arch", "Value": "aarch64"},
-                ],
-            },
-        ],
-    )["ImageId"]
-
-    # just one tag
-    assert (
-        aws_api.get_image_id(
-            "some-account", "us-east-1", tags=[AmiTag(name="arch", value="x86_64")]
-        )
-        == ami_x86_64
-    )
-    # multiple tags
-    assert (
-        aws_api.get_image_id(
-            "some-account",
-            "us-east-1",
-            tags=[
-                AmiTag(name="commit", value="sha-123456"),
-                AmiTag(name="arch", value="aarch64"),
-            ],
-        )
-        == ami_aarch64
-    )
-    # multiple amis returned ... error
-    with pytest.raises(ValueError):
-        aws_api.get_image_id(
-            "some-account", "us-east-1", tags=[AmiTag(name="foo", value="bar")]
-        )

reconcile/test/test_utils_aws_helper.py

@@ -1,80 +0,0 @@
-import pytest
-
-import reconcile.utils.aws_helper as awsh
-from reconcile.utils.secret_reader import SecretReader
-
-
-def test_get_user_id_from_arn():
-    user_id = "id"
-    arn = f"arn:aws:iam::12345:user/{user_id}"
-    result = awsh.get_user_id_from_arn(arn)
-    assert result == user_id
-
-
-def test_get_account_uid_from_arn():
-    uid = "12345"
-    arn = f"arn:aws:iam::{uid}:role/role-1"
-    result = awsh.get_account_uid_from_arn(arn)
-    assert result == uid
-
-
-def test_get_details_from_role_link():
-    role_link = "https://signin.aws.amazon.com/switchrole?account=12345&roleName=role-1"
-    expected = ("12345", "role-1")
-    result = awsh.get_details_from_role_link(role_link)
-    assert result == expected
-
-
-def test_get_role_arn_from_role_link():
-    role_link = "https://signin.aws.amazon.com/switchrole?account=12345&roleName=role-1"
-    expected = "arn:aws:iam::12345:role/role-1"
-    result = awsh.get_role_arn_from_role_link(role_link)
-    assert result == expected
-
-
-def test_get_account_uid_from_role_link():
-    role_link = "https://signin.aws.amazon.com/switchrole?account=12345&roleName=role-1"
-    expected = "12345"
-    result = awsh.get_account_uid_from_role_link(role_link)
-    assert result == expected
-
-
-def test_get_tf_secrets(mocker):
-    account_name = "a"
-    automation_token = "at"
-    account = {"name": account_name, "automationToken": automation_token}
-    mocker.patch(
-        "reconcile.utils.secret_reader.SecretReader.read_all",
-        return_value=automation_token,
-    )
-    secret_reader = SecretReader()
-    result = awsh.get_tf_secrets(account, secret_reader)
-    assert result == (account_name, automation_token)
-
-
-def test_get_account_found():
-    account_name = "a'"
-    acc_a = {"name": account_name}
-    accounts = [
-        acc_a,
-        {"name": "b"},
-    ]
-    result = awsh.get_account(accounts, account_name)
-    assert result == acc_a
-
-
-def test_get_account_not_found():
-    with pytest.raises(awsh.AccountNotFoundError):
-        awsh.get_account([], "a")
-
-
-@pytest.mark.parametrize(
-    "az,region",
-    [
-        ("us-east-1c", "us-east-1"),
-        ("eu-central-1a", "eu-central-1"),
-        ("us-west-2b", "us-west-2"),
-    ],
-)
-def test_get_region_from_availability_zone(az, region):
-    assert awsh.get_region_from_availability_zone(az) == region

reconcile/test/test_utils_cluster_version_data.py

@@ -1,177 +0,0 @@
-from copy import deepcopy
-from typing import Any
-from unittest.mock import Mock
-
-import pytest
-
-from reconcile.utils import cluster_version_data as cvd
-
-LOW_VERSION = "4.12.1"
-HIGH_VERSION = "4.12.2"
-
-
-@pytest.fixture
-def ocm1_state():
-    return {
-        "check_in": "2021-08-29T18:00:00",
-        "versions": {
-            LOW_VERSION: {
-                "workloads": {
-                    "workload1": {
-                        "soak_days": 21.0,
-                        "reporting": ["cluster1", "cluster2"],
-                    },
-                    "workload2": {"soak_days": 6.0, "reporting": ["cluster3"]},
-                }
-            }
-        },
-        "stats": {
-            "min_version": LOW_VERSION,
-            "min_version_per_workload": {
-                "workload1": LOW_VERSION,
-            },
-        },
-    }
-
-
-@pytest.fixture
-def ocm2_state():
-    return {
-        "check_in": "2021-08-29T18:00:00",
-        "versions": {
-            LOW_VERSION: {
-                "workloads": {
-                    "workload1": {
-                        "soak_days": 3.0,
-                        "reporting": ["cluster4", "cluster5"],
-                    },
-                    "workload3": {"soak_days": 10.0, "reporting": ["cluster6"]},
-                }
-            },
-            HIGH_VERSION: {
-                "workloads": {
-                    "workload1": {
-                        "soak_days": 13.0,
-                        "reporting": ["cluster4", "cluster5"],
-                    },
-                    "workload3": {"soak_days": 20.0, "reporting": ["cluster6"]},
-                }
-            },
-        },
-        "stats": {
-            "min_version": LOW_VERSION,
-            "min_version_per_workload": {
-                "workload1": LOW_VERSION,
-                "workload3": HIGH_VERSION,
-            },
-        },
-    }
-
-
-def get_data(
-    version_data_dict: dict[str, Any], version: str, workload: str
-) -> dict[str, Any]:
-    return version_data_dict["versions"][version]["workloads"][workload]
-
-
-@pytest.fixture
-def state(mocker: Mock, ocm1_state, ocm2_state):
-    s = mocker.patch(
-        "reconcile.utils.cluster_version_data.State", autospec=True
-    ).return_value
-    data = {"ocm1": ocm1_state, "ocm2": ocm2_state}
-    s.get.side_effect = data.get
-    return s
-
-
-def test_version_data_load(state, ocm1_state):
-    version_data = cvd.get_version_data(state, "ocm1")
-    assert version_data.jsondict() == ocm1_state
-
-
-def test_version_data_save(state, ocm1_state):
-    version_data = cvd.get_version_data(state, "ocm1")
-    version_data.save(state, "ocm1")
-    state.add.assert_called_once_with("ocm1", ocm1_state, force=True)
-
-
-def test_version_data_old_style_check_in(state, ocm1_state):
-    # the check_in datetime used to not be using the iso format
-    # let's check we can load the old format and still save the new one..
-    # this test can be removed once deployed in production since the check_in
-    # format will then become the standard ISO
-    new_ocm1_state = deepcopy(ocm1_state)
-    ocm1_state["check_in"] = "2021-08-29 18:00:00"
-    version_data = cvd.get_version_data(state, "ocm1")
-    assert version_data.jsondict() == new_ocm1_state
-    version_data.save(state, "ocm1")
-    state.add.assert_called_once_with("ocm1", new_ocm1_state, force=True)
-
-
-def test_version_data_load_update_save(state, ocm1_state):
-    version_data = cvd.get_version_data(state, "ocm1")
-    new_ocm1_state = deepcopy(ocm1_state)
-    get_data(new_ocm1_state, LOW_VERSION, "workload1")["soak_days"] = 100.0
-    version_data.versions[LOW_VERSION].workloads["workload1"].soak_days = 100.0
-    version_data.save(state, "ocm1")
-    state.add.assert_called_once_with("ocm1", new_ocm1_state, force=True)
-
-
-def test_version_data_workload_history(state, ocm1_state):
-    default_wh = cvd.WorkloadHistory()
-    version_data = cvd.get_version_data(state, "ocm1")
-
-    wh = version_data.workload_history(LOW_VERSION, "workload1")
-    assert wh == get_data(ocm1_state, LOW_VERSION, "workload1")
-
-    wh = version_data.workload_history(LOW_VERSION, "workload1", default_wh)
-    assert wh == get_data(ocm1_state, LOW_VERSION, "workload1")
-
-    wh = version_data.workload_history(LOW_VERSION, "does-not-exist")
-    assert wh == default_wh
-
-    default_wh.soak_days = 5.0
-    wh = version_data.workload_history(LOW_VERSION, "does-not-exist", default_wh)
-    assert wh == default_wh
-    # ensure our new default has been set
-    wh = version_data.workload_history(LOW_VERSION, "does-not-exist")
-    assert wh == default_wh
-
-
-def test_version_data_aggregate(state, ocm1_state, ocm2_state):
-    version_data = cvd.get_version_data(state, "ocm1")
-    version_data_ocm2 = cvd.get_version_data(state, "ocm2")
-    version_data.aggregate(version_data_ocm2, "ocm2")
-
-    assert set(version_data.versions.keys()) == {LOW_VERSION, HIGH_VERSION}
-
-    v1_workloads = version_data.versions[LOW_VERSION].workloads
-    # unkwown workloads are not aggregated
-    assert "workload3" not in v1_workloads
-    # nothing to aggregate
-    assert v1_workloads["workload2"] == get_data(ocm1_state, LOW_VERSION, "workload2")
-    # aggregation of LOW_VERSION/workload1
-    ocm1_v1_w1 = get_data(ocm1_state, LOW_VERSION, "workload1")
-    ocm2_v1_w1 = get_data(ocm2_state, LOW_VERSION, "workload1")
-    assert v1_workloads["workload1"] == {
-        "soak_days": ocm1_v1_w1["soak_days"] + ocm2_v1_w1["soak_days"],
-        "reporting": ocm1_v1_w1["reporting"]
-        + [f"ocm2/{r}" for r in ocm2_v1_w1["reporting"]],
-    }
-
-    v2_workloads = version_data.versions[HIGH_VERSION].workloads
-    aggregated = get_data(ocm2_state, HIGH_VERSION, "workload1")
-    aggregated["reporting"] = [f"ocm2/{r}" for r in aggregated["reporting"]]
-    # new version HIGH_VERSION for workload1 aggregated
-    assert v2_workloads == {"workload1": aggregated}
-
-    assert version_data.stats is not None
-    assert version_data.stats.inherited == version_data_ocm2.stats
-
-
-def test_update_stats():
-    pass
-
-
-def test_validate_against_inherited():
-    pass

reconcile/test/test_utils_data_structures.py

@@ -1,13 +0,0 @@
-from unittest import TestCase
-
-import reconcile.utils.data_structures as ds
-
-
-class TestGetOrInit(TestCase):
-    def test_get_or_init_get(self):
-        d = {"k": "v"}
-        self.assertEqual(ds.get_or_init(d, "k", "notv"), "v")
-
-    def test_get_or_init_init(self):
-        d = {}
-        self.assertEqual(ds.get_or_init(d, "k", "v"), "v")