add dashboard tests

frontend/packages/kubevirt-plugin/integration-tests/tests/models/virtualMachine.ts

@@ -19,11 +19,13 @@ import {
   VM_ACTIONS_TIMEOUT_SECS,
   VM_STOP_TIMEOUT_SECS,
   VM_STATUS,
+  VMI_ACTION,
 } from '../utils/consts';
 import { detailViewAction, listViewAction } from '../../views/vm.actions.view';
 import { nameInput as cloneDialogNameInput } from '../../views/dialogs/cloneVirtualMachineDialog.view';
 import { ProvisionConfigName } from '../utils/constants/wizard';
 import { Wizard } from './wizard';
+import { appHost, testName } from '@console/internal-integration-tests/protractor.conf';
 import { KubevirtDetailView } from './kubevirtDetailView';
 import { ImportWizard } from './importWizard';
 
@@ -44,11 +46,11 @@ export class VirtualMachine extends KubevirtDetailView {
     return vmView.vmDetailBootOrder(this.namespace, this.name).getText();
   }
 
-  async action(action: VM_ACTION, waitForAction?: boolean, timeout?: number) {
+  async action(action: VM_ACTION | VMI_ACTION, waitForAction?: boolean, timeout?: number) {
     await this.navigateToTab(TAB.Details);
 
     let confirmDialog = true;
-    if ([VM_ACTION.Clone].includes(action)) {
+    if (VM_ACTION.Clone === action) {
       confirmDialog = false;
     }
 
@@ -58,6 +60,16 @@ export class VirtualMachine extends KubevirtDetailView {
     }
   }
 
+  async navigateToListView() {
+    const vmsListUrl = (namespace) =>
+      `${appHost}/k8s/${namespace === 'all-namespaces' ? '' : 'ns/'}${namespace}/virtualmachines`;
+    const currentUrl = await browser.getCurrentUrl();
+    if (![vmsListUrl(testName), vmsListUrl('all-namespaces')].includes(currentUrl)) {
+      await browser.get(vmsListUrl(this.namespace));
+      await isLoaded();
+    }
+  }
+
   async listViewAction(action: string, waitForAction?: boolean, timeout?: number) {
     await this.navigateToListView();
 

frontend/packages/kubevirt-plugin/integration-tests/tests/utils/consts.ts

@@ -140,3 +140,9 @@ export const diskTabCol = {
   storageClass: 4,
 };
 Object.freeze(diskTabCol);
+
+export enum VMI_ACTION {
+  Delete = 'Delete Virtual Machine Instance',
+  EditAnnotations = 'Edit Annotations',
+  EditLabels = 'Edit Labels',
+}

frontend/packages/kubevirt-plugin/integration-tests/tests/vmi.actions.scenario.ts

@@ -0,0 +1,96 @@
+import { browser, ExpectedConditions as until } from 'protractor';
+import { testName } from '@console/internal-integration-tests/protractor.conf';
+import {
+  resourceRows,
+  resourceRowsPresent,
+  isLoaded,
+  textFilter,
+} from '@console/internal-integration-tests/views/crud.view';
+import {
+  addLeakableResource,
+  createResource,
+  removeLeakedResources,
+  removeLeakableResource,
+  waitForCount,
+} from '@console/shared/src/test-utils/utils';
+import { getVMIManifest } from './utils/mocks';
+import { fillInput } from './utils/utils';
+import {
+  PAGE_LOAD_TIMEOUT_SECS,
+  VMI_ACTION,
+  TAB,
+  VM_IMPORT_TIMEOUT_SECS,
+  VM_STATUS,
+} from './utils/consts';
+import { VirtualMachine } from './models/virtualMachine';
+
+const waitForVM = async (
+  manifest: any,
+  status: VM_STATUS,
+  resourcesSet: Set<string>,
+  kind?: 'virtualmachines' | 'virtualmachineinstances',
+) => {
+  const vm = new VirtualMachine(manifest.metadata, kind || 'virtualmachines');
+
+  createResource(manifest);
+  addLeakableResource(resourcesSet, manifest);
+  await vm.waitForStatus(status);
+
+  return vm;
+};
+
+const waitForVMDelete = async (vm: VirtualMachine) => {
+  await vm.navigateToListView();
+  await isLoaded();
+
+  await fillInput(textFilter, vm.name);
+  await resourceRowsPresent();
+
+  await browser.wait(until.and(waitForCount(resourceRows, 0)), PAGE_LOAD_TIMEOUT_SECS);
+};
+
+describe('Test VMI actions', () => {
+  const leakedResources = new Set<string>();
+
+  afterAll(async () => {
+    removeLeakedResources(leakedResources);
+  });
+
+  describe('Test VMI list view kebab dropdown', () => {
+    let vm: VirtualMachine;
+    let testVM: any;
+
+    beforeAll(async () => {
+      testVM = getVMIManifest('Container', testName, `vm-list-actions-${testName}`);
+      vm = await waitForVM(testVM, VM_STATUS.Running, leakedResources, 'virtualmachineinstances');
+    }, VM_IMPORT_TIMEOUT_SECS);
+
+    it('Deletes VMI', async () => {
+      await vm.navigateToListView();
+      await isLoaded();
+
+      await vm.listViewAction(VMI_ACTION.Delete, false);
+      removeLeakableResource(leakedResources, testVM);
+      await waitForVMDelete(vm);
+    });
+  });
+
+  describe('Test VMI detail view actions dropdown', () => {
+    let vm: VirtualMachine;
+    let testVM: any;
+
+    beforeAll(async () => {
+      testVM = getVMIManifest('Container', testName, `vm-detail-actions-${testName}`);
+      vm = await waitForVM(testVM, VM_STATUS.Running, leakedResources, 'virtualmachineinstances');
+    }, VM_IMPORT_TIMEOUT_SECS);
+
+    it('Deletes VM', async () => {
+      await vm.navigateToTab(TAB.Details);
+      await isLoaded();
+
+      await vm.action(VMI_ACTION.Delete, false);
+      removeLeakableResource(leakedResources, testVM);
+      await waitForVMDelete(vm);
+    });
+  });
+});

frontend/packages/kubevirt-plugin/integration-tests/tests/vmi.dashboard.scenario.ts

@@ -0,0 +1,74 @@
+import { testName } from '@console/internal-integration-tests/protractor.conf';
+import {
+  addLeakableResource,
+  removeLeakedResources,
+  createResource,
+} from '@console/shared/src/test-utils/utils';
+import { VirtualMachineInstanceModel } from '../../src/models';
+import {
+  vmDetailsName,
+  vmDetailsNamespace,
+  vmDetailsNode,
+  vmDetailsIPAddress,
+  vmStatus,
+  vmInventoryNICs,
+  vmInventoryDisks,
+} from '../views/dashboard.view';
+import { getVMIManifest } from './utils/mocks';
+import { VirtualMachine } from './models/virtualMachine';
+import { VM_STATUS, NOT_AVAILABLE } from './utils/consts';
+
+const waitForVM = async (
+  manifest: any,
+  status: VM_STATUS,
+  resourcesSet: Set<string>,
+  kind?: 'virtualmachines' | 'virtualmachineinstances',
+) => {
+  const vm = new VirtualMachine(manifest.metadata, kind || 'virtualmachines');
+
+  createResource(manifest);
+  addLeakableResource(resourcesSet, manifest);
+  await vm.waitForStatus(status);
+
+  return vm;
+};
+
+describe('Test VMI dashboard', () => {
+  const leakedResources = new Set<string>();
+  const testVM = getVMIManifest('Container', testName);
+
+  let vm: VirtualMachine;
+
+  afterAll(async () => {
+    removeLeakedResources(leakedResources);
+  });
+
+  beforeAll(async () => {
+    vm = await waitForVM(testVM, VM_STATUS.Running, leakedResources, 'virtualmachineinstances');
+    await vm.navigateToDashboard();
+  });
+
+  it('Inventory card', async () => {
+    expect(vmInventoryNICs.getText()).toEqual('1 NIC');
+    expect(vmInventoryNICs.$('a').getAttribute('href')).toMatch(
+      new RegExp(`.*/k8s/ns/${vm.namespace}/${VirtualMachineInstanceModel.plural}/${vm.name}/nics`),
+    );
+    expect(vmInventoryDisks.getText()).toEqual('1 Disk');
+    expect(vmInventoryDisks.$('a').getAttribute('href')).toMatch(
+      new RegExp(
+        `.*/k8s/ns/${vm.namespace}/${VirtualMachineInstanceModel.plural}/${vm.name}/disks`,
+      ),
+    );
+  });
+
+  it('Status card', async () => {
+    expect(vmStatus.getText()).toEqual(VM_STATUS.Running);
+  });
+
+  it('Details card', async () => {
+    expect(vmDetailsName.getText()).toEqual(vm.name);
+    expect(vmDetailsNamespace.getText()).toEqual(vm.namespace);
+    expect(vmDetailsNode.getText()).not.toEqual(NOT_AVAILABLE);
+    expect(vmDetailsIPAddress.getText()).not.toEqual(NOT_AVAILABLE);
+  });
+});