RHOAIENG-16055: new(tests): test to start a Workbench by creating the Notebook CR directly

Author: jiridanek

tests/workbenches/__init__.py

@@ -0,0 +1,46 @@
+#
+# Copyright Skodjob authors.
+# License: Apache License 2.0 (see the file LICENSE or http://apache.org/licenses/LICENSE-2.0.html).
+#
+from __future__ import annotations
+
+from typing import Generator
+
+from kubernetes.dynamic import DynamicClient
+
+from ocp_resources.namespace import Namespace
+from ocp_resources.persistent_volume_claim import PersistentVolumeClaim
+
+import pytest
+
+from utilities import constants
+from utilities.infra import create_ns
+
+
+@pytest.fixture(scope="class")
+def users_namespace(
+    request: pytest.FixtureRequest, unprivileged_client: DynamicClient
+) -> Generator[Namespace, None, None]:
+    with create_ns(
+        unprivileged_client=unprivileged_client,
+        name=request.param["name"],
+        labels={constants.Dashboard.label: "true"},
+        annotations={constants.ServiceMesh.annotation_inject: "false"},
+    ) as ns:
+        yield ns
+
+
+@pytest.fixture(scope="function")
+def users_persistent_volume_claim(
+    request: pytest.FixtureRequest, unprivileged_client: DynamicClient
+) -> Generator[PersistentVolumeClaim, None, None]:
+    with PersistentVolumeClaim(
+        client=unprivileged_client,
+        name=request.param["name"],
+        namespace=request.param["namespace"],
+        label={constants.Dashboard.label: "true"},
+        accessmodes="ReadWriteOnce",
+        size="10Gi",
+        volume_mode=PersistentVolumeClaim.VolumeMode.FILE,
+    ) as pvc:
+        yield pvc

tests/workbenches/conftest.py

@@ -0,0 +1,45 @@
+#
+# Copyright Skodjob authors.
+# License: Apache License 2.0 (see the file LICENSE or http://apache.org/licenses/LICENSE-2.0.html).
+#
+from __future__ import annotations
+
+from typing import Callable
+import typing
+
+T = typing.TypeVar("T")  # noqa: FCN001
+StepRType = tuple[str, str]
+
+
+def Desc(value: str) -> str:
+    return value
+
+
+def Step(
+    value: str,
+    expected: str,
+) -> StepRType:
+    return value, expected
+
+
+def SuiteDoc(
+    description: str,
+    before_test_steps: set[StepRType],
+    after_test_steps: set[StepRType],
+) -> Callable[[T], T]:
+    return lambda x: x
+
+
+def Contact(
+    name: str,
+    email: str,
+) -> tuple[str, str]:
+    return name, email
+
+
+def TestDoc(
+    description: str,
+    contact: tuple[str, str],
+    steps: set[StepRType],
+) -> Callable[[T], T]:
+    return lambda x: x

tests/workbenches/docs.py

@@ -0,0 +1,146 @@
+apiVersion: kubeflow.org/v1
+kind: Notebook
+metadata:
+  annotations:
+    notebooks.opendatahub.io/inject-oauth: 'true'
+    opendatahub.io/service-mesh: 'false'
+    opendatahub.io/accelerator-name: ''
+  labels:
+    app: my-workbench
+    opendatahub.io/dashboard: 'true'
+    opendatahub.io/odh-managed: 'true'
+    sidecar.istio.io/inject: 'false'
+  name: my-workbench
+  namespace: my-project
+spec:
+  template:
+    spec:
+      affinity: {}
+      containers:
+        - env:
+            - name: NOTEBOOK_ARGS
+              value: |-
+                --ServerApp.port=8888
+                                  --ServerApp.token=''
+                                  --ServerApp.password=''
+                                  --ServerApp.base_url=/notebook/my-project/my-workbench
+                                  --ServerApp.quit_button=False
+                                  --ServerApp.tornado_settings={"user":"odh_user","hub_host":"odh_dashboard_route","hub_prefix":"/projects/my-project"}
+            - name: JUPYTER_IMAGE
+              value: notebook_image_placeholder
+          image: notebook_image_placeholder
+          imagePullPolicy: Always
+          livenessProbe:
+            failureThreshold: 3
+            httpGet:
+              path: /notebook/my-project/my-workbench/api
+              port: notebook-port
+              scheme: HTTP
+            initialDelaySeconds: 10
+            periodSeconds: 5
+            successThreshold: 1
+            timeoutSeconds: 1
+          name: my-workbench
+          ports:
+            - containerPort: 8888
+              name: notebook-port
+              protocol: TCP
+          readinessProbe:
+            failureThreshold: 3
+            httpGet:
+              path: /notebook/my-project/my-workbench/api
+              port: notebook-port
+              scheme: HTTP
+            initialDelaySeconds: 10
+            periodSeconds: 5
+            successThreshold: 1
+            timeoutSeconds: 1
+          resources:
+            limits:
+              cpu: "2"
+              memory: 4Gi
+            requests:
+              cpu: "1"
+              memory: 1Gi
+          volumeMounts:
+            - mountPath: /opt/app-root/src
+              name: my-workbench
+            - mountPath: /dev/shm
+              name: shm
+          workingDir: /opt/app-root/src
+        - args:
+            - --provider=openshift
+            - --https-address=:8443
+            - --http-address=
+            - --openshift-service-account=my-workbench
+            - --cookie-secret-file=/etc/oauth/config/cookie_secret
+            - --cookie-expire=24h0m0s
+            - --tls-cert=/etc/tls/private/tls.crt
+            - --tls-key=/etc/tls/private/tls.key
+            - --upstream=http://localhost:8888
+            - --upstream-ca=/var/run/secrets/kubernetes.io/serviceaccount/ca.crt
+            - --email-domain=*
+            - --skip-provider-button
+            - --openshift-sar={"verb":"get","resource":"notebooks","resourceAPIGroup":"kubeflow.org","resourceName":"my-workbench","namespace":"$(NAMESPACE)"}
+            - --logout-url=odh_dashboard_route/projects/my-project?notebookLogout=my-workbench
+          env:
+            - name: NAMESPACE
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.namespace
+          image: registry.redhat.io/openshift4/ose-oauth-proxy:v4.10
+          imagePullPolicy: Always
+          livenessProbe:
+            failureThreshold: 3
+            httpGet:
+              path: /oauth/healthz
+              port: oauth-proxy
+              scheme: HTTPS
+            initialDelaySeconds: 30
+            periodSeconds: 5
+            successThreshold: 1
+            timeoutSeconds: 1
+          name: oauth-proxy
+          ports:
+            - containerPort: 8443
+              name: oauth-proxy
+              protocol: TCP
+          readinessProbe:
+            failureThreshold: 3
+            httpGet:
+              path: /oauth/healthz
+              port: oauth-proxy
+              scheme: HTTPS
+            initialDelaySeconds: 5
+            periodSeconds: 5
+            successThreshold: 1
+            timeoutSeconds: 1
+          resources:
+            limits:
+              cpu: 100m
+              memory: 64Mi
+            requests:
+              cpu: 100m
+              memory: 64Mi
+          volumeMounts:
+            - mountPath: /etc/oauth/config
+              name: oauth-config
+            - mountPath: /etc/tls/private
+              name: tls-certificates
+      enableServiceLinks: false
+      serviceAccountName: my-workbench
+      volumes:
+        - name: my-workbench
+          persistentVolumeClaim:
+            claimName: my-workbench
+        - emptyDir:
+            medium: Memory
+          name: shm
+        - name: oauth-config
+          secret:
+            defaultMode: 420
+            secretName: my-workbench-oauth-config  # pragma: allowlist secret
+        - name: tls-certificates
+          secret:
+            defaultMode: 420
+            secretName: my-workbench-tls  # pragma: allowlist secret

tests/workbenches/notebook-controller/test_data/notebook.yaml

@@ -0,0 +1,138 @@
+#
+# Copyright Skodjob authors.
+# License: Apache License 2.0 (see the file LICENSE or http://apache.org/licenses/LICENSE-2.0.html).
+#
+from __future__ import annotations
+
+import io
+import pathlib
+
+import kubernetes.client
+from kubernetes.dynamic import DynamicClient
+
+from ocp_resources.route import Route
+
+import pytest
+from pytest_testconfig import config as py_config
+
+from tests.workbenches.docs import TestDoc, SuiteDoc, Contact, Desc, Step
+from tests.workbenches.resources import Notebook
+from tests.workbenches.utils import step, PodUtils, OcpResourceManager
+from utilities import constants
+
+
+@SuiteDoc(
+    description=Desc("Verifies deployments of Notebooks via GitOps approach"),
+    before_test_steps={
+        Step(value="Deploy Pipelines Operator", expected="Pipelines operator is available on the cluster"),
+        Step(value="Deploy ServiceMesh Operator", expected="ServiceMesh operator is available on the cluster"),
+        Step(value="Deploy Serverless Operator", expected="Serverless operator is available on the cluster"),
+        Step(value="Install ODH operator", expected="Operator is up and running and is able to serve it's operands"),
+        Step(value="Deploy DSCI", expected="DSCI is created and ready"),
+        Step(value="Deploy DSC", expected="DSC is created and ready"),
+    },
+    after_test_steps={
+        Step(
+            value="Delete all created resources",
+            expected="All created resources are removed",
+        )
+    },
+)
+class TestNotebookST:
+    NTB_NAME: str = "test-odh-notebook"
+    NTB_NAMESPACE: str = "test-odh-notebook"
+
+    @pytest.mark.parametrize(
+        "users_namespace",
+        [
+            pytest.param(
+                {"name": NTB_NAMESPACE},
+            )
+        ],
+        indirect=True,
+    )
+    @pytest.mark.parametrize(
+        "users_persistent_volume_claim",
+        [
+            pytest.param(
+                {"name": NTB_NAME, "namespace": NTB_NAMESPACE},
+            )
+        ],
+        indirect=True,
+    )
+    @TestDoc(
+        description=Desc("Create simple Notebook with all needed resources and see if Operator creates it properly"),
+        contact=Contact(name="Jakub Stejskal", email="jstejska@redhat.com"),
+        steps={
+            Step(
+                value="Create namespace for Notebook resources with proper name, labels and annotations",
+                expected="Namespace is created",
+            ),
+            Step(value="Create PVC with proper labels and data for Notebook", expected="PVC is created"),
+            Step(
+                value="Create Notebook resource with Jupyter Minimal image in pre-defined namespace",
+                expected="Notebook resource is created",
+            ),
+            Step(
+                value="Wait for Notebook pods readiness",
+                expected="Notebook pods are up and running, Notebook is in ready state",
+            ),
+        },
+    )
+    def test_create_simple_notebook(
+        self, admin_client, unprivileged_client, users_namespace, users_persistent_volume_claim
+    ):
+        with OcpResourceManager() as test_frame:
+            with step("Create Notebook CR"):
+                notebook_image: str = _get_notebook_image("jupyter-minimal-notebook", "2024.2")
+                notebook = _load_default_notebook(
+                    client=unprivileged_client, namespace=self.NTB_NAMESPACE, name=self.NTB_NAME, image=notebook_image
+                )
+                test_frame.enter(resource=notebook)
+
+            with step("Wait for Notebook pod readiness"):
+                PodUtils.wait_for_pods_ready(
+                    client=admin_client,
+                    namespace_name=self.NTB_NAMESPACE,
+                    label_selector=f"app={self.NTB_NAME}",
+                    expect_pods_count=1,
+                )
+
+
+def _get_notebook_image(image_name: str, image_tag: str) -> str:
+    registry_path = "image-registry.openshift-image-registry.svc:5000"
+    controllers_namespace = py_config["applications_namespace"]
+    if py_config.get("distribution") == "upstream":
+        image_dict = {"jupyter-minimal-notebook": "jupyter-minimal-notebook"}
+    else:
+        image_dict = {"jupyter-minimal-notebook": "s2i-minimal-notebook"}
+    return registry_path + "/" + controllers_namespace + "/" + image_dict[image_name] + ":" + image_tag
+
+
+def _load_default_notebook(client: DynamicClient, namespace: str, name: str, image: str) -> Notebook:
+    notebook_string = (pathlib.Path(__file__).parent / "test_data/notebook.yaml").read_text()
+    notebook_string = notebook_string.replace("my-project", namespace).replace("my-workbench", name)
+    # Set new Route url
+    route_host: str = list(
+        Route.get(client=client, name=constants.Dashboard.route_name, namespace=py_config["applications_namespace"])
+    )[0].host
+    notebook_string = notebook_string.replace("odh_dashboard_route", "https://" + route_host)
+    # Set the correct username
+    username = _get_username(client=client)
+    notebook_string = notebook_string.replace("odh_user", username)
+    # Replace image
+    notebook_string = notebook_string.replace("notebook_image_placeholder", image)
+
+    nb = Notebook(yaml_file=io.StringIO(notebook_string))
+
+    return nb
+
+
+def _get_username(client: DynamicClient) -> str:
+    """Gets the username for the client (see kubectl -v8 auth whoami)"""
+    self_subject_review_resource: kubernetes.dynamic.Resource = client.resources.get(
+        api_version="authentication.k8s.io/v1", kind="SelfSubjectReview"
+    )
+    self_subject_review: kubernetes.dynamic.ResourceInstance = client.create(self_subject_review_resource)
+    username: str = self_subject_review.status.userInfo.username
+    return username

tests/workbenches/notebook-controller/test_spawning.py

@@ -0,0 +1,11 @@
+#
+# Copyright Skodjob authors.
+# License: Apache License 2.0 (see the file LICENSE or http://apache.org/licenses/LICENSE-2.0.html).
+#
+from __future__ import annotations
+
+from ocp_resources.resource import NamespacedResource
+
+
+class Notebook(NamespacedResource):
+    api_group: str = "kubeflow.org"