kubernetes.core/tests/unit/module_utils/test_discoverer.py

# Copyright [2017] [Red Hat, Inc.]
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


import pytest

from kubernetes.client import ApiClient
from kubernetes.dynamic import Resource

from ansible_collections.kubernetes.core.plugins.module_utils.k8sdynamicclient import (
    K8SDynamicClient,
)
from ansible_collections.kubernetes.core.plugins.module_utils.client.discovery import (
    LazyDiscoverer,
)
from ansible_collections.kubernetes.core.plugins.module_utils.client.resource import (
    ResourceList,
)


@pytest.fixture(scope="module")
def mock_namespace():
    return Resource(
        api_version="v1",
        kind="Namespace",
        name="namespaces",
        namespaced=False,
        preferred=True,
        prefix="api",
        shorter_names=["ns"],
        shortNames=["ns"],
        singularName="namespace",
        verbs=["create", "delete", "get", "list", "patch", "update", "watch"],
    )


@pytest.fixture(scope="module")
def mock_templates():
    return Resource(
        api_version="v1",
        kind="Template",
        name="templates",
        namespaced=True,
        preferred=True,
        prefix="api",
        shorter_names=[],
        shortNames=[],
        verbs=["create", "delete", "get", "list", "patch", "update", "watch"],
    )


@pytest.fixture(scope="module")
def mock_processedtemplates():
    return Resource(
        api_version="v1",
        kind="Template",
        name="processedtemplates",
        namespaced=True,
        preferred=True,
        prefix="api",
        shorter_names=[],
        shortNames=[],
        verbs=["create", "delete", "get", "list", "patch", "update", "watch"],
    )


@pytest.fixture(scope="module")
def mock_namespace_list(mock_namespace):
    ret = ResourceList(
        mock_namespace.client,
        mock_namespace.group,
        mock_namespace.api_version,
        mock_namespace.kind,
    )
    ret._ResourceList__base_resource = mock_namespace
    return ret


@pytest.fixture(scope="function", autouse=True)
def setup_client_monkeypatch(
    monkeypatch,
    mock_namespace,
    mock_namespace_list,
    mock_templates,
    mock_processedtemplates,
):
    def mock_load_server_info(self):
        self.__version = {"kubernetes": "mock-k8s-version"}

    def mock_parse_api_groups(self, request_resources=False):
        return {
            "api": {
                "": {
                    "v1": {
                        "Namespace": [mock_namespace],
                        "NamespaceList": [mock_namespace_list],
                        "Template": [mock_templates, mock_processedtemplates],
                    }
                }
            }
        }

    monkeypatch.setattr(LazyDiscoverer, "_load_server_info", mock_load_server_info)
    monkeypatch.setattr(LazyDiscoverer, "parse_api_groups", mock_parse_api_groups)


@pytest.fixture
def client(request):
    return K8SDynamicClient(ApiClient(), discoverer=LazyDiscoverer)


@pytest.mark.parametrize(
    ("attribute", "value"),
    [("name", "namespaces"), ("singular_name", "namespace"), ("short_names", ["ns"])],
)
def test_search_returns_single_and_list(
    client, mock_namespace, mock_namespace_list, attribute, value
):
    resources = client.resources.search(**{"api_version": "v1", attribute: value})

    assert len(resources) == 2
    assert mock_namespace in resources
    assert mock_namespace_list in resources


@pytest.mark.parametrize(
    ("attribute", "value"),
    [
        ("kind", "Namespace"),
        ("name", "namespaces"),
        ("singular_name", "namespace"),
        ("short_names", ["ns"]),
    ],
)
def test_get_returns_only_single(client, mock_namespace, attribute, value):
    resource = client.resources.get(**{"api_version": "v1", attribute: value})

    assert resource == mock_namespace


def test_get_namespace_list_kind(client, mock_namespace_list):
    resource = client.resources.get(api_version="v1", kind="NamespaceList")

    assert resource == mock_namespace_list


def test_search_multiple_resources_for_template(
    client, mock_templates, mock_processedtemplates
):
    resources = client.resources.search(api_version="v1", kind="Template")

    assert len(resources) == 2
    assert mock_templates in resources
    assert mock_processedtemplates in resources