OCPBUGS-111698: Migrate app/ Cypress e2e tests to Playwright

frontend/e2e/pages/list-page.ts

@@ -151,6 +151,13 @@ export class ListPage extends BasePage {
     }
   }
 
+  async clickStatusButton(resourceName: string): Promise<void> {
+    const cell = this.getCell(resourceName);
+    const row = cell.locator('xpath=ancestor::tr');
+    const statusButton = row.getByTestId('popover-status-button');
+    await this.robustClick(statusButton, { timeout: 60_000 });
+  }
+
   async clickFirstRowLink(): Promise<void> {
     const firstLink = this.dataViewCells.first().locator('a').first();
     await this.robustClick(firstLink);

frontend/e2e/pages/yaml-editor-page.ts

@@ -12,8 +12,8 @@ export class YamlEditorPage extends BasePage {
   private readonly yamlError = this.page.getByTestId('yaml-error');
   private readonly resourceSidebar = this.page.getByTestId('resource-sidebar');
 
-  async navigateToImportYaml(): Promise<void> {
-    await this.goTo('/k8s/ns/default/import');
+  async navigateToImportYaml(namespace = 'default'): Promise<void> {
+    await this.goTo(`/k8s/ns/${namespace}/import`);
   }
 
   async waitForEditorReady(): Promise<void> {

frontend/e2e/tests/console/app/admission-webhook-warning-notifications.spec.ts

@@ -0,0 +1,186 @@
+import { test, expect } from '../../../fixtures';
+import { YamlEditorPage } from '../../../pages/yaml-editor-page';
+
+const POD_NAME = 'pod1';
+const DEPLOY_NAME = 'deploy1';
+const CONTAINER_NAME = 'container1';
+const WARNING_FOO = '299 - "[pod-must-have-label-foo] you must provide labels: {"foo"}"';
+const WARNING_BAR = '299 - "[deployment-must-have-label-bar] you must provide labels: {"bar"}"';
+const WARNING_ID = 'admission-webhook-warning';
+const LEARN_MORE_ID = 'admission-webhook-warning-learn-more';
+
+test.describe('Admission Webhook warning notification', () => {
+  let ns: string;
+
+  test.beforeAll(async ({ k8sClient }) => {
+    ns = `test-webhook-warn-${Date.now()}`;
+    await k8sClient.createNamespace(ns);
+  });
+
+  test.afterAll(async ({ k8sClient }) => {
+    await k8sClient.deleteNamespace(ns);
+  });
+
+  test('displays warning notification when creating a pod', async ({ page }) => {
+    const yamlEditorPage = new YamlEditorPage(page);
+
+    const podYaml = `apiVersion: v1
+kind: Pod
+metadata:
+  name: ${POD_NAME}-a
+  labels:
+    app: httpd
+  namespace: ${ns}
+spec:
+  securityContext:
+    runAsNonRoot: true
+    seccompProfile:
+      type: RuntimeDefault
+  containers:
+    - name: ${CONTAINER_NAME}
+      image: 'image-registry.openshift-image-registry.svc:5000/openshift/httpd:latest'
+      ports:
+        - containerPort: 8080
+      securityContext:
+        allowPrivilegeEscalation: false
+        capabilities:
+          drop:
+            - ALL`;
+
+    await yamlEditorPage.navigateToImportYaml(ns);
+    await yamlEditorPage.waitForEditorReady();
+    await yamlEditorPage.setEditorContent(podYaml);
+
+    await page.route(`**/api/kubernetes/api/v1/namespaces/${ns}/pods`, async (route) => {
+      if (route.request().method() === 'POST') {
+        const response = await route.fetch();
+        await route.fulfill({
+          response,
+          headers: { ...response.headers(), Warning: WARNING_FOO },
+        });
+      } else {
+        await route.continue();
+      }
+    });
+
+    await yamlEditorPage.clickSave();
+
+    await expect(page.getByTestId('section-heading-Pod details')).toBeVisible({ timeout: 30_000 });
+    const warning = page.getByTestId(WARNING_ID);
+    await expect(warning).toContainText('Admission Webhook Warning', { timeout: 10_000 });
+    await expect(warning).toContainText(
+      `Pod ${POD_NAME}-a violates policy ${WARNING_FOO}`,
+    );
+    await expect(page.getByTestId(LEARN_MORE_ID)).toContainText('Learn more');
+    await page.getByTestId(LEARN_MORE_ID).click();
+  });
+
+  test('displays warning notifications when creating bulk resources', async ({ page }) => {
+    const yamlEditorPage = new YamlEditorPage(page);
+
+    const bulkYaml = `apiVersion: v1
+kind: Pod
+metadata:
+  name: ${POD_NAME}-b
+  labels:
+    app: httpd
+  namespace: ${ns}
+spec:
+  securityContext:
+    runAsNonRoot: true
+    seccompProfile:
+      type: RuntimeDefault
+  containers:
+    - name: ${CONTAINER_NAME}
+      image: 'image-registry.openshift-image-registry.svc:5000/openshift/httpd:latest'
+      ports:
+        - containerPort: 8080
+      securityContext:
+        allowPrivilegeEscalation: false
+        capabilities:
+          drop:
+            - ALL
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${DEPLOY_NAME}
+  namespace: ${ns}
+spec:
+  selector:
+    matchLabels:
+      app: deploy1
+  replicas: 3
+  template:
+    metadata:
+      labels:
+        app: deploy1
+    spec:
+      containers:
+        - name: ${CONTAINER_NAME}
+          image: >-
+            image-registry.openshift-image-registry.svc:5000/openshift/httpd:latest
+          ports:
+            - containerPort: 8080
+              protocol: TCP
+          env:
+            - name: app
+              value: frontennd
+      imagePullSecrets: []
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxSurge: 25%
+      maxUnavailable: 25%
+  paused: false`;
+
+    await yamlEditorPage.navigateToImportYaml(ns);
+    await yamlEditorPage.waitForEditorReady();
+    await yamlEditorPage.setEditorContent(bulkYaml);
+
+    await page.route(`**/api/kubernetes/api/v1/namespaces/${ns}/pods`, async (route) => {
+      if (route.request().method() === 'POST') {
+        const response = await route.fetch();
+        await route.fulfill({
+          response,
+          headers: { ...response.headers(), Warning: WARNING_FOO },
+        });
+      } else {
+        await route.continue();
+      }
+    });
+
+    await page.route(
+      `**/api/kubernetes/apis/apps/v1/namespaces/${ns}/deployments`,
+      async (route) => {
+        if (route.request().method() === 'POST') {
+          const response = await route.fetch();
+          await route.fulfill({
+            response,
+            headers: { ...response.headers(), Warning: WARNING_BAR },
+          });
+        } else {
+          await route.continue();
+        }
+      },
+    );
+
+    await yamlEditorPage.clickSave();
+
+    await expect(page.getByTestId('resources-successfully-created')).toContainText(
+      'Resources successfully created',
+      { timeout: 30_000 },
+    );
+    const warning = page.getByTestId(WARNING_ID);
+    await expect(warning).toHaveCount(2, { timeout: 10_000 });
+    await expect(warning.first()).toContainText('Admission Webhook Warning');
+    await expect(
+      warning.filter({ hasText: `Pod ${POD_NAME}-b violates policy ${WARNING_FOO}` }),
+    ).toBeVisible();
+    await expect(
+      warning.filter({ hasText: `Deployment ${DEPLOY_NAME} violates policy ${WARNING_BAR}` }),
+    ).toBeVisible();
+    await expect(page.getByTestId(LEARN_MORE_ID).first()).toContainText('Learn more');
+    await page.getByTestId(LEARN_MORE_ID).first().click();
+  });
+});

frontend/e2e/tests/console/app/auth-multiuser-login.spec.ts

@@ -0,0 +1,105 @@
+import { test, expect } from '../../../fixtures';
+import { performLogin } from '../../../setup/login-helper';
+
+const KUBEADMIN_IDP = 'kube:admin';
+const KUBEADMIN_USERNAME = 'kubeadmin';
+
+test.describe('Auth test', () => {
+  test.use({ storageState: { cookies: [], origins: [] } });
+
+  test('logs in as test user via htpasswd identity provider', async ({ page }) => {
+    const htpasswdPassword = process.env.BRIDGE_HTPASSWD_PASSWORD;
+    const idp = process.env.BRIDGE_HTPASSWD_IDP || 'test';
+    const username = process.env.BRIDGE_HTPASSWD_USERNAME || 'test';
+    const baseURL = process.env.WEB_CONSOLE_URL || 'http://localhost:9000';
+
+    test.skip(!htpasswdPassword, 'BRIDGE_HTPASSWD_PASSWORD not set');
+
+    await performLogin(page, baseURL, username, htpasswdPassword, idp);
+    await expect(page).toHaveURL(new RegExp(baseURL.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), {
+      timeout: 30_000,
+    });
+
+    await test.step('Verify username is displayed', async () => {
+      await expect(page.getByTestId('user-dropdown-toggle')).toHaveText(username, {
+        timeout: 30_000,
+      });
+    });
+
+    await test.step('Switch to Admin perspective', async () => {
+      const toggle = page.getByTestId('perspective-switcher-toggle');
+      await toggle.click();
+      const adminOption = page
+        .getByTestId('perspective-switcher-menu-option')
+        .filter({ hasText: 'Core platform' });
+      await adminOption.click();
+      await expect(toggle).toContainText('Core platform', { timeout: 30_000 });
+    });
+
+    await test.step('Verify restricted admin nav items are not visible', async () => {
+      const sidebar = page.locator('#page-sidebar');
+      await expect(sidebar).toBeVisible({ timeout: 30_000 });
+
+      for (const section of ['Compute', 'Monitoring']) {
+        await expect(sidebar.getByRole('button', { name: section })).not.toBeAttached({
+          timeout: 30_000,
+        });
+      }
+
+      for (const link of [
+        'Cluster Status',
+        'Cluster Settings',
+        'Namespaces',
+        'Custom Resource Definitions',
+        'Software Catalog',
+        'Persistent Volumes',
+      ]) {
+        await expect(sidebar.getByRole('link', { name: link })).not.toBeAttached();
+      }
+    });
+  });
+
+  test('logs in as kubeadmin user', async ({ page }) => {
+    const kubeadminPassword = process.env.BRIDGE_KUBEADMIN_PASSWORD;
+    const baseURL = process.env.WEB_CONSOLE_URL || 'http://localhost:9000';
+
+    test.skip(!kubeadminPassword, 'BRIDGE_KUBEADMIN_PASSWORD not set');
+
+    await performLogin(page, baseURL, KUBEADMIN_USERNAME, kubeadminPassword!, KUBEADMIN_IDP);
+    await expect(page.getByTestId('loading-indicator')).not.toBeAttached({ timeout: 30_000 });
+
+    await test.step('Verify kubeadmin username', async () => {
+      await expect(page.getByTestId('user-dropdown-toggle')).toHaveText(KUBEADMIN_IDP, {
+        timeout: 30_000,
+      });
+    });
+
+    await test.step('Verify temporary admin notification', async () => {
+      await expect(page.getByTestId('global-notifications')).toContainText(
+        'You are logged in as a temporary administrative user',
+        { timeout: 30_000 },
+      );
+    });
+
+    await test.step('Verify Admin perspective and nav sections', async () => {
+      const toggle = page.getByTestId('perspective-switcher-toggle');
+      await expect(toggle).toContainText('Core platform', { timeout: 30_000 });
+
+      const sidebar = page.locator('#page-sidebar');
+      await expect(sidebar.getByRole('button', { name: 'Compute' })).toBeVisible({
+        timeout: 30_000,
+      });
+      await expect(sidebar.getByRole('button', { name: 'Administration' })).toBeVisible();
+    });
+
+    await test.step('Navigate to Cluster Settings', async () => {
+      const sidebar = page.locator('#page-sidebar');
+      const adminSection = sidebar.getByRole('button', { name: 'Administration' });
+      await adminSection.click();
+      await sidebar.getByRole('link', { name: 'Cluster Settings' }).click();
+      await expect(page.getByTestId('cluster-settings-page-heading')).toBeVisible({
+        timeout: 30_000,
+      });
+    });
+  });
+});