ci: merge main branch

Author: rnetser

tests/model_registry/conftest.py

@@ -1,27 +1,40 @@
 import pytest
+import re
 import schemathesis
 from typing import Generator, Any
+from kubernetes.dynamic.exceptions import ResourceNotFoundError
+from ocp_resources.pod import Pod
 from ocp_resources.secret import Secret
 from ocp_resources.namespace import Namespace
 from ocp_resources.service import Service
 from ocp_resources.persistent_volume_claim import PersistentVolumeClaim
+from ocp_resources.data_science_cluster import DataScienceCluster
 from ocp_resources.deployment import Deployment
+
 from ocp_resources.model_registry import ModelRegistry
+from ocp_resources.resource import ResourceEditor
+
+from pytest import FixtureRequest
 from simple_logger.logger import get_logger
 from kubernetes.dynamic import DynamicClient
-
+from pytest_testconfig import config as py_config
+from model_registry.types import RegisteredModel
+from tests.model_registry.constants import (
+    MR_NAMESPACE,
+    MR_OPERATOR_NAME,
+    MR_INSTANCE_NAME,
+    ISTIO_CONFIG_DICT,
+    DB_RESOURCES_NAME,
+    MR_DB_IMAGE_DIGEST,
+)
 from tests.model_registry.utils import get_endpoint_from_mr_service, get_mr_service_by_label
 from utilities.infra import create_ns
-from utilities.constants import Annotations, Protocols
-from .constants import MR_DB_IMAGE_DIGEST
+from utilities.constants import Annotations, Protocols, DscComponents
+from model_registry import ModelRegistry as ModelRegistryClient
 
 
 LOGGER = get_logger(name=__name__)
 
-DB_RESOURCES_NAME: str = "model-registry-db"
-MR_INSTANCE_NAME: str = "model-registry"
-MR_OPERATOR_NAME: str = "model-registry-operator"
-MR_NAMESPACE: str = "rhoai-model-registries"
 DEFAULT_LABEL_DICT_DB: dict[str, str] = {
     Annotations.KubernetesIo.NAME: DB_RESOURCES_NAME,
     Annotations.KubernetesIo.INSTANCE: DB_RESOURCES_NAME,
@@ -30,20 +43,12 @@
 
 
 @pytest.fixture(scope="class")
-def model_registry_namespace(admin_client: DynamicClient) -> Generator[Namespace, Any, Any]:
-    # This namespace should exist after Model Registry is enabled, but it can also be deleted
-    # from the cluster and does not get reconciled. Fetch if it exists, create otherwise.
-    ns = Namespace(name=MR_NAMESPACE, client=admin_client)
-    if ns.exists:
+def model_registry_namespace(request: FixtureRequest, admin_client: DynamicClient) -> Generator[Namespace, Any, Any]:
+    with create_ns(
+        name=request.param.get("namespace_name", MR_NAMESPACE),
+        admin_client=admin_client,
+    ) as ns:
         yield ns
-    else:
-        LOGGER.warning(f"{MR_NAMESPACE} namespace was not present, creating it")
-        with create_ns(
-            name=MR_NAMESPACE,
-            admin_client=admin_client,
-            teardown=False,
-        ) as ns:
-            yield ns
 
 
 @pytest.fixture(scope="class")
@@ -259,10 +264,7 @@ def model_registry_instance(
         },
         grpc={},
         rest={},
-        istio={
-            "authProvider": "redhat-ods-applications-auth-provider",
-            "gateway": {"grpc": {"tls": {}}, "rest": {"tls": {}}},
-        },
+        istio=ISTIO_CONFIG_DICT,
         mysql={
             "host": f"{model_registry_db_deployment.name}.{model_registry_db_deployment.namespace}.svc.cluster.local",
             "database": model_registry_db_secret.string_data["database-name"],
@@ -304,3 +306,70 @@ def generated_schema(model_registry_instance_rest_endpoint: str) -> Any:
         uri="https://raw.githubusercontent.com/kubeflow/model-registry/main/api/openapi/model-registry.yaml",
         base_url=f"https://{model_registry_instance_rest_endpoint}/",
     )
+
+
+@pytest.fixture(scope="class")
+def updated_dsc_component_state_scope_class(
+    request: FixtureRequest,
+    model_registry_namespace: Namespace,
+    dsc_resource: DataScienceCluster,
+) -> Generator[DataScienceCluster, Any, Any]:
+    original_components = dsc_resource.instance.spec.components
+    with ResourceEditor(patches={dsc_resource: {"spec": {"components": request.param["component_patch"]}}}):
+        for component_name in request.param["component_patch"]:
+            dsc_resource.wait_for_condition(condition=DscComponents.COMPONENT_MAPPING[component_name], status="True")
+        yield dsc_resource
+
+    for component_name, value in request.param["component_patch"].items():
+        LOGGER.info(f"Waiting for component {component_name} to be updated.")
+        if original_components[component_name]["managementState"] == DscComponents.ManagementState.MANAGED:
+            dsc_resource.wait_for_condition(condition=DscComponents.COMPONENT_MAPPING[component_name], status="True")
+        if (
+            component_name == DscComponents.MODELREGISTRY
+            and value.get("managementState") == DscComponents.ManagementState.MANAGED
+        ):
+            # Since namespace specified in registriesNamespace is automatically created after setting
+            # managementStateto Managed. We need to explicitly delete it on clean up.
+            namespace = Namespace(name=value["registriesNamespace"], ensure_exists=True)
+            if namespace:
+                namespace.delete(wait=True)
+
+
+@pytest.fixture(scope="class")
+def model_registry_client(current_client_token: str, model_registry_instance_rest_endpoint: str) -> ModelRegistryClient:
+    # address and port need to be split in the client instantiation
+    server, port = model_registry_instance_rest_endpoint.split(":")
+    return ModelRegistryClient(
+        server_address=f"{Protocols.HTTPS}://{server}",
+        port=port,
+        author="opendatahub-test",
+        user_token=current_client_token,
+        is_secure=False,
+    )
+
+
+@pytest.fixture(scope="class")
+def registered_model(request: FixtureRequest, model_registry_client: ModelRegistryClient) -> RegisteredModel:
+    return model_registry_client.register_model(
+        name=request.param.get("model_name"),
+        uri=request.param.get("model_uri"),
+        version=request.param.get("model_version"),
+        description=request.param.get("model_description"),
+        model_format_name=request.param.get("model_format"),
+        model_format_version=request.param.get("model_format_version"),
+        storage_key=request.param.get("model_storage_key"),
+        storage_path=request.param.get("model_storage_path"),
+        metadata=request.param.get("model_metadata"),
+    )
+
+
+@pytest.fixture()
+def model_registry_operator_pod(admin_client: DynamicClient) -> Pod:
+    model_registry_operator_pods = [
+        pod
+        for pod in Pod.get(dyn_client=admin_client, namespace=py_config["applications_namespace"])
+        if re.match(MR_OPERATOR_NAME, pod.name)
+    ]
+    if not model_registry_operator_pods:
+        raise ResourceNotFoundError("Model registry operator pod not found")
+    return model_registry_operator_pods[0]

tests/model_registry/constants.py

@@ -1,7 +1,37 @@
+from typing import Any
+
+from utilities.constants import ModelFormat
+
+
 class ModelRegistryEndpoints:
     REGISTERED_MODELS: str = "/api/model_registry/v1alpha3/registered_models"
 
 
+MR_NAMESPACE: str = "rhoai-model-registries"
+MR_OPERATOR_NAME: str = "model-registry-operator"
+MODEL_NAME: str = "my-model"
+MODEL_DICT: dict[str, Any] = {
+    "model_name": MODEL_NAME,
+    "model_uri": "https://storage-place.my-company.com",
+    "model_version": "2.0.0",
+    "model_description": "lorem ipsum",
+    "model_format": ModelFormat.ONNX,
+    "model_format_version": "1",
+    "model_storage_key": "my-data-connection",
+    "model_storage_path": "path/to/model",
+    "model_metadata": {
+        "int_key": 1,
+        "bool_key": False,
+        "float_key": 3.14,
+        "str_key": "str_value",
+    },
+}
+MR_INSTANCE_NAME: str = "model-registry"
+ISTIO_CONFIG_DICT: dict[str, Any] = {
+    "authProvider": "redhat-ods-applications-auth-provider",
+    "gateway": {"grpc": {"tls": {}}, "rest": {"tls": {}}},
+}
+DB_RESOURCES_NAME: str = "model-registry-db"
 MR_DB_IMAGE_DIGEST: str = (
     "public.ecr.aws/docker/library/mysql@sha256:9de9d54fecee6253130e65154b930978b1fcc336bcc86dfd06e89b72a2588ebe"
 )

tests/model_registry/test_model_registry_creation.py

@@ -3,79 +3,99 @@
 from simple_logger.logger import get_logger
 
 from ocp_resources.data_science_cluster import DataScienceCluster
-from utilities.constants import Protocols, DscComponents, ModelFormat
-from model_registry import ModelRegistry
-
+from ocp_resources.pod import Pod
+from ocp_resources.namespace import Namespace
+from utilities.constants import DscComponents
+from tests.model_registry.constants import MR_NAMESPACE, MODEL_NAME, MODEL_DICT
+from model_registry import ModelRegistry as ModelRegistryClient
+from model_registry.types import RegisteredModel
+from kubernetes.dynamic import DynamicClient
 
 LOGGER = get_logger(name=__name__)
-MODEL_NAME: str = "my-model"
+
+CUSTOM_NAMESPACE = "model-registry-custom-ns"
 
 
 @pytest.mark.parametrize(
-    "updated_dsc_component_state",
+    "model_registry_namespace, updated_dsc_component_state_scope_class",
     [
         pytest.param(
+            {"namespace_name": CUSTOM_NAMESPACE},
+            {
+                "component_patch": {
+                    DscComponents.MODELREGISTRY: {
+                        "managementState": DscComponents.ManagementState.MANAGED,
+                        "registriesNamespace": CUSTOM_NAMESPACE,
+                    },
+                }
+            },
+        ),
+        pytest.param(
+            {"namespace_name": MR_NAMESPACE},
             {
-                "component_name": DscComponents.MODELREGISTRY,
-                "desired_state": DscComponents.ManagementState.MANAGED,
+                "component_patch": {
+                    DscComponents.MODELREGISTRY: {
+                        "managementState": DscComponents.ManagementState.MANAGED,
+                        "registriesNamespace": MR_NAMESPACE,
+                    },
+                },
             },
-        )
+        ),
     ],
     indirect=True,
 )
+@pytest.mark.usefixtures("model_registry_namespace", "updated_dsc_component_state_scope_class")
 class TestModelRegistryCreation:
     """
     Tests the creation of a model registry. If the component is set to 'Removed' it will be switched to 'Managed'
     for the duration of this test module.
     """
 
     @pytest.mark.smoke
+    @pytest.mark.parametrize(
+        "registered_model",
+        [
+            pytest.param(
+                MODEL_DICT,
+            )
+        ],
+        indirect=True,
+    )
     def test_registering_model(
         self: Self,
-        model_registry_instance_rest_endpoint: str,
-        current_client_token: str,
-        updated_dsc_component_state: DataScienceCluster,
+        model_registry_client: ModelRegistryClient,
+        registered_model: RegisteredModel,
     ):
-        # address and port need to be split in the client instantiation
-        server, port = model_registry_instance_rest_endpoint.split(":")
-        registry = ModelRegistry(
-            server_address=f"{Protocols.HTTPS}://{server}",
-            port=port,
-            author="opendatahub-test",
-            user_token=current_client_token,
-            is_secure=False,
-        )
-        model = registry.register_model(
-            name=MODEL_NAME,
-            uri="https://storage-place.my-company.com",
-            version="2.0.0",
-            description="lorem ipsum",
-            model_format_name=ModelFormat.ONNX,
-            model_format_version="1",
-            storage_key="my-data-connection",
-            storage_path="path/to/model",
-            metadata={
-                "int_key": 1,
-                "bool_key": False,
-                "float_key": 3.14,
-                "str_key": "str_value",
-            },
-        )
-        registered_model = registry.get_registered_model(MODEL_NAME)
+        model = model_registry_client.get_registered_model(MODEL_NAME)
         errors = []
         if not registered_model.id == model.id:
-            errors.append(f"Unexpected id, received {registered_model.id}")
+            errors.append(f"Unexpected id, received {model.id}")
         if not registered_model.name == model.name:
-            errors.append(f"Unexpected name, received {registered_model.name}")
+            errors.append(f"Unexpected name, received {model.name}")
         if not registered_model.description == model.description:
-            errors.append(f"Unexpected description, received {registered_model.description}")
+            errors.append(f"Unexpected description, received {model.description}")
         if not registered_model.owner == model.owner:
-            errors.append(f"Unexpected owner, received {registered_model.owner}")
+            errors.append(f"Unexpected owner, received {model.owner}")
         if not registered_model.state == model.state:
-            errors.append(f"Unexpected state, received {registered_model.state}")
+            errors.append(f"Unexpected state, received {model.state}")
 
         assert not errors, "errors found in model registry response validation:\n{}".format("\n".join(errors))
 
+    def test_model_registry_operator_env(
+        self,
+        admin_client: DynamicClient,
+        model_registry_namespace: Namespace,
+        updated_dsc_component_state_scope_class: DataScienceCluster,
+        model_registry_operator_pod: Pod,
+    ):
+        namespace_env = []
+        for container in model_registry_operator_pod.instance.spec.containers:
+            for env in container.env:
+                if env.name == "REGISTRIES_NAMESPACE" and env.value == model_registry_namespace.name:
+                    namespace_env.append({container.name: env})
+        if not namespace_env:
+            pytest.fail("Missing environment variable REGISTRIES_NAMESPACE")
+
     # TODO: Edit a registered model
     # TODO: Add additional versions for a model
     # TODO: List all available models