open-nomad/ui/tests/acceptance/topology-test.js
2022-01-20 09:46:45 -05:00

253 lines
9.2 KiB
JavaScript

import { get } from '@ember/object';
import { currentURL } from '@ember/test-helpers';
import { module, test } from 'qunit';
import { setupApplicationTest } from 'ember-qunit';
import { setupMirage } from 'ember-cli-mirage/test-support';
import a11yAudit from 'nomad-ui/tests/helpers/a11y-audit';
import Topology from 'nomad-ui/tests/pages/topology';
import {
formatBytes,
formatScheduledBytes,
formatHertz,
formatScheduledHertz,
} from 'nomad-ui/utils/units';
import queryString from 'query-string';
const sumResources = (list, dimension) =>
list.reduce((agg, val) => agg + (get(val, dimension) || 0), 0);
module('Acceptance | topology', function (hooks) {
setupApplicationTest(hooks);
setupMirage(hooks);
hooks.beforeEach(function () {
server.create('job', { createAllocations: false });
});
test('it passes an accessibility audit', async function (assert) {
server.createList('node', 3);
server.createList('allocation', 5);
await Topology.visit();
await a11yAudit(assert);
});
test('by default the info panel shows cluster aggregate stats', async function (assert) {
server.createList('node', 3);
server.createList('allocation', 5);
await Topology.visit();
assert.equal(Topology.infoPanelTitle, 'Cluster Details');
assert.notOk(Topology.filteredNodesWarning.isPresent);
assert.equal(
Topology.clusterInfoPanel.nodeCount,
`${server.schema.nodes.all().length} Clients`
);
const allocs = server.schema.allocations.all().models;
const scheduledAllocs = allocs.filter((alloc) =>
['pending', 'running'].includes(alloc.clientStatus)
);
assert.equal(Topology.clusterInfoPanel.allocCount, `${scheduledAllocs.length} Allocations`);
const nodeResources = server.schema.nodes.all().models.mapBy('nodeResources');
const taskResources = scheduledAllocs.mapBy('taskResources.models').flat().mapBy('resources');
const totalMem = sumResources(nodeResources, 'Memory.MemoryMB');
const totalCPU = sumResources(nodeResources, 'Cpu.CpuShares');
const reservedMem = sumResources(taskResources, 'Memory.MemoryMB');
const reservedCPU = sumResources(taskResources, 'Cpu.CpuShares');
assert.equal(Topology.clusterInfoPanel.memoryProgressValue, reservedMem / totalMem);
assert.equal(Topology.clusterInfoPanel.cpuProgressValue, reservedCPU / totalCPU);
assert.equal(
Topology.clusterInfoPanel.memoryAbsoluteValue,
`${formatBytes(reservedMem * 1024 * 1024)} / ${formatBytes(totalMem * 1024 * 1024)} reserved`
);
assert.equal(
Topology.clusterInfoPanel.cpuAbsoluteValue,
`${formatHertz(reservedCPU, 'MHz')} / ${formatHertz(totalCPU, 'MHz')} reserved`
);
});
test('all allocations for all namespaces and all clients are queried on load', async function (assert) {
server.createList('node', 3);
server.createList('allocation', 5);
await Topology.visit();
const requests = this.server.pretender.handledRequests;
assert.ok(requests.findBy('url', '/v1/nodes?resources=true'));
const allocationsRequest = requests.find((req) => req.url.startsWith('/v1/allocations'));
assert.ok(allocationsRequest);
const allocationRequestParams = queryString.parse(allocationsRequest.url.split('?')[1]);
assert.deepEqual(allocationRequestParams, {
namespace: '*',
task_states: 'false',
resources: 'true',
});
});
test('when an allocation is selected, the info panel shows information on the allocation', async function (assert) {
const nodes = server.createList('node', 5);
const job = server.create('job', { createAllocations: false });
const taskGroup = server.schema.find('taskGroup', job.taskGroupIds[0]).name;
const allocs = server.createList('allocation', 5, {
forceRunningClientStatus: true,
jobId: job.id,
taskGroup,
});
// Get the first alloc of the first node that has an alloc
const sortedNodes = nodes.sortBy('datacenter');
let node, alloc;
for (let n of sortedNodes) {
alloc = allocs.find((a) => a.nodeId === n.id);
if (alloc) {
node = n;
break;
}
}
const dcIndex = nodes.mapBy('datacenter').uniq().sort().indexOf(node.datacenter);
const nodeIndex = nodes.filterBy('datacenter', node.datacenter).indexOf(node);
const reset = async () => {
await Topology.visit();
await Topology.viz.datacenters[dcIndex].nodes[nodeIndex].memoryRects[0].select();
};
await reset();
assert.equal(Topology.infoPanelTitle, 'Allocation Details');
assert.equal(Topology.allocInfoPanel.id, alloc.id.split('-')[0]);
const uniqueClients = allocs.mapBy('nodeId').uniq();
assert.equal(Topology.allocInfoPanel.siblingAllocs, `Sibling Allocations: ${allocs.length}`);
assert.equal(
Topology.allocInfoPanel.uniquePlacements,
`Unique Client Placements: ${uniqueClients.length}`
);
assert.equal(Topology.allocInfoPanel.job, job.name);
assert.ok(Topology.allocInfoPanel.taskGroup.endsWith(alloc.taskGroup));
assert.equal(Topology.allocInfoPanel.client, node.id.split('-')[0]);
await Topology.allocInfoPanel.visitAlloc();
assert.equal(currentURL(), `/allocations/${alloc.id}`);
await reset();
await Topology.allocInfoPanel.visitJob();
assert.equal(currentURL(), `/jobs/${job.id}`);
await reset();
await Topology.allocInfoPanel.visitClient();
assert.equal(currentURL(), `/clients/${node.id}`);
});
test('changing which allocation is selected changes the metric charts', async function (assert) {
server.create('node');
const job1 = server.create('job', { createAllocations: false });
const taskGroup1 = server.schema.find('taskGroup', job1.taskGroupIds[0]).name;
server.create('allocation', {
forceRunningClientStatus: true,
jobId: job1.id,
taskGroup1,
});
const job2 = server.create('job', { createAllocations: false });
const taskGroup2 = server.schema.find('taskGroup', job2.taskGroupIds[0]).name;
server.create('allocation', {
forceRunningClientStatus: true,
jobId: job2.id,
taskGroup2,
});
await Topology.visit();
await Topology.viz.datacenters[0].nodes[0].memoryRects[0].select();
const firstAllocationTaskNames = Topology.allocInfoPanel.charts[0].areas.mapBy('taskName');
await Topology.viz.datacenters[0].nodes[0].memoryRects[1].select();
const secondAllocationTaskNames = Topology.allocInfoPanel.charts[0].areas.mapBy('taskName');
assert.notDeepEqual(firstAllocationTaskNames, secondAllocationTaskNames);
});
test('when a node is selected, the info panel shows information on the node', async function (assert) {
// A high node count is required for node selection
const nodes = server.createList('node', 51);
const node = nodes.sortBy('datacenter')[0];
server.createList('allocation', 5, { forceRunningClientStatus: true });
const allocs = server.schema.allocations.where({ nodeId: node.id }).models;
await Topology.visit();
await Topology.viz.datacenters[0].nodes[0].selectNode();
assert.equal(Topology.infoPanelTitle, 'Client Details');
assert.equal(Topology.nodeInfoPanel.id, node.id.split('-')[0]);
assert.equal(Topology.nodeInfoPanel.name, `Name: ${node.name}`);
assert.equal(Topology.nodeInfoPanel.address, `Address: ${node.httpAddr}`);
assert.equal(Topology.nodeInfoPanel.status, `Status: ${node.status}`);
assert.equal(Topology.nodeInfoPanel.drainingLabel, node.drain ? 'Yes' : 'No');
assert.equal(
Topology.nodeInfoPanel.eligibleLabel,
node.schedulingEligibility === 'eligible' ? 'Yes' : 'No'
);
assert.equal(Topology.nodeInfoPanel.drainingIsAccented, node.drain);
assert.equal(
Topology.nodeInfoPanel.eligibleIsAccented,
node.schedulingEligibility !== 'eligible'
);
const taskResources = allocs.mapBy('taskResources.models').flat().mapBy('resources');
const reservedMem = sumResources(taskResources, 'Memory.MemoryMB');
const reservedCPU = sumResources(taskResources, 'Cpu.CpuShares');
const totalMem = node.nodeResources.Memory.MemoryMB;
const totalCPU = node.nodeResources.Cpu.CpuShares;
assert.equal(Topology.nodeInfoPanel.memoryProgressValue, reservedMem / totalMem);
assert.equal(Topology.nodeInfoPanel.cpuProgressValue, reservedCPU / totalCPU);
assert.equal(
Topology.nodeInfoPanel.memoryAbsoluteValue,
`${formatScheduledBytes(reservedMem * 1024 * 1024)} / ${formatScheduledBytes(
totalMem,
'MiB'
)} reserved`
);
assert.equal(
Topology.nodeInfoPanel.cpuAbsoluteValue,
`${formatScheduledHertz(reservedCPU, 'MHz')} / ${formatScheduledHertz(
totalCPU,
'MHz'
)} reserved`
);
await Topology.nodeInfoPanel.visitNode();
assert.equal(currentURL(), `/clients/${node.id}`);
});
test('when one or more nodes lack the NodeResources property, a warning message is shown', async function (assert) {
server.createList('node', 3);
server.createList('allocation', 5);
server.schema.nodes.all().models[0].update({ nodeResources: null });
await Topology.visit();
assert.ok(Topology.filteredNodesWarning.isPresent);
assert.ok(Topology.filteredNodesWarning.message.startsWith('1'));
});
});