Merge remote-tracking branch 'upstream/main' into cp_maria

Author: dbasunag

.pre-commit-config.yaml

@@ -35,7 +35,7 @@ repos:
       - id: detect-secrets
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.1
+    rev: v0.12.2
     hooks:
       - id: ruff
       - id: ruff-format

pyproject.toml

@@ -50,7 +50,6 @@ dependencies = [
     "pyyaml",
     "tenacity",
     "types-requests>=2.32.0.20241016",
-    "schemathesis>=4.0.0a8",
     "requests",
     "pytest-asyncio",
     "syrupy",

schemathesis.toml

@@ -9,7 +9,7 @@
 LOGGER = get_logger(name=__name__)
 
 
-def get_lmevaljob_pod(client: DynamicClient, lmevaljob: LMEvalJob, timeout: int = Timeout.TIMEOUT_2MIN) -> Pod:
+def get_lmevaljob_pod(client: DynamicClient, lmevaljob: LMEvalJob, timeout: int = Timeout.TIMEOUT_10MIN) -> Pod:
     """
     Gets the pod corresponding to a given LMEvalJob and waits for it to be ready.
 

tests/model_explainability/lm_eval/utils.py

@@ -197,7 +197,6 @@ def test_validate_trustyai_service_image(
     indirect=True,
 )
 @pytest.mark.usefixtures("minio_pod")
-@pytest.mark.smoke
 def test_trustyai_service_db_migration(
     admin_client,
     current_client_token,

tests/model_explainability/trustyai_service/service/test_trustyai_service.py

@@ -38,7 +38,7 @@ def wait_for_mariadb_operator_deployments(mariadb_operator: MariadbOperator) ->
         deployment.wait_for_replicas()
 
 
-def wait_for_mariadb_pods(client: DynamicClient, mariadb: MariaDB, timeout: int = Timeout.TIMEOUT_5MIN) -> None:
+def wait_for_mariadb_pods(client: DynamicClient, mariadb: MariaDB, timeout: int = Timeout.TIMEOUT_15MIN) -> None:
     def _get_mariadb_pods() -> list[Pod]:
         _pods = [
             _pod

tests/model_explainability/trustyai_service/utils.py

@@ -1,7 +1,5 @@
-import os
 import pytest
 from pytest import Config
-import schemathesis
 from typing import Generator, Any
 
 from ocp_resources.infrastructure import Infrastructure
@@ -14,10 +12,6 @@
 from ocp_resources.deployment import Deployment
 
 from ocp_resources.model_registry_modelregistry_opendatahub_io import ModelRegistry
-from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
-from schemathesis.generation.stateful.state_machine import APIStateMachine
-from schemathesis.core.transport import Response
-from schemathesis.generation.case import Case
 from ocp_resources.resource import ResourceEditor
 
 from pytest import FixtureRequest
@@ -37,15 +31,15 @@
     ISTIO_CONFIG_DICT,
 )
 from tests.model_registry.rest_api.utils import ModelRegistryV1Alpha1
-from utilities.constants import Labels
+from utilities.constants import Labels, Protocols
 from tests.model_registry.utils import (
     get_endpoint_from_mr_service,
     get_mr_service_by_label,
     get_model_registry_deployment_template_dict,
     get_model_registry_db_label_dict,
     wait_for_pods_running,
 )
-from utilities.constants import Protocols, DscComponents
+from utilities.constants import DscComponents
 from model_registry import ModelRegistry as ModelRegistryClient
 from semver import Version
 from utilities.general import wait_for_pods_by_labels
@@ -235,7 +229,7 @@ def model_registry_instance_mysql(
             mr.wait_for_condition(condition="Available", status="True")
             mr.wait_for_condition(condition="OAuthProxyAvailable", status="True")
             wait_for_pods_running(
-                admin_client=admin_client, namespace_name=model_registry_namespace, number_of_consecutive_checks=3
+                admin_client=admin_client, namespace_name=model_registry_namespace, number_of_consecutive_checks=6
             )
             yield mr
 
@@ -279,43 +273,6 @@ def model_registry_instance_rest_endpoint(admin_client: DynamicClient, model_reg
     )
 
 
-@pytest.fixture(scope="class")
-def generated_schema(pytestconfig: Config, model_registry_instance_rest_endpoint: str) -> BaseOpenAPISchema:
-    os.environ["API_HOST"] = model_registry_instance_rest_endpoint
-    config = schemathesis.config.SchemathesisConfig.from_path(f"{pytestconfig.rootpath}/schemathesis.toml")
-    schema = schemathesis.openapi.from_url(
-        url="https://raw.githubusercontent.com/kubeflow/model-registry/main/api/openapi/model-registry.yaml",
-        config=config,
-    )
-    return schema
-
-
-@pytest.fixture()
-def state_machine(generated_schema: BaseOpenAPISchema, current_client_token: str) -> APIStateMachine:
-    BaseAPIWorkflow = generated_schema.as_state_machine()
-
-    class APIWorkflow(BaseAPIWorkflow):  # type: ignore
-        headers: dict[str, str]
-
-        def setup(self) -> None:
-            self.headers = {"Authorization": f"Bearer {current_client_token}", "Content-Type": "application/json"}
-
-        def before_call(self, case: Case) -> None:
-            LOGGER.info(f"Checking: {case.method} {case.path}")
-
-        # these kwargs are passed to requests.request()
-        def get_call_kwargs(self, case: Case) -> dict[str, Any]:
-            return {"verify": False, "headers": self.headers}
-
-        def after_call(self, response: Response, case: Case) -> None:
-            LOGGER.info(
-                f"Method tested: {case.method}, API: {case.path}, response code:{response.status_code},"
-                f" Full Response:{response.text}"
-            )
-
-    return APIWorkflow
-
-
 @pytest.fixture(scope="class")
 def updated_dsc_component_state_scope_class(
     pytestconfig: Config,
@@ -481,6 +438,55 @@ def model_registry_instance_pod(admin_client: DynamicClient) -> Generator[Pod, A
     )[0]
 
 
+@pytest.fixture()
+def model_registry_db_instance_pod(admin_client: DynamicClient) -> Generator[Pod, Any, Any]:
+    """Get the model registry instance pod."""
+    yield wait_for_pods_by_labels(
+        admin_client=admin_client,
+        namespace=py_config["model_registry_namespace"],
+        label_selector=f"name={DB_RESOURCES_NAME}",
+        expected_num_pods=1,
+    )[0]
+
+
+@pytest.fixture()
+def set_mr_db_dirty(model_registry_db_instance_pod: Pod) -> int:
+    """Set the model registry database dirty and return the latest migration version"""
+    output = model_registry_db_instance_pod.execute(
+        command=[
+            "mysql",
+            "-u",
+            MODEL_REGISTRY_DB_SECRET_STR_DATA["database-user"],
+            f"-p{MODEL_REGISTRY_DB_SECRET_STR_DATA['database-password']}",
+            "-e",
+            "SELECT version FROM schema_migrations ORDER BY version DESC LIMIT 1;",
+            MODEL_REGISTRY_DB_SECRET_STR_DATA["database-name"],
+        ]
+    )
+    latest_migration_version = int(output.strip().split()[1])
+    model_registry_db_instance_pod.execute(
+        command=[
+            "mysql",
+            "-u",
+            MODEL_REGISTRY_DB_SECRET_STR_DATA["database-user"],
+            f"-p{MODEL_REGISTRY_DB_SECRET_STR_DATA['database-password']}",
+            "-e",
+            f"UPDATE schema_migrations SET dirty = 1 WHERE version = {latest_migration_version};",
+            MODEL_REGISTRY_DB_SECRET_STR_DATA["database-name"],
+        ]
+    )
+    return latest_migration_version
+
+
+@pytest.fixture()
+def delete_mr_deployment() -> None:
+    """Delete the model registry deployment"""
+    mr_deployment = Deployment(
+        name=MR_INSTANCE_NAME, namespace=py_config["model_registry_namespace"], ensure_exists=True
+    )
+    mr_deployment.delete(wait=True)
+
+
 @pytest.fixture(scope="class")
 def is_model_registry_oauth(request: FixtureRequest) -> bool:
     return getattr(request, "param", {}).get("use_oauth_proxy", True)
@@ -490,3 +496,18 @@ def is_model_registry_oauth(request: FixtureRequest) -> bool:
 def api_server_url(admin_client: DynamicClient) -> str:
     infrastructure = Infrastructure(client=admin_client, name="cluster", ensure_exists=True)
     return infrastructure.instance.status.apiServerURL
+
+
+@pytest.fixture(scope="class")
+def model_registry_rest_url(model_registry_instance_rest_endpoint: str) -> str:
+    # address and port need to be split in the client instantiation
+    return f"{Protocols.HTTPS}://{model_registry_instance_rest_endpoint}"
+
+
+@pytest.fixture(scope="class")
+def model_registry_rest_headers(current_client_token: str) -> dict[str, str]:
+    return {
+        "Authorization": f"Bearer {current_client_token}",
+        "accept": "application/json",
+        "Content-Type": "application/json",
+    }

tests/model_registry/conftest.py

@@ -0,0 +1,62 @@
+import pytest
+from typing import Self
+from simple_logger.logger import get_logger
+from pytest_testconfig import config as py_config
+
+from ocp_resources.pod import Pod
+from utilities.constants import DscComponents
+from tests.model_registry.constants import MR_INSTANCE_NAME
+from kubernetes.dynamic.client import DynamicClient
+from utilities.general import wait_for_pods_by_labels
+
+
+LOGGER = get_logger(name=__name__)
+
+
+@pytest.mark.parametrize(
+    "updated_dsc_component_state_scope_class",
+    [
+        pytest.param({
+            "component_patch": {
+                DscComponents.MODELREGISTRY: {
+                    "managementState": DscComponents.ManagementState.MANAGED,
+                    "registriesNamespace": py_config["model_registry_namespace"],
+                },
+            }
+        }),
+    ],
+    indirect=True,
+)
+@pytest.mark.usefixtures(
+    "updated_dsc_component_state_scope_class", "model_registry_mysql_metadata_db", "model_registry_instance_mysql"
+)
+class TestDBMigration:
+    def test_db_migration_negative(
+        self: Self,
+        admin_client: DynamicClient,
+        model_registry_db_instance_pod: Pod,
+        set_mr_db_dirty: int,
+        delete_mr_deployment: None,
+    ):
+        """
+        RHOAIENG-27505: This test is to check the migration error when the database is dirty.
+        The test will:
+        1. Set the dirty flag to 1 for the latest migration version
+        2. Delete the model registry deployment
+        3. Check the logs for the expected error
+        """
+        mr_pods = wait_for_pods_by_labels(
+            admin_client=admin_client,
+            namespace=py_config["model_registry_namespace"],
+            label_selector=f"app={MR_INSTANCE_NAME}",
+            expected_num_pods=1,
+        )
+        mr_pod = mr_pods[0]
+        LOGGER.info("Checking the logs for the expected error")
+
+        log_output = mr_pod.log(container="rest-container")
+        expected_error = (
+            f"Error: {{{{ALERT}}}} error connecting to datastore: Dirty database version {set_mr_db_dirty}. "
+            "Fix and force version."
+        )
+        assert expected_error in log_output, "Expected error message not found in logs!"

tests/model_registry/negative_tests/test_db_migration.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+import pytest
+
+from ocp_resources.deployment import Deployment
+from tests.model_registry.constants import MR_INSTANCE_NAME
+
+
+@pytest.fixture(scope="class")
+def model_registry_deployment_containers(model_registry_namespace: str) -> dict[str, Any]:
+    return Deployment(
+        name=MR_INSTANCE_NAME, namespace=model_registry_namespace, ensure_exists=True
+    ).instance.spec.template.spec.containers

tests/model_registry/python_client/conftest.py

@@ -1,9 +1,10 @@
 import pytest
-from typing import Self
+from typing import Self, Any
 from simple_logger.logger import get_logger
 from pytest_testconfig import config as py_config
 
 from ocp_resources.pod import Pod
+from tests.model_registry.utils import execute_model_registry_get_command
 from utilities.constants import DscComponents
 from tests.model_registry.constants import MODEL_NAME, MODEL_DICT
 from model_registry import ModelRegistry as ModelRegistryClient
@@ -89,7 +90,41 @@ def test_model_registry_operator_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
-    # TODO: List all versions of a model
+    def test_model_registry_grpc_container_removal(self, model_registry_deployment_containers: dict[str, Any]):
+        """
+        RHOAIENG-26239: Test to ensure removal of grpc container from model registry deployment
+        Steps:
+            Create metadata database
+            Deploys model registry using the same
+            Check model registry deployment for grpc container. It should not be present
+        """
+
+        for container in model_registry_deployment_containers:
+            if "grpc" in container["name"]:
+                pytest.fail(f"GRPC container found: {container}")
+
+    @pytest.mark.parametrize(
+        "endpoint",
+        [
+            pytest.param(
+                "oauth/healthz",
+            ),
+            pytest.param(
+                "readyz/isDirty",
+            ),
+        ],
+    )
+    def test_model_registry_endpoint_response(
+        self, model_registry_rest_url: str, model_registry_rest_headers: dict[str, str], endpoint: str
+    ):
+        """
+        RHOAIENG-26239: Test to ensure model registry endpoints are responsive
+        Steps:
+            Create metadata database
+            Deploys model registry using the same
+            Ensure endpoint is responsive via get call
+        """
+        output = execute_model_registry_get_command(
+            url=f"{model_registry_rest_url}/{endpoint}", headers=model_registry_rest_headers, json_output=False
+        )
+        assert output["raw_output"].lower() == "OK".lower()