Fix test for Rawkserve clusteripnone chnages

Signed-off-by: Milind Waykole <mwaykole@mwaykole-thinkpadp1gen4i.bengluru.csb>

Author: Milind Waykole

tests/model_serving/model_server/components/kserve_dsc_deployment_mode/conftest.py

@@ -14,6 +14,7 @@
 
 from tests.model_serving.model_server.components.kserve_dsc_deployment_mode.utils import (
     patch_dsc_default_deployment_mode,
+    patch_raw_default_deployment_config,
 )
 from utilities.constants import ModelAndFormat
 from utilities.inference_utils import create_isvc
@@ -54,6 +55,54 @@ def patched_default_deployment_mode_in_dsc(
     )
 
 
+@pytest.fixture(scope="class")
+def default_deployment_serviceconfig_in_dsc(
+    request: FixtureRequest,
+    default_deployment_mode_in_dsc: DataScienceCluster,
+    inferenceservice_config_cm: ConfigMap,
+) -> Generator[DataScienceCluster, Any, Any]:
+    """
+    Fixture to set the default deployment service configuration in DSC.
+
+    Args:
+        request: Fixture request object
+        default_deployment_mode_in_dsc: DataScienceCluster resource with deployment mode set
+        inferenceservice_config_cm: ConfigMap for inference service configuration
+
+    Yields:
+        DataScienceCluster: The DSC resource with updated service configuration
+    """
+    yield from patch_raw_default_deployment_config(
+        dsc_resource=default_deployment_mode_in_dsc,
+        inferenceservice_config_cm=inferenceservice_config_cm,
+        request_default_deployment_config=request.param["default-deployment-config"],
+    )
+
+
+@pytest.fixture(scope="class")
+def patched_default_deployment_serviceconfig_in_dsc(
+    request: FixtureRequest,
+    default_deployment_serviceconfig_in_dsc: DataScienceCluster,
+    inferenceservice_config_cm: ConfigMap,
+) -> Generator[DataScienceCluster, Any, Any]:
+    """
+    Fixture to patch the default deployment service configuration in DSC.
+
+    Args:
+        request: Fixture request object
+        default_deployment_serviceconfig_in_dsc: DSC resource with initial service configuration
+        inferenceservice_config_cm: ConfigMap for inference service configuration
+
+    Yields:
+        DataScienceCluster: The DSC resource with patched service configuration
+    """
+    yield from patch_raw_default_deployment_config(
+        dsc_resource=default_deployment_serviceconfig_in_dsc,
+        inferenceservice_config_cm=inferenceservice_config_cm,
+        request_default_deployment_config=request.param["updated-deployment-config"],
+    )
+
+
 @pytest.fixture(scope="class")
 def ovms_inference_service(
     request: FixtureRequest,

tests/model_serving/model_server/components/kserve_dsc_deployment_mode/test_kserve_dsc_default_deployment_mode.py

@@ -1,5 +1,6 @@
 import pytest
 
+from tests.model_serving.model_server.components.kserve_dsc_deployment_mode.utils import get_service_cluster_ip
 from tests.model_serving.model_server.utils import verify_inference_response
 from utilities.constants import (
     Annotations,
@@ -170,3 +171,39 @@ def test_restarted_pod_is_raw(
         pod_containers = {container.name for container in restarted_inference_pod.instance.spec.containers}
 
         assert pod_containers == {"kserve-container"}
+
+    def test_default_service_config_is_headless(
+        self, admin_client, default_deployment_mode_in_dsc, ovms_inference_service
+    ):
+        """
+        Verify that the default service configuration is set to Headless mode
+        (serviceClusterIPNone=True).
+        """
+        assert get_service_cluster_ip(admin_client) is True, (
+            "Default service config should be Headless (serviceClusterIPNone=True)"
+        )
+
+    @pytest.mark.parametrize(
+        "patched_default_deployment_serviceconfig_in_dsc,default_deployment_serviceconfig_in_dsc",
+        [
+            pytest.param(
+                {"updated-deployment-config": "Headed"},
+                {"default-deployment-config": "Headless"},
+            )
+        ],
+        indirect=True,
+    )
+    def test_service_config_can_be_updated_to_headed(
+        self,
+        default_deployment_mode_in_dsc,
+        default_deployment_serviceconfig_in_dsc,
+        patched_default_deployment_serviceconfig_in_dsc,
+        ovms_inference_service,
+        admin_client,
+    ):
+        """
+        Verify that the service configuration can be updated from Headless to Headed mode.
+        """
+        assert get_service_cluster_ip(admin_client) is False, (
+            "Service config should be Headed (serviceClusterIPNone=False) after update"
+        )

tests/model_serving/model_server/components/kserve_dsc_deployment_mode/utils.py

@@ -7,6 +7,7 @@
 from simple_logger.logger import get_logger
 from timeout_sampler import TimeoutSampler
 
+from kubernetes.dynamic import DynamicClient
 from utilities.constants import Timeout
 
 LOGGER = get_logger(name=__name__)
@@ -67,3 +68,86 @@ def patch_dsc_default_deployment_mode(
             deployment_mode=request_default_deployment_mode,
         )
         yield dsc_resource
+
+
+def wait_for_service_config_in_cm(config_map: ConfigMap, service_config: str) -> None:
+    """
+    Wait for service config to be set in inferenceservice-config configmap.
+
+    Args:
+        config_map (ConfigMap): ConfigMap object
+        service_config (str): Service configuration type ("Headless" or "Headed")
+
+    Raises:
+        TimeoutExpiredError: If service config value is not set in configmap
+    """
+    LOGGER.info(f"Waiting for {service_config} service config to be set in {config_map.name} configmap")
+    expected_value = service_config == "Headless"
+    for sample in TimeoutSampler(
+        wait_timeout=Timeout.TIMEOUT_5MIN,
+        sleep=5,
+        func=lambda: config_map.instance.data,
+    ):
+        if sample:
+            try:
+                cm_service_config = json.loads(sample.service)["serviceClusterIPNone"]
+                if cm_service_config == expected_value:
+                    LOGGER.info(f"Service config successfully set to {service_config}")
+                    break
+            except (KeyError, json.JSONDecodeError) as e:
+                LOGGER.warning(f"Error reading service config: {e}")
+                continue
+
+
+def patch_raw_default_deployment_config(
+    dsc_resource: DataScienceCluster,
+    inferenceservice_config_cm: ConfigMap,
+    request_default_deployment_config: str,
+) -> Generator[DataScienceCluster, Any, Any]:
+    """
+    Patch DataScienceCluster object with service configuration and wait for it to be set in configmap.
+
+    Args:
+        dsc_resource (DataScienceCluster): DataScienceCluster object
+        inferenceservice_config_cm (ConfigMap): ConfigMap object
+        request_default_deployment_config (str): Service configuration type ("Headless" or "Headed")
+
+    Yields:
+        DataScienceCluster: DataScienceCluster object with updated service configuration
+    """
+    if request_default_deployment_config not in ["Headless", "Headed"]:
+        raise ValueError("Service config must be either 'Headless' or 'Headed'")
+
+    with ResourceEditor(
+        patches={
+            dsc_resource: {
+                "spec": {"components": {"kserve": {"rawDeploymentServiceConfig": request_default_deployment_config}}}
+            }
+        }
+    ):
+        wait_for_service_config_in_cm(
+            config_map=inferenceservice_config_cm,
+            service_config=request_default_deployment_config,
+        )
+        yield dsc_resource
+
+
+def get_service_cluster_ip(admin_client: DynamicClient) -> bool:
+    """
+    Get the service cluster IP configuration from the inferenceservice-config configmap.
+
+    Args:
+        admin_client: Admin client for accessing the cluster
+
+    Returns:
+        dict: Service configuration from the configmap
+
+    Raises:
+        ValueError: If the configmap or service configuration cannot be read
+    """
+    try:
+        config_map = ConfigMap(client=admin_client, namespace="redhat-ods-applications", name="inferenceservice-config")
+        config_map = json.loads(config_map.instance["data"]["service"])
+        return config_map["serviceClusterIPNone"]
+    except (KeyError, json.JSONDecodeError) as e:
+        raise ValueError(f"Failed to read service configuration: {e}")