Cypress e2e Test - Verify Non Admin Can Serve And Query A Model Using The UI

frontend/src/__tests__/cypress/cypress/fixtures/e2e/dataScienceProjects/testSingleModelContributorCreation.yaml

@@ -0,0 +1,5 @@
+# testSingleModelContributorCreation.cy.ts Test Data #
+projectSingleModelDisplayName: "Cypress Single Model Test Project"
+projectSingleModelResourceName: "cypress-single-model-test-project" 
+singleModelName: "cypress-single-model"
+modelFilePath: "flan-t5-small/flan-t5-small-caikit"

frontend/src/__tests__/cypress/cypress/fixtures/resources/yaml/data_connection_model_serving.yaml

@@ -0,0 +1,18 @@
+kind: Secret
+apiVersion: v1
+metadata:
+  name: aws-connection-ods-ci-wisdom
+  namespace: {{NAMESPACE}}
+  labels:
+    opendatahub.io/dashboard: 'true'
+    opendatahub.io/managed: 'true'
+  annotations:
+    opendatahub.io/connection-type: s3
+    openshift.io/display-name: ods-ci-wisdom
+data:
+  AWS_ACCESS_KEY_ID: {{AWS_ACCESS_KEY_ID}}
+  AWS_DEFAULT_REGION: {{AWS_DEFAULT_REGION}}
+  AWS_S3_BUCKET: {{AWS_S3_BUCKET}}
+  AWS_S3_ENDPOINT: {{AWS_S3_ENDPOINT}}
+  AWS_SECRET_ACCESS_KEY: {{AWS_SECRET_ACCESS_KEY}}
+type: Opaque

frontend/src/__tests__/cypress/cypress/pages/modelServing.ts

@@ -52,6 +52,10 @@ class ModelServingGlobal {
     return cy.findByTestId('empty-state-action-button');
   }
 
+  findSingleServingModelButton() {
+    return cy.findByTestId('single-serving-select-button');
+  }
+
   private findModelsTable() {
     // TODO be more precise
     return cy.findByTestId('inference-service-table');
@@ -65,6 +69,10 @@ class ModelServingGlobal {
     return this.findModelsTable().findByTestId(`metrics-link-${name}`);
   }
 
+  findStatusTooltip() {
+    return cy.findByTestId('status-tooltip');
+  }
+
   findEmptyResults() {
     return cy.findByTestId('dashboard-empty-table-state');
   }
@@ -97,6 +105,18 @@ class InferenceServiceModal extends Modal {
     return this.find().findByTestId('inference-service-model-selection');
   }
 
+  findServingRuntimeTemplate() {
+    return this.find().findByTestId('serving-runtime-template-selection');
+  }
+
+  findCalkitStandaloneServingRuntime() {
+    return this.find().findByTestId('caikit-standalone-runtime');
+  }
+
+  findCalkitTGISServingRuntime() {
+    return this.find().findByTestId('caikit-tgis-runtime');
+  }
+
   findModelFrameworkSelect() {
     return this.find().findByTestId('inference-service-framework-selection');
   }
@@ -184,6 +204,10 @@ class InferenceServiceModal extends Modal {
   findServingRuntimeEnvVarsValue(value: string) {
     return this.find().findByTestId(`serving-runtime-environment-variables-input-value ${value}`);
   }
+
+  findCreatedModel(name: string) {
+    return this.find().findByTestId(`metrics-link-${name}`);
+  }
 }
 
 class ServingRuntimeModal extends Modal {
@@ -402,6 +426,14 @@ class ModelServingSection {
     return this.find().findByTestId('serving-runtime-table');
   }
 
+  findModelServerName(name: string) {
+    return this.find().findByTestId(`metrics-link-${name}`);
+  }
+
+  findStatusTooltip() {
+    return this.find().findByTestId('status-tooltip');
+  }
+
   findKServeTableHeaderButton(name: string) {
     return this.findKServeTable().find('thead').findByRole('button', { name });
   }

frontend/src/__tests__/cypress/cypress/tests/e2e/dashboardNavigation/testManifestLinks.cy.ts

@@ -1,7 +1,7 @@
 import * as yaml from 'js-yaml';
 import { isUrlExcluded } from '~/__tests__/cypress/cypress/utils/urlExtractor';
 
-describe('Verify that all the URLs referenced in the Manifest directory are operational', () => {
+describe('[Known Bug: RHOAIENG-9235] Verify that all the URLs referenced in the Manifest directory are operational', () => {
   let excludedSubstrings: string[];
 
   // Setup: Load test data

frontend/src/__tests__/cypress/cypress/tests/e2e/dataSciencePipelines/createRunDeletePipelineCustomPipMirror.cy.ts

@@ -21,10 +21,11 @@ const projectName = 'test-dsp-custom-pip-prj';
 const dspaSecretName = 'test-custom-pip-dspa-secret';
 const testPipelineIrisName = 'test-iris-pipeline';
 const testRunName = 'test-pipelines-run';
+const awsBucket = 'BUCKET_2' as const;
 
 describe('An admin user can import and run a pipeline', { testIsolation: false }, () => {
   before(() => {
-    provisionProjectForPipelines(projectName, dspaSecretName);
+    provisionProjectForPipelines(projectName, dspaSecretName, awsBucket);
     //Create Pipelines ConfigMap With Custom Pip Index Url And Trusted Host
     createOpenShiftConfigMap('ds-pipeline-custom-env-vars', projectName, {
       // The following lines should be snake case

frontend/src/__tests__/cypress/cypress/tests/e2e/dataSciencePipelines/pipelines.cy.ts

@@ -13,11 +13,12 @@ const projectName = 'test-pipelines-prj';
 const dspaSecretName = 'dashboard-dspa-secret';
 const testPipelineName = 'test-pipelines-pipeline';
 const testRunName = 'test-pipelines-run';
+const awsBucket = 'BUCKET_3' as const;
 
 describe('An admin user can import and run a pipeline', { testIsolation: false }, () => {
   before(() => {
     // Create a Project for pipelines
-    provisionProjectForPipelines(projectName, dspaSecretName);
+    provisionProjectForPipelines(projectName, dspaSecretName, awsBucket);
   });
 
   after(() => {

frontend/src/__tests__/cypress/cypress/tests/e2e/dataScienceProjects/models/testSingleModelContributorCreation.cy.ts

@@ -0,0 +1,104 @@
+import type { DataScienceProjectData } from '~/__tests__/cypress/cypress/types';
+import {
+  addUserToProject,
+  deleteOpenShiftProject,
+} from '~/__tests__/cypress/cypress/utils/oc_commands/project';
+import { loadDSPFixture } from '~/__tests__/cypress/cypress/utils/dataLoader';
+import { LDAP_CONTRIBUTOR_USER } from '~/__tests__/cypress/cypress/utils/e2eUsers';
+import { projectListPage, projectDetails } from '~/__tests__/cypress/cypress/pages/projects';
+import {
+  modelServingGlobal,
+  inferenceServiceModal,
+  modelServingSection,
+} from '~/__tests__/cypress/cypress/pages/modelServing';
+import {
+  checkInferenceServiceState,
+  provisionProjectForModelServing,
+} from '~/__tests__/cypress/cypress/utils/oc_commands/modelServing';
+
+let testData: DataScienceProjectData;
+let projectName: string;
+let contributor: string;
+let modelName: string;
+let modelFilePath: string;
+const awsBucket = 'BUCKET_3' as const;
+
+describe('Verify Model Creation and Validation using the UI', () => {
+  before(() => {
+    Cypress.on('uncaught:exception', (err) => {
+      if (err.message.includes('Error: secrets "ds-pipeline-config" already exists')) {
+        return false;
+      }
+      return true;
+    });
+    // Setup: Load test data and ensure clean state
+    return loadDSPFixture('e2e/dataScienceProjects/testSingleModelContributorCreation.yaml').then(
+      (fixtureData: DataScienceProjectData) => {
+        testData = fixtureData;
+        projectName = testData.projectSingleModelResourceName;
+        contributor = LDAP_CONTRIBUTOR_USER.USERNAME;
+        modelName = testData.singleModelName;
+        modelFilePath = testData.modelFilePath;
+
+        if (!projectName) {
+          throw new Error('Project name is undefined or empty in the loaded fixture');
+        }
+        cy.log(`Loaded project name: ${projectName}`);
+        // Create a Project for pipelines
+        provisionProjectForModelServing(
+          projectName,
+          awsBucket,
+          'resources/yaml/data_connection_model_serving.yaml',
+        );
+        addUserToProject(projectName, contributor, 'edit');
+      },
+    );
+  });
+  after(() => {
+    // Delete provisioned Project - 5 min timeout to accomadate increased time to delete a project with a model
+    deleteOpenShiftProject(projectName, { timeout: 300000 });
+  });
+
+  it(
+    'Verify that a Non Admin can Serve and Query a Model using the UI',
+    { tags: ['@Smoke', '@SmokeSet2', '@ODS-2552', '@Dashboard'] },
+    () => {
+      cy.log('Model Name:', modelName);
+      // Authentication and navigation
+      cy.step(`Log into the application with ${LDAP_CONTRIBUTOR_USER.USERNAME}`);
+      cy.visitWithLogin('/', LDAP_CONTRIBUTOR_USER);
+
+      // Project navigation, add user and provide contributor permissions
+      cy.step(
+        `Navigate to the Project list tab and search for ${testData.projectSingleModelResourceName}`,
+      );
+      projectListPage.navigate();
+      projectListPage.filterProjectByName(testData.projectSingleModelResourceName);
+      projectListPage.findProjectLink(testData.projectSingleModelResourceName).click();
+
+      // Navigate to Model Serving tab and Deploy a Single Model
+      cy.step('Navigate to Model Serving and click to Deploy a Single Model');
+      projectDetails.findSectionTab('model-server').click();
+      modelServingGlobal.findSingleServingModelButton().click();
+      modelServingGlobal.findDeployModelButton().click();
+
+      // Launch a Single Serving Model and select the required entries
+      cy.step('Launch a Single Serving Model using Caikit TGIS ServingRuntime for KServe');
+      inferenceServiceModal.findModelNameInput().type(testData.singleModelName);
+      inferenceServiceModal.findServingRuntimeTemplate().click();
+      inferenceServiceModal.findCalkitTGISServingRuntime().click();
+
+      inferenceServiceModal.findLocationPathInput().type(modelFilePath);
+      inferenceServiceModal.findSubmitButton().click();
+
+      //Verify the model created
+      cy.step('Verify that the Model is created Successfully on the backend and frontend');
+      checkInferenceServiceState(testData.singleModelName);
+      modelServingSection.findModelServerName(testData.singleModelName);
+      // Note reload is required as status tooltip was not found due to a stale element
+      cy.reload();
+      modelServingSection.findStatusTooltip().click({ force: true });
+      cy.contains('Loaded', { timeout: 120000 }).should('be.visible');
+    },
+  );
+});

frontend/src/__tests__/cypress/cypress/types.ts

@@ -36,6 +36,7 @@ export type AWSS3Buckets = {
   AWS_ACCESS_KEY_ID: string;
   AWS_SECRET_ACCESS_KEY: string;
   BUCKET_2: AWSS3BucketDetails;
+  BUCKET_3: AWSS3BucketDetails;
 };
 
 export type DataConnectionReplacements = {
@@ -118,6 +119,10 @@ export type DataScienceProjectData = {
   projectEditDescription: string;
   projectEditResourceName: string;
   projectEditUpdatedName: string;
+  projectSingleModelDisplayName: string;
+  projectSingleModelResourceName: string;
+  singleModelName: string;
+  modelFilePath: string;
 };
 
 export type NotebookImageData = {

frontend/src/__tests__/cypress/cypress/utils/oc_commands/dataConnection.ts

@@ -25,6 +25,8 @@ export const createDataConnection = (
 ): Cypress.Chainable<CommandLineResult> => {
   return cy.fixture(yamlFilePath).then((yamlContent) => {
     const modifiedYamlContent = replacePlaceholdersInYaml(yamlContent, dataConnectionReplacements);
+
+    cy.log(`Yaml:${modifiedYamlContent}`);
     return applyOpenShiftYaml(modifiedYamlContent);
   });
 };

frontend/src/__tests__/cypress/cypress/utils/oc_commands/modelServing.ts

@@ -0,0 +1,79 @@
+/* eslint-disable cypress/no-unnecessary-waiting */
+import { createDataConnection } from '~/__tests__/cypress/cypress/utils/oc_commands/dataConnection';
+import { AWS_BUCKETS } from '~/__tests__/cypress/cypress/utils/s3Buckets';
+import type { DataConnectionReplacements } from '~/__tests__/cypress/cypress/types';
+import { createCleanProject } from '~/__tests__/cypress/cypress/utils/projectChecker';
+
+/**
+ * Provision (using oc) a Project in order to make it usable with model seving
+ * (creates a Data Connection also)
+ *
+ * @param projectName Project Name
+ * @param bucketKey AWS Bucket
+ * @param customDataConnectionYamlPath DC Yaml Value
+ */
+export const provisionProjectForModelServing = (
+  projectName: string,
+  bucketKey: 'BUCKET_2' | 'BUCKET_3',
+  customDataConnectionYamlPath?: string,
+): void => {
+  cy.log(`Provisioning project with bucket key: ${bucketKey}`);
+
+  const bucketConfig = AWS_BUCKETS[bucketKey];
+
+  // Provision a Project
+  createCleanProject(projectName);
+
+  // Create a pipeline-compatible Data Connection
+  const dataConnectionReplacements: DataConnectionReplacements = {
+    NAMESPACE: projectName,
+    AWS_ACCESS_KEY_ID: Buffer.from(AWS_BUCKETS.AWS_ACCESS_KEY_ID).toString('base64'),
+    AWS_DEFAULT_REGION: Buffer.from(bucketConfig.REGION).toString('base64'),
+    AWS_S3_BUCKET: Buffer.from(bucketConfig.NAME).toString('base64'),
+    AWS_S3_ENDPOINT: Buffer.from(bucketConfig.ENDPOINT).toString('base64'),
+    AWS_SECRET_ACCESS_KEY: Buffer.from(AWS_BUCKETS.AWS_SECRET_ACCESS_KEY).toString('base64'),
+  };
+  createDataConnection(dataConnectionReplacements, customDataConnectionYamlPath);
+};
+
+/**
+ * Check InferenceService active model state
+ *
+ *
+ * @param serviceName InferenceService name
+ * @returns Result Object of the operation
+ */
+export const checkInferenceServiceState = (
+  serviceName: string,
+): Cypress.Chainable<Cypress.Exec> => {
+  const ocCommand = `oc get inferenceService ${serviceName} -o json | grep activeModelState`;
+  const maxAttempts = 60; // 5 minutes / 5 seconds = 60 attempts
+  let attempts = 0;
+
+  const checkState = (): Cypress.Chainable<Cypress.Exec> => {
+    return cy.exec(ocCommand, { failOnNonZeroExit: false }).then((result) => {
+      attempts++;
+
+      // Use cy.log for both Cypress logging and console output
+      cy.log(`🧐 Attempt ${attempts}: Checking InferenceService state
+          Command: ${ocCommand}
+          Output: ${result.stdout}`);
+
+      if (result.stdout.includes('"activeModelState": "Loaded"')) {
+        cy.log(
+          `✅ InferenceService ${serviceName} is in "Loaded" state after ${attempts} attempts`,
+        );
+        return cy.wrap(result);
+      }
+      if (attempts >= maxAttempts) {
+        const errorMessage = `❌ InferenceService ${serviceName} did not reach "Loaded" state within 5 minutes`;
+        cy.log(errorMessage);
+        throw new Error(errorMessage);
+      } else {
+        return cy.wait(5000).then(() => checkState());
+      }
+    });
+  };
+
+  return checkState();
+};

frontend/src/__tests__/cypress/cypress/utils/oc_commands/project.ts

@@ -35,17 +35,21 @@ export const createOpenShiftProject = (
  */
 export const deleteOpenShiftProject = (
   projectName: string,
+  options: { timeout?: number } = {},
 ): Cypress.Chainable<CommandLineResult> => {
+  const { timeout } = options;
   const ocCommand = `oc delete project ${projectName}`;
-  return cy.exec(ocCommand, { failOnNonZeroExit: false }).then((result) => {
-    if (result.code !== 0) {
-      cy.log(`ERROR deleting ${projectName} Project
+  return cy
+    .exec(ocCommand, { failOnNonZeroExit: false, ...(timeout && { timeout }) })
+    .then((result) => {
+      if (result.code !== 0) {
+        cy.log(`ERROR deleting ${projectName} Project
                 stdout: ${result.stdout}
                 stderr: ${result.stderr}`);
-      throw new Error(`Command failed with code ${result.code}`);
-    }
-    return result;
-  });
+        throw new Error(`Command failed with code ${result.code}`);
+      }
+      return result;
+    });
 };
 
 /**