test: add qdrant vector_io tests (opendatahub-io#1029)

* test: add qdrant vector_io tests

* test: update env vars for qdrant and readme added generic secrets

---------

Co-authored-by: Jorge <jgarciao@users.noreply.github.com>

Author: Bobbins228

tests/fixtures/vector_io.py

@@ -7,6 +7,7 @@
 from ocp_resources.deployment import Deployment
 from ocp_resources.namespace import Namespace
 from ocp_resources.service import Service
+from ocp_resources.secret import Secret
 
 
 MILVUS_IMAGE = os.getenv(
@@ -30,11 +31,26 @@
 PGVECTOR_USER = os.getenv("LLS_VECTOR_IO_PGVECTOR_USER", "vector_user")
 PGVECTOR_PASSWORD = os.getenv("LLS_VECTOR_IO_PGVECTOR_PASSWORD", "yourpassword")
 
+# qdrant v1 unprivileged latest
+QDRANT_IMAGE = os.getenv(
+    "LLS_VECTOR_IO_QDRANT_IMAGE",
+    (
+        "docker.io/qdrant/qdrant@sha256:"
+        "9dfabc51ededc48158899a288a19a04de1ab54a11d8c512e1c40eebbd5e2bc92"  # pragma: allowlist secret
+    ),
+)
+
+QDRANT_API_KEY = os.getenv("LLS_VECTOR_IO_QDRANT_API_KEY", "yourapikey")
+QDRANT_URL = os.getenv("LLS_VECTOR_IO_QDRANT_URL", "http://vector-io-qdrant-service:6333")
+
 
 @pytest.fixture(scope="class")
 def vector_io_provider_deployment_config_factory(
+    unprivileged_client: DynamicClient,
+    unprivileged_model_namespace: Namespace,
+    vector_io_secret: Secret,
     request: FixtureRequest,
-) -> Callable[[str], list[Dict[str, str]]]:
+) -> Callable[[str], list[Dict[str, Any]]]:
     """
     Factory fixture for deploying vector I/O providers and returning their configuration.
 
@@ -66,23 +82,35 @@ def vector_io_provider_deployment_config_factory(
           * PGVECTOR_USER: Database user
           * PGVECTOR_PASSWORD: Database password
           * PGVECTOR_DB: Database name
+        - "qdrant-remote":
+          * ENABLE_QDRANT: enable qdrant provider
+          * QDRANT_API_KEY: Qdrant API key
+          * QDRANT_URL: Qdrant service URL with protocol (e.g., "http://vector-io-qdrant-service:6333")
 
     Example:
         def test_with_milvus(vector_io_provider_deployment_config_factory):
             env_vars = vector_io_provider_deployment_config_factory("milvus-remote")
             # env_vars contains MILVUS_ENDPOINT, MILVUS_TOKEN, etc.
     """
+    _ = unprivileged_client
+    _ = unprivileged_model_namespace
+    _ = vector_io_secret
 
-    def _factory(provider_name: str) -> list[Dict[str, str]]:
-        env_vars: list[dict[str, str]] = []
+    def _factory(provider_name: str) -> list[Dict[str, Any]]:
+        env_vars: list[dict[str, Any]] = []
 
         if provider_name is None or provider_name == "milvus":
             # Default case - no additional environment variables needed
             pass
         elif provider_name == "milvus-remote":
             request.getfixturevalue(argname="milvus_service")
             env_vars.append({"name": "MILVUS_ENDPOINT", "value": "http://vector-io-milvus-service:19530"})
-            env_vars.append({"name": "MILVUS_TOKEN", "value": MILVUS_TOKEN})
+            env_vars.append(
+                {
+                    "name": "MILVUS_TOKEN",
+                    "valueFrom": {"secretKeyRef": {"name": "vector-io-secret", "key": "milvus-token"}},
+                },
+            )
             env_vars.append({"name": "MILVUS_CONSISTENCY_LEVEL", "value": "Bounded"})
         elif provider_name == "faiss":
             env_vars.append({"name": "ENABLE_FAISS", "value": "faiss"})
@@ -95,15 +123,54 @@ def _factory(provider_name: str) -> list[Dict[str, str]]:
             env_vars.append({"name": "ENABLE_PGVECTOR", "value": "true"})
             env_vars.append({"name": "PGVECTOR_HOST", "value": "vector-io-pgvector-service"})
             env_vars.append({"name": "PGVECTOR_PORT", "value": "5432"})
-            env_vars.append({"name": "PGVECTOR_USER", "value": PGVECTOR_USER})
-            env_vars.append({"name": "PGVECTOR_PASSWORD", "value": PGVECTOR_PASSWORD})
+            env_vars.append(
+                {
+                    "name": "PGVECTOR_USER",
+                    "valueFrom": {"secretKeyRef": {"name": "vector-io-secret", "key": "pgvector-user"}},
+                },
+            )
+            env_vars.append(
+                {
+                    "name": "PGVECTOR_PASSWORD",
+                    "valueFrom": {"secretKeyRef": {"name": "vector-io-secret", "key": "pgvector-password"}},
+                },
+            )
             env_vars.append({"name": "PGVECTOR_DB", "value": "pgvector"})
+        elif provider_name == "qdrant-remote":
+            request.getfixturevalue(argname="qdrant_service")
+            env_vars.append({"name": "ENABLE_QDRANT", "value": "true"})
+            env_vars.append({"name": "QDRANT_URL", "value": QDRANT_URL})
+            env_vars.append({
+                "name": "QDRANT_API_KEY",
+                "valueFrom": {"secretKeyRef": {"name": "vector-io-secret", "key": "qdrant-api-key"}},
+            })
 
         return env_vars
 
     return _factory
 
 
+@pytest.fixture(scope="class")
+def vector_io_secret(
+    unprivileged_client: DynamicClient,
+    unprivileged_model_namespace: Namespace,
+) -> Generator[Secret, Any, Any]:
+    """Create a secret for the vector I/O providers"""
+    with Secret(
+        client=unprivileged_client,
+        namespace=unprivileged_model_namespace.name,
+        name="vector-io-secret",
+        type="Opaque",
+        string_data={
+            "qdrant-api-key": QDRANT_API_KEY,
+            "pgvector-user": PGVECTOR_USER,
+            "pgvector-password": PGVECTOR_PASSWORD,
+            "milvus-token": MILVUS_TOKEN,
+        },
+    ) as secret:
+        yield secret
+
+
 @pytest.fixture(scope="class")
 def etcd_deployment(
     unprivileged_client: DynamicClient,
@@ -152,8 +219,13 @@ def remote_milvus_deployment(
     unprivileged_model_namespace: Namespace,
     etcd_deployment: Deployment,
     etcd_service: Service,
+    vector_io_secret: Secret,
 ) -> Generator[Deployment, Any, Any]:
     """Deploy a remote Milvus instance for vector I/O provider testing."""
+    _ = etcd_deployment
+    _ = etcd_service
+    _ = vector_io_secret
+
     with Deployment(
         client=unprivileged_client,
         namespace=unprivileged_model_namespace.name,
@@ -176,6 +248,8 @@ def milvus_service(
     remote_milvus_deployment: Deployment,
 ) -> Generator[Service, Any, Any]:
     """Create a service for the remote Milvus deployment."""
+    _ = remote_milvus_deployment
+
     with Service(
         client=unprivileged_client,
         namespace=unprivileged_model_namespace.name,
@@ -272,8 +346,11 @@ def get_etcd_deployment_template() -> Dict[str, Any]:
 def pgvector_deployment(
     unprivileged_client: DynamicClient,
     unprivileged_model_namespace: Namespace,
+    vector_io_secret: Secret,
 ) -> Generator[Deployment, Any, Any]:
     """Deploy a PGVector instance for vector I/O provider testing."""
+    _ = vector_io_secret
+
     with Deployment(
         client=unprivileged_client,
         namespace=unprivileged_model_namespace.name,
@@ -296,6 +373,8 @@ def pgvector_service(
     pgvector_deployment: Deployment,
 ) -> Generator[Service, Any, Any]:
     """Create a service for the PGVector deployment."""
+    _ = pgvector_deployment
+
     with Service(
         client=unprivileged_client,
         namespace=unprivileged_model_namespace.name,
@@ -325,8 +404,14 @@ def get_pgvector_deployment_template() -> Dict[str, Any]:
                     "ports": [{"containerPort": 5432}],
                     "env": [
                         {"name": "POSTGRES_DB", "value": "pgvector"},
-                        {"name": "POSTGRES_USER", "value": PGVECTOR_USER},
-                        {"name": "POSTGRES_PASSWORD", "value": PGVECTOR_PASSWORD},
+                        {
+                            "name": "POSTGRES_USER",
+                            "valueFrom": {"secretKeyRef": {"name": "vector-io-secret", "key": "pgvector-user"}},
+                        },
+                        {
+                            "name": "POSTGRES_PASSWORD",
+                            "valueFrom": {"secretKeyRef": {"name": "vector-io-secret", "key": "pgvector-password"}},
+                        },
                         {"name": "PGDATA", "value": "/var/lib/postgresql/data/pgdata"},
                     ],
                     "lifecycle": {
@@ -350,3 +435,103 @@ def get_pgvector_deployment_template() -> Dict[str, Any]:
             "volumes": [{"name": "pgdata", "emptyDir": {}}],
         },
     }
+
+
+@pytest.fixture(scope="class")
+def qdrant_deployment(
+    unprivileged_client: DynamicClient,
+    unprivileged_model_namespace: Namespace,
+    vector_io_secret: Secret,
+) -> Generator[Deployment, Any, Any]:
+    """Deploy a Qdrant instance for vector I/O provider testing."""
+    _ = vector_io_secret
+
+    with Deployment(
+        client=unprivileged_client,
+        namespace=unprivileged_model_namespace.name,
+        name="vector-io-qdrant-deployment",
+        min_ready_seconds=5,
+        replicas=1,
+        selector={"matchLabels": {"app": "qdrant"}},
+        strategy={"type": "Recreate"},
+        template=get_qdrant_deployment_template(),
+        teardown=True,
+    ) as deployment:
+        deployment.wait_for_replicas(deployed=True, timeout=240)
+        yield deployment
+
+
+@pytest.fixture(scope="class")
+def qdrant_service(
+    unprivileged_client: DynamicClient,
+    unprivileged_model_namespace: Namespace,
+    qdrant_deployment: Deployment,
+) -> Generator[Service, Any, Any]:
+    """Create a service for the Qdrant deployment."""
+    _ = qdrant_deployment
+
+    with Service(
+        client=unprivileged_client,
+        namespace=unprivileged_model_namespace.name,
+        name="vector-io-qdrant-service",
+        ports=[
+            {
+                "name": "http",
+                "port": 6333,
+                "targetPort": 6333,
+            },
+            {
+                "name": "grpc",
+                "port": 6334,
+                "targetPort": 6334,
+            },
+        ],
+        selector={"app": "qdrant"},
+        wait_for_resource=True,
+    ) as service:
+        yield service
+
+
+def get_qdrant_deployment_template() -> Dict[str, Any]:
+    """Return a Kubernetes deployment for Qdrant"""
+    return {
+        "metadata": {"labels": {"app": "qdrant"}},
+        "spec": {
+            "containers": [
+                {
+                    "name": "qdrant",
+                    "image": QDRANT_IMAGE,
+                    "ports": [
+                        {
+                            "containerPort": 6333,
+                            "name": "http",
+                        },
+                        {
+                            "containerPort": 6334,
+                            "name": "grpc",
+                        },
+                    ],
+                    "env": [
+                        {
+                            "name": "QDRANT__SERVICE__API_KEY",
+                            "valueFrom": {
+                                "secretKeyRef": {
+                                    "name": "vector-io-secret",
+                                    "key": "qdrant-api-key",
+                                },
+                            },
+                        },
+                    ],
+                    "volumeMounts": [
+                        {"name": "qdrant-storage", "mountPath": "/qdrant/storage"},
+                        {
+                            "name": "qdrant-storage",
+                            "mountPath": "/qdrant/snapshots",
+                            "subPath": "snapshots",
+                        },
+                    ],
+                },
+            ],
+            "volumes": [{"name": "qdrant-storage", "emptyDir": {}}],
+        },
+    }

tests/llama_stack/README.md

@@ -71,6 +71,9 @@ LLS_VECTOR_IO_ETCD_IMAGE=<CUSTOM-ETCD-IMAGE>      # Optional
 LLS_VECTOR_IO_PGVECTOR_IMAGE=<CUSTOM-PGVECTOR-IMAGE> # Optional
 LLS_VECTOR_IO_PGVECTOR_USER=<CUSTOM-PGVECTOR-USER> # Optional
 LLS_VECTOR_IO_PGVECTOR_PASSWORD=<CUSTOM-PGVECTOR-PASSWORD> # Optional
+LLS_VECTOR_IO_QDRANT_IMAGE=<CUSTOM-QDRANT-IMAGE> # Optional
+LLS_VECTOR_IO_QDRANT_API_KEY=<CUSTOM-QDRANT-API-KEY> # Optional
+LLS_VECTOR_IO_QDRANT_URL=<QDRANT_URL_WITH_PROTOCOL> # Optional
 
 # Red Hat Llama Stack Distribution requires PostgreSQL (replacing SQLite)
 LLS_VECTOR_IO_POSTGRES_IMAGE=<CUSTOM-POSTGRES-IMAGE> # Optional