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

@@ -143,3 +143,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);
+  });
+});

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

@@ -0,0 +1,105 @@
+import * as _ from 'lodash';
+import { testName } from '@console/internal-integration-tests/protractor.conf';
+import { isLoaded, resourceTitle } from '@console/internal-integration-tests/views/crud.view';
+import { asyncForEach, createResource, deleteResource } from '@console/shared/src/test-utils/utils';
+import * as vmView from '../views/virtualMachine.view';
+import { getVMIManifest, basicVMConfig } from './utils/mocks';
+import { exposeServices } from './utils/utils';
+import { VirtualMachine } from './models/virtualMachine';
+import { TAB, VM_STATUS, NOT_AVAILABLE } from './utils/consts';
+import { NodePortService } from './utils/types';
+
+describe('Test VMI overview', () => {
+  const vmiName = `vmi-${testName}`;
+  const cloudInit = `#cloud-config\nuser: cloud-user\npassword: atomic\nchpasswd: {expire: False}`;
+  const serviceCommon = { name: vmiName, kind: 'vmi', type: 'NodePort', namespace: testName };
+  const testVMI = getVMIManifest('Container', testName, vmiName, cloudInit);
+  const vmi = new VirtualMachine(testVMI.metadata, 'virtualmachineinstances');
+  const nodePortServices = new Set<NodePortService>();
+  nodePortServices.add({
+    ...serviceCommon,
+    exposeName: `${vmiName}-service-ssh`,
+    port: '22',
+    targetPort: '20022',
+  });
+  nodePortServices.add({
+    ...serviceCommon,
+    exposeName: `${vmiName}-service-smtp`,
+    port: '25',
+    targetPort: '20025',
+  });
+  nodePortServices.add({
+    ...serviceCommon,
+    exposeName: `${vmiName}-service-http`,
+    port: '80',
+    targetPort: '20080',
+  });
+
+  beforeAll(async () => {
+    createResource(testVMI);
+    await vmi.waitForStatus(VM_STATUS.Running);
+
+    exposeServices(nodePortServices);
+  });
+
+  afterAll(() => {
+    deleteResource(testVMI);
+  });
+
+  beforeEach(async () => {
+    await vmi.navigateToTab(TAB.Details);
+    await isLoaded();
+  });
+
+  it('Check VMI details in overview', async () => {
+    const expectation = {
+      name: vmiName,
+      status: VM_STATUS.Running,
+      description: testName,
+      os: basicVMConfig.operatingSystem,
+      profile: basicVMConfig.workloadProfile,
+      bootOrderTexts: ['rootdisk (Disk)', 'nic0 (NIC)', 'cloudinitdisk (Disk)'],
+      flavorText: 'Tiny: 1 vCPU, 1 GiB Memory',
+    };
+
+    const found = {
+      name: await resourceTitle.getText(),
+      status: await vmi.getStatus(),
+      description: await vmView.vmDetailDesc(testName, vmiName).getText(),
+      os: await vmView.vmDetailOS(testName, vmiName).getText(),
+      profile: await vmView.vmDetailWorkloadProfile(testName, vmiName).getText(),
+      bootOrderTexts: await vmView.vmDetailBootOrder(testName, vmiName).getText(),
+      flavorText: await vmView.vmDetailFlavor(testName, vmiName).getText(),
+    };
+
+    const equal = _.isEqual(found, expectation);
+    if (!equal) {
+      // eslint-disable-next-line no-console
+      console.error(`Expected:\n${JSON.stringify(expectation)},\nGot:\n${JSON.stringify(found)}`);
+    }
+    expect(equal).toBe(true);
+
+    expect(await vmView.vmDetailIP(testName, vmiName).getText()).not.toEqual(NOT_AVAILABLE);
+    expect(
+      await vmView
+        .vmDetailPod(testName, vmiName)
+        .$('a')
+        .getText(),
+    ).toContain('virt-launcher');
+    expect(
+      await vmView
+        .vmDetailNode(testName, vmiName)
+        .$('a')
+        .getText(),
+    ).not.toEqual(NOT_AVAILABLE);
+  });
+
+  it('Check VMI services', async () => {
+    await asyncForEach(nodePortServices, async (srv) => {
+      expect(await vmView.vmDetailService(srv.exposeName).getText()).toEqual(srv.exposeName);
+      expect(await vmView.vmDetailService(srv.exposeName).getAttribute('href')).toContain(
+        `/k8s/ns/${testName}/services/${srv.exposeName}`,
+      );
+    });
+  });
+});