mirror of
https://github.com/harvester/harvester-ui-extension.git
synced 2026-11-22 00:27:38 +08:00
* feat: page the VM list on the server when the API supports it On clusters whose API serves lists from the Steve SQL cache, the VM list uses PaginatedResourceTable: it loads one page of VMs, and the VMIs, pods, PVCs, PVs, migrations, restores and backups of those VMs only. Sorting, search and the namespace filter run on the server, so CPU, memory, IP and node can't be sorted or searched there. The feature is gated by the vmListPagination feature flag and enabled for the VM list only, through a pagination context. Older clusters keep the current list. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * feat: enable the VM list pagination from v1.10.0 The backend change that serves API lists from the SQL cache has to be on the v1.10 branch before this is merged. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * fix: keep the paged VM list when adding a volume The Add Volume dialog loaded every VM to find the volumes in use, which replaced the page the VM list keeps in the store and emptied the list. When the list is paged, the dialog now reads only the VMs of the namespace and doesn't store them. The requests for the resources of a page use one IN filter instead of one filter per value, which keeps the URLs about a third as long. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * fix: keep the paged VM list intact in its dialogs and on older APIs The Add Volume, Storage Migration and Restore dialogs read the VMs, PVCs and backups of the VM's namespace through the VM. While the list keeps a page of a type in the store they read the namespace without storing it, so the list keeps its page and the dialogs' own lists don't shrink when the page reloads. Storage Migration no longer offers volumes of VMs on other pages as targets. The list is paged only when the API lists the VM's printer columns as metadata.fields, which the SQL cache does, so a missing or non-semver server version can't turn it on against an API that can't filter. One failed request for a page's resources no longer stops the others. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * fix: show the restart notice only when its VMs change The list rebuilds the names of the VMs that need a restart on every refresh, and when it pages also on every page, sort and search, so the notice popped up again each time even when nothing new needed a restart. Show it only when the set of VMs changes. While paging it still covers only the VMs on the current page: the API can't filter VMs by their RestartRequired condition. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * fix: find the launcher pods of every VM on the page The paged list loaded the page's launcher pods by the harvesterhci.io/vmName label, which only the Harvester VM form writes into a VM's template. VMs created any other way, like an imported VM or one applied with kubectl, got no pod, so their rows lost View Logs and the starting and pod error states. Load the pods after the page's VMIs instead, by the kubevirt.io/created-by label KubeVirt puts on every launcher pod (the VMI's UID). Also cover the paged mode in the tests: it must not load every VMI, migration or pod, and a forced refresh must reach every request. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * fix: notify about restarts again when coming back to the VM list The restart notice compared the VMs that need a restart with the previous value of the list. Coming back from a page that loads every VM, like Volumes or a VM's detail page, that previous value already held the same VMs, so the notice didn't show. Remember what was notified on the list itself instead, so each visit starts fresh, and compare by namespace and name, so a VM of the same name in another namespace counts as a change. Also say which VMs lack Harvester's vmName label: the ones from Forklift or plain manifests, not every VM created outside the UI. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * refactor: keep the VM list's paging helpers in the component Only canPaginate stays outside, because ResourceList calls $loadingResources(route, store) on the component options, where there is no `this`. The pagination headers become a computed property and the printer column lookup a method. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * refactor: always list VMs with PaginatedResourceTable PaginatedResourceTable handles both modes. fetchSecondaryResources loads every pod, volume, restore, backup, VMI and migration when the list isn't paged, and only what every row shares when it is. VMIs without a VM are added back through localFilter, which only runs without pagination. The list passes the pagination context only when the cluster's API can page, so older clusters keep the full list. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * refactor: register the VM list's columns with the product Both column sets go through the product's headers(), with the paged set next to the unpaged one in config/table-headers.js. The list only adds the node and restore progress columns, which the API can't sort or search when paging. State sorts by the VM's Status printer column, metadata.fields.2. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * fix: show the restart notice when coming back to the VM list Since the list always uses PaginatedResourceTable it reads the VMs from the store. Coming back to the list the store already holds them, so the restart watcher never saw a change and the notice didn't show. Run it when the list is created too. While paging, the store can still hold the VMs another view loaded, like every VM after Volumes or a VM's detail, so wait for the list's own page before notifying. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * fix: let the namespace filter know the VM list is paged The VMs were registered for pagination with a context that only the VM list passed. The header's namespace filter asks without one, so it didn't know the list was paged and kept offering "Not in a Project", which the paged API can't filter by: picking it hid every VM. Register the VMs in every context and answer per cluster in the store's paginationEnabled getter instead: only when the feature is on and the API lists the VM's printer columns as metadata.fields, as the SQL cache does. The filter, the list and the store now agree, and clusters whose API can't page keep the full list. The filter is shared by every list, so Not in a Project can still be picked on a list that doesn't page. The paged VM list then asks for another option, like the shell's generic lists do, instead of showing no rows. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * fix: keep the paged VM list when showing a VM's configuration The Config tab of the Show Configuration drawer renders the VM form, which loads every VM, PVC, PV, VMI and migration, and its device tabs every VM again. On a paged list that replaced the list's page in the store and emptied the list. Hide the Config tab while the store keeps a page of VMs, so the drawer shows the YAML. The VM's own page still shows its configuration, and a drawer opened where every VM is loaded keeps its Config tab. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> * refactor: define the VM list's node and restore columns with the others The node and restore progress columns are now in VM_HEADERS, so the paged set turns their sort and search off through VM_PAGINATION_FIELDS, like the other columns the API can't index. The list only leaves them out when they don't apply: the node column when the cluster's nodes can't be seen, the restore progress while no backup is being restored. Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com> --------- Signed-off-by: Marcelo Fukumoto <marcelo.fukumoto@suse.com>
452 lines
15 KiB
JavaScript
452 lines
15 KiB
JavaScript
import { reactive } from 'vue';
|
|
import VirtVm from '../kubevirt.io.virtualmachine';
|
|
import { POD, PVC } from '@shell/config/types';
|
|
import { HCI } from '../../types';
|
|
|
|
// The Steve base model and the shell resource class pull in most of the dashboard, none of that is needed here
|
|
jest.mock('../harvester', () => ({ __esModule: true, default: class {} }));
|
|
jest.mock('@shell/plugins/dashboard-store/resource-class', () => ({
|
|
colorForState: (state) => (state === 'Running' ? 'text-success' : 'text-info'),
|
|
stateSort: (color, display) => `${ color.replace(/^text-/, '') } ${ display }`,
|
|
}));
|
|
|
|
const VM_ID = 'ns1/vm1';
|
|
|
|
// Creates a VM model with mocked store getters. Like the real store, `all` returns the same array that is mutated in place.
|
|
// Reads from the global `$rootGetters` are recorded in `globalReads`.
|
|
function createVm({
|
|
vm = {}, vmi, pods = [], pvcs = [], restores = [], backups = [], claims = ['disk-pvc'], printableStatus
|
|
} = {}) {
|
|
const lists = reactive({
|
|
[POD]: pods,
|
|
[PVC]: pvcs,
|
|
[HCI.RESTORE]: restores,
|
|
[HCI.BACKUP]: backups,
|
|
});
|
|
const byId = { [HCI.VMI]: vmi ? [vmi] : [] };
|
|
|
|
const getters = {
|
|
all: (type) => lists[type] || [],
|
|
byId: (type, id) => (byId[type] || lists[type] || []).find((x) => x.id === id),
|
|
schemaFor: () => undefined,
|
|
};
|
|
const globalReads = [];
|
|
const rootGetters = new Proxy({ 'harvester-common/getFeatureEnabled': () => false }, {
|
|
get(target, key) {
|
|
globalReads.push(key);
|
|
|
|
return target[key];
|
|
}
|
|
});
|
|
|
|
const obj = Object.create(VirtVm.prototype);
|
|
|
|
Object.assign(obj, {
|
|
id: VM_ID,
|
|
type: HCI.VM,
|
|
metadata: {
|
|
name: 'vm1', namespace: 'ns1', annotations: {}
|
|
},
|
|
spec: {
|
|
runStrategy: 'Always',
|
|
template: {
|
|
spec: {
|
|
domain: { cpu: { cores: 1 }, resources: { limits: { memory: '1Gi' } } },
|
|
volumes: claims.map((c) => ({ name: c, persistentVolumeClaim: { claimName: c } })),
|
|
}
|
|
}
|
|
},
|
|
status: {
|
|
created: true, ready: true, printableStatus: printableStatus || 'Running', conditions: []
|
|
},
|
|
...vm,
|
|
});
|
|
Object.defineProperty(obj, '$rootGetters', { value: rootGetters });
|
|
Object.defineProperty(obj, '$getters', { value: getters });
|
|
Object.defineProperty(obj, 't', { value: (k) => k });
|
|
|
|
return {
|
|
vm: obj, lists, globalReads
|
|
};
|
|
}
|
|
|
|
const readyVmi = (extra = {}) => ({
|
|
id: VM_ID,
|
|
metadata: { name: 'vm1', namespace: 'ns1' },
|
|
status: {
|
|
phase: 'Running',
|
|
conditions: [{ type: 'Ready', status: 'True' }],
|
|
...extra
|
|
}
|
|
});
|
|
|
|
const pvc = (name, encrypted, ns = 'ns1') => ({
|
|
id: `${ ns }/${ name }`,
|
|
metadata: { name, namespace: ns },
|
|
isEncrypted: encrypted,
|
|
});
|
|
|
|
describe('class VirtVm', () => {
|
|
describe('restoreResource', () => {
|
|
it('should distinguish snapshots from backups and follow backup updates', () => {
|
|
const { vm, lists } = createVm({
|
|
vm: {
|
|
metadata: {
|
|
namespace: 'ns1', name: 'vm1', annotations: { 'restore.harvesterhci.io/name': 'r1' }
|
|
}
|
|
},
|
|
restores: [{
|
|
id: 'ns1/r1', isComplete: false, spec: { virtualMachineBackupNamespace: 'ns1', virtualMachineBackupName: 'b1' }
|
|
}],
|
|
backups: [
|
|
{ id: 'ns2/b1', spec: { type: 'snapshot' } },
|
|
{ id: 'ns1/b1', spec: { type: 'backup' } },
|
|
],
|
|
});
|
|
|
|
expect(vm.restoreResource.fromSnapshot).toBe(false);
|
|
expect(vm.restoreState).toBe(false);
|
|
|
|
lists[HCI.BACKUP][1].spec.type = 'snapshot';
|
|
expect(vm.restoreResource.fromSnapshot).toBe(true);
|
|
|
|
lists[HCI.BACKUP].splice(1, 1);
|
|
expect(vm.restoreResource.fromSnapshot).toBe(false);
|
|
|
|
lists[HCI.RESTORE][0].isComplete = true;
|
|
expect(vm.restoreState).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('encryptedVolumeType', () => {
|
|
it('should be none without volumes', () => {
|
|
const { vm } = createVm({ claims: [] });
|
|
|
|
expect(vm.encryptedVolumeType).toBe('none');
|
|
});
|
|
|
|
it('should be none if no PVC is encrypted', () => {
|
|
const { vm } = createVm({ pvcs: [pvc('disk-pvc', false)] });
|
|
|
|
expect(vm.encryptedVolumeType).toBe('none');
|
|
});
|
|
|
|
it('should be all if every PVC is encrypted', () => {
|
|
const { vm } = createVm({
|
|
claims: ['a', 'b'],
|
|
pvcs: [pvc('a', true), pvc('b', true), pvc('other', false)]
|
|
});
|
|
|
|
expect(vm.encryptedVolumeType).toBe('all');
|
|
});
|
|
|
|
it('should be partial if some PVCs are encrypted', () => {
|
|
const { vm } = createVm({
|
|
claims: ['a', 'b'],
|
|
pvcs: [pvc('a', true), pvc('b', false)]
|
|
});
|
|
|
|
expect(vm.encryptedVolumeType).toBe('partial');
|
|
});
|
|
|
|
it('should follow PVCs that are added to the store later', () => {
|
|
const { vm, lists } = createVm({ claims: ['a'], pvcs: [] });
|
|
|
|
expect(vm.encryptedVolumeType).toBe('none');
|
|
|
|
lists[PVC].push(pvc('a', true));
|
|
|
|
expect(vm.encryptedVolumeType).toBe('all');
|
|
});
|
|
});
|
|
|
|
describe('actualState', () => {
|
|
it('should be Off if the VM is halted', () => {
|
|
const { vm } = createVm({
|
|
vm: {
|
|
spec: { runStrategy: 'Halted', template: { spec: { volumes: [], domain: {} } } },
|
|
status: { created: false, conditions: [] }
|
|
}
|
|
});
|
|
|
|
expect(vm.actualState).toBe('Off');
|
|
});
|
|
|
|
it('should be Running if the VMI is running and ready', () => {
|
|
const { vm } = createVm({ vmi: readyVmi() });
|
|
|
|
expect(vm.actualState).toBe('Running');
|
|
});
|
|
|
|
it('should be Not Ready if the VMI is running but not ready', () => {
|
|
const { vm } = createVm({ vmi: readyVmi({ conditions: [{ type: 'Ready', status: 'False' }] }) });
|
|
|
|
expect(vm.actualState).toBe('Not Ready');
|
|
});
|
|
|
|
it('should be Paused if the VMI has the Paused condition', () => {
|
|
const { vm } = createVm({ vmi: readyVmi({ conditions: [{ type: 'Ready', status: 'True' }, { type: 'Paused', status: 'True' }] }) });
|
|
|
|
expect(vm.actualState).toBe('Paused');
|
|
});
|
|
|
|
it('should be Stopping if the VM is not expected to run anymore but the VMI exists', () => {
|
|
const { vm } = createVm({
|
|
vm: { spec: { runStrategy: 'Halted', template: { spec: { volumes: [], domain: {} } } } },
|
|
vmi: readyVmi()
|
|
});
|
|
|
|
expect(vm.actualState).toBe('Stopping');
|
|
});
|
|
|
|
it('should be Starting while the launcher pod is not ready', () => {
|
|
const { vm } = createVm({
|
|
vmi: readyVmi({ phase: 'Scheduling', conditions: [] }),
|
|
pods: [{
|
|
metadata: { namespace: 'ns1', ownerReferences: [{ name: 'vm1' }] },
|
|
getPodStatus: { status: 'POD_NOT_SCHEDULABLE' }
|
|
}]
|
|
});
|
|
|
|
expect(vm.actualState).toBe('Starting');
|
|
});
|
|
|
|
it('should be Unschedulable if the VM is starting and has an unschedulable condition', () => {
|
|
const { vm } = createVm({
|
|
vmi: readyVmi({ phase: 'Pending', conditions: [] }),
|
|
vm: { status: { created: true, conditions: [{ reason: 'Unschedulable', message: 'no node' }] } }
|
|
});
|
|
|
|
expect(vm.actualState).toBe('Unschedulable');
|
|
expect(vm.isUnschedulable.message).toBe('no node');
|
|
});
|
|
|
|
it('should not be Unschedulable without an unschedulable condition', () => {
|
|
const { vm } = createVm({ vmi: readyVmi() });
|
|
|
|
expect(vm.isUnschedulable).toBeNull();
|
|
expect(vm.actualState).toBe('Running');
|
|
});
|
|
|
|
it('should not be Unschedulable if the VM is neither starting nor stopping', () => {
|
|
const { vm } = createVm({
|
|
vm: {
|
|
spec: { runStrategy: 'Halted', template: { spec: { volumes: [], domain: {} } } },
|
|
status: { created: false, conditions: [{ reason: 'Unschedulable' }] }
|
|
}
|
|
});
|
|
|
|
expect(vm.isUnschedulable).toBeNull();
|
|
expect(vm.actualState).toBe('Off');
|
|
});
|
|
|
|
it('should be Terminating if the VM is being deleted', () => {
|
|
const { vm } = createVm({
|
|
vmi: readyVmi(),
|
|
vm: {
|
|
metadata: {
|
|
name: 'vm1', namespace: 'ns1', annotations: {}, deletionTimestamp: 'now'
|
|
}
|
|
}
|
|
});
|
|
|
|
expect(vm.actualState).toBe('Terminating');
|
|
});
|
|
|
|
it('should be VM error if the VM has a failure condition', () => {
|
|
const { vm } = createVm({ vm: { status: { created: true, conditions: [{ type: 'Failure', message: 'boom' }] } } });
|
|
|
|
expect(vm.actualState).toBe('VM error');
|
|
});
|
|
|
|
it('should be Restoring while a restore is in progress', () => {
|
|
const { vm } = createVm({
|
|
vmi: readyVmi(),
|
|
vm: {
|
|
metadata: {
|
|
name: 'vm1', namespace: 'ns1', annotations: { 'restore.harvesterhci.io/name': 'r1' }
|
|
}
|
|
},
|
|
restores: [{ id: 'ns1/r1', isComplete: false }]
|
|
});
|
|
|
|
expect(vm.actualState).toBe('Restoring');
|
|
});
|
|
|
|
it('should not be Restoring if the restore of the annotation does not exist', () => {
|
|
const { vm } = createVm({
|
|
vmi: readyVmi(),
|
|
vm: {
|
|
metadata: {
|
|
name: 'vm1', namespace: 'ns1', annotations: { 'restore.harvesterhci.io/name': 'other' }
|
|
}
|
|
},
|
|
restores: [{ id: 'ns1/r1', isComplete: false }]
|
|
});
|
|
|
|
expect(vm.actualState).toBe('Running');
|
|
});
|
|
});
|
|
|
|
describe('stateSort', () => {
|
|
it('should be built from the same state as stateDisplay and stateColor', () => {
|
|
const { vm } = createVm({ vmi: readyVmi() });
|
|
|
|
expect(vm.stateSort).toBe(`${ vm.stateColor.replace(/^text-/, '') } ${ vm.stateDisplay }`);
|
|
});
|
|
|
|
it('should evaluate the state only once', () => {
|
|
const { vm } = createVm({ vmi: readyVmi() });
|
|
const spy = jest.spyOn(vm, 'actualState', 'get');
|
|
|
|
expect(vm.stateSort).toBe('success Running');
|
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
|
|
spy.mockRestore();
|
|
});
|
|
});
|
|
|
|
describe('podResource', () => {
|
|
it('should find the launcher pod by owner name', () => {
|
|
const pod = { metadata: { namespace: 'ns1', ownerReferences: [{ name: 'vm1' }] } };
|
|
const { vm } = createVm({ vmi: readyVmi(), pods: [pod] });
|
|
|
|
expect(vm.podResource).toStrictEqual(pod);
|
|
});
|
|
|
|
it('should return the last pod if several pods have the same owner', () => {
|
|
// e.g. the source and the target pod while the VM migrates
|
|
const source = {
|
|
metadata: {
|
|
name: 'launcher-source', namespace: 'ns1', ownerReferences: [{ name: 'vm1' }]
|
|
}
|
|
};
|
|
const target = {
|
|
metadata: {
|
|
name: 'launcher-target', namespace: 'ns1', ownerReferences: [{ name: 'vm1' }]
|
|
}
|
|
};
|
|
const { vm } = createVm({ vmi: readyVmi(), pods: [source, target] });
|
|
|
|
expect(vm.podResource.metadata.name).toBe('launcher-target');
|
|
});
|
|
|
|
it('should find pods that are added to the store later', () => {
|
|
const { vm, lists } = createVm({ vmi: readyVmi(), pods: [] });
|
|
|
|
expect(vm.podResource).toBeUndefined();
|
|
|
|
const pod = { metadata: { namespace: 'ns1', ownerReferences: [{ name: 'vm1' }] } };
|
|
|
|
lists[POD].push(pod);
|
|
|
|
expect(vm.podResource).toStrictEqual(pod);
|
|
});
|
|
|
|
it('should not return a pod of a VM with the same name in another namespace', () => {
|
|
const other = { metadata: { namespace: 'ns2', ownerReferences: [{ name: 'vm1' }] } };
|
|
const mine = { metadata: { namespace: 'ns1', ownerReferences: [{ name: 'vm1' }] } };
|
|
const { vm } = createVm({ vmi: readyVmi(), pods: [mine, other] });
|
|
|
|
expect(vm.podResource).toStrictEqual(mine);
|
|
});
|
|
|
|
it('should not return pods that were removed from the store', () => {
|
|
const pod = { metadata: { namespace: 'ns1', ownerReferences: [{ name: 'vm1' }] } };
|
|
const { vm, lists } = createVm({ vmi: readyVmi(), pods: [pod] });
|
|
|
|
expect(vm.podResource).toStrictEqual(pod);
|
|
|
|
lists[POD].splice(0, 1);
|
|
|
|
expect(vm.podResource).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('store', () => {
|
|
it('should read the data of the VM from the store the VM lives in, not from a fixed one', () => {
|
|
// The VM model is used with the `harvester` store (Harvester product) and the `cluster` store (Rancher explorer)
|
|
const pod = { metadata: { namespace: 'ns1', ownerReferences: [{ name: 'vm1' }] } };
|
|
const { vm, globalReads } = createVm({
|
|
vmi: readyVmi(),
|
|
pods: [pod],
|
|
pvcs: [pvc('disk-pvc', false)],
|
|
restores: [{ id: 'ns1/r1', isComplete: true }],
|
|
vm: {
|
|
metadata: {
|
|
name: 'vm1', namespace: 'ns1', annotations: { 'restore.harvesterhci.io/name': 'r1' }
|
|
}
|
|
},
|
|
});
|
|
|
|
expect(vm.vmi.id).toBe(VM_ID);
|
|
expect(vm.podResource).toStrictEqual(pod);
|
|
expect(vm.volumes).toHaveLength(1);
|
|
expect(vm.restoreResource.id).toBe('ns1/r1');
|
|
expect(vm.actualState).toBe('Running');
|
|
expect(globalReads.filter((key) => /^(harvester|cluster)\//.test(key))).toStrictEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('isRestartRequired', () => {
|
|
it('should reflect the RestartRequired condition', () => {
|
|
const { vm } = createVm({ vm: { status: { conditions: [{ type: 'RestartRequired', status: 'True' }] } } });
|
|
|
|
expect(vm.isRestartRequired).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('findInNamespace', () => {
|
|
function vmWithStore({ havePage }) {
|
|
const vm = Object.create(VirtVm.prototype);
|
|
const stored = [{ metadata: { namespace: 'ns1', name: 'a' } }, { metadata: { namespace: 'other', name: 'b' } }];
|
|
const dispatch = jest.fn((action) => Promise.resolve(action === 'findPage' ? { data: [{ metadata: { namespace: 'ns1', name: 'page' } }] } : stored));
|
|
|
|
vm.metadata = { name: 'vm1', namespace: 'ns1' };
|
|
Object.defineProperty(vm, '$getters', { value: { havePage: (type) => havePage && type === PVC } });
|
|
Object.defineProperty(vm, '$dispatch', { value: dispatch });
|
|
|
|
return {
|
|
vm, dispatch, stored
|
|
};
|
|
}
|
|
|
|
it('should load every resource and return a copy with the ones of the namespace when no page of the type is stored', async() => {
|
|
const { vm, dispatch, stored } = vmWithStore({ havePage: false });
|
|
const out = await vm.findInNamespace(PVC);
|
|
|
|
expect(dispatch.mock.calls).toStrictEqual([['findAll', { type: PVC }]]);
|
|
expect(out.map(({ metadata }) => metadata.name)).toStrictEqual(['a']);
|
|
expect(out).not.toBe(stored);
|
|
});
|
|
|
|
it('should read only the namespace, without storing it, when a paged list keeps a page of the type', async() => {
|
|
const { vm, dispatch } = vmWithStore({ havePage: true });
|
|
const out = await vm.findInNamespace(PVC);
|
|
|
|
expect(out.map(({ metadata }) => metadata.name)).toStrictEqual(['page']);
|
|
expect(dispatch).toHaveBeenCalledTimes(1);
|
|
|
|
const [action, { type, opt }] = dispatch.mock.calls[0];
|
|
|
|
expect([action, type, opt.transient]).toStrictEqual(['findPage', PVC, true]);
|
|
expect(opt.pagination.filters[0].fields.map(({ field, value }) => `${ field }=${ value }`)).toStrictEqual(['metadata.namespace=ns1']);
|
|
});
|
|
});
|
|
|
|
describe('disableResourceDetailDrawerConfigTab', () => {
|
|
it.each([
|
|
['hide the drawer\'s Config tab while the paged VM list keeps a page of VMs', { paged: true }, true],
|
|
['keep the drawer\'s Config tab when every VM is loaded', null, false],
|
|
])('should %s', (_, page, hidden) => {
|
|
const vm = Object.create(VirtVm.prototype);
|
|
const havePage = jest.fn(() => page);
|
|
|
|
Object.defineProperty(vm, '$getters', { value: { havePage } });
|
|
|
|
expect(vm.disableResourceDetailDrawerConfigTab).toBe(hidden);
|
|
expect(havePage).toHaveBeenCalledWith(HCI.VM);
|
|
});
|
|
});
|
|
});
|