You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/web/tests/AdminHostSchedulingBehavior...

215 lines
9.6 KiB
JavaScript

import assert from 'node:assert/strict';
import { readFile } from 'node:fs/promises';
import vm from 'node:vm';
const adminSource = await readFile(
new URL('../public/cloud/admin-hosts.js', import.meta.url), 'utf8');
const source = adminSource.slice(adminSource.indexOf('const root ='))
.replace('void initialize();', '')
+ `\nglobalThis.hostSchedulingUI = {
renderHostScheduling, schedulingBody, saveHostScheduling,
createHostMembership, saveHostMembership, deleteHostMembership,
syncCachedHostScheduling, state,
};`;
const descendants = node => [node, ...(node?.children || []).flatMap(descendants)];
function fixture(canManage = true) {
const elements = new Map();
const requests = [];
const reads = [];
let response = null;
let hostListResponse = { hosts: [], regions: [], summary: {} };
class Element {
constructor(tag = 'input') {
this.tag = tag; this.value = ''; this.textContent = ''; this.className = '';
this.name = ''; this.type = ''; this.dataset = {}; this.children = [];
this.disabled = false; this.hidden = false; this.isConnected = true;
this.listeners = new Map();
this.classList = { add() {}, remove() {}, toggle() {} };
}
get options() { return this.children; }
get elements() {
return { namedItem: name => descendants(this).find(node => node.name === name) || null };
}
append(...children) { this.children.push(...children); }
replaceChildren(...children) {
for (const child of this.children) for (const node of descendants(child)) node.isConnected = false;
this.children = children;
}
addEventListener(name, listener) { this.listeners.set(name, listener); }
querySelector(selector) {
if (selector === '[data-host-membership-save]') {
return descendants(this).find(node => Object.hasOwn(node.dataset, 'hostMembershipSave')) || null;
}
return null;
}
reportValidity() { return true; }
}
const selectIds = new Set([
'host-membership-pool', 'host-membership-new-state',
]);
const get = id => {
if (!elements.has(id)) elements.set(id, new Element(selectIds.has(id) ? 'select' : 'input'));
return elements.get(id);
};
const root = { dataset: { cloudAdmin: 'hosts', canManage: canManage ? '1' : '0' } };
const runtime = {
create: () => ({
read: async path => {
reads.push(path);
return { payload: hostListResponse, path };
},
mutate: async (path, options) => {
requests.push({ path, ...options });
return { payload: response };
},
}),
};
const context = {
document: {
querySelector: () => root,
getElementById: get,
createElement: tag => new Element(tag),
},
ADMIN_CSRF_TOKEN: 'a'.repeat(64),
VenixAdminRequestRuntime: runtime,
VenixAdminDangerDialog: { confirm: async () => true },
VenixDrawerMotion: {},
taskUrl: () => '',
location: { assign() {} },
Headers, AbortController, setTimeout, clearTimeout,
};
context.window = context;
vm.runInNewContext(source, context, { filename: 'admin-hosts.js' });
return {
...context.hostSchedulingUI,
get,
requests,
reads,
descendants: id => descendants(get(id)),
respond(payload) { response = payload; },
respondHostList(payload) { hostListResponse = payload; },
};
}
const capacity = {
cpu: { allocated: 1, reserved: 0, free: 7 },
memory: { allocated: 1024, reserved: 0, free: 7168 },
disk: { allocated: 20, reserved: 0, free: 180 },
instances: { allocated: 1, reserved: 0 },
ip: { available: 4, total: 8 },
};
const policy = {
configured_cpu_cores: 8, configured_memory_mib: 8192,
configured_disk_gib: 200, safety_cpu_cores: 0,
safety_memory_mib: 0, safety_disk_gib: 0, max_instances: 20,
};
const pools = [
{ id: 11, name: 'Premium', status: 'active', line_name: 'CN2', line_status: 'active', region_name: 'Hong Kong', region_status: 'active' },
{ id: 12, name: 'Standard', status: 'active', line_name: 'Global', line_status: 'active', region_name: 'Hong Kong', region_status: 'active' },
];
const membership = {
resource_pool_id: 11, pool_name: 'Premium', line_name: 'CN2',
region_name: 'Hong Kong', scheduler_state: 'active', priority: 10,
weight: 200, revision: 4, warnings: [],
};
const payload = {
host: { id: 7, name: 'HKG-A', enabled: true, resource_pool_id: 11, scheduler_state: 'active' },
policy, capacity, pools, memberships: [membership], warnings: [],
network_lines_enabled: true,
};
const test = fixture();
test.respond(payload);
test.respondHostList({
hosts: [{
id: 7, name: 'HKG-A', enabled: true, scheduler_state: 'active',
placement: { region_id: 1, region_name: 'Hong Kong', line_name: 'CN2', pool_name: 'Premium' },
agent: { ready: true, state: 'ready' },
readiness: { placement_ready: false }, needs_attention: true,
capacity,
}],
regions: [{ id: 1, name: 'Hong Kong', summary: { hosts_total: 1, agent_ready_hosts: 1, attention_hosts: 1 }, hosts: [] }],
summary: { hosts_total: 1, placement_ready_hosts: 0, attention_hosts: 1 },
});
test.renderHostScheduling(payload);
assert.deepEqual(test.get('host-membership-pool').children.map(option => option.value), ['', '12'],
'Assigned resource pools remained selectable as new memberships.');
const cards = test.descendants('host-membership-list');
assert.ok(cards.some(node => node.dataset.hostMembership === '11'));
assert.ok(cards.some(node => /Hong Kong \/ CN2 \/ Premium/.test(node.textContent)));
const memberForm = cards.find(node => node.dataset.hostMembershipForm === '');
assert.equal(memberForm.dataset.revision, '4');
assert.equal(memberForm.elements.namedItem('scheduler_state').value, 'active');
assert.equal(memberForm.elements.namedItem('priority').value, '10');
assert.equal(memberForm.elements.namedItem('weight').value, '200');
assert.deepEqual({ ...test.schedulingBody() }, policy,
'The global capacity payload still contained membership fields.');
await test.saveHostScheduling({ preventDefault() {}, currentTarget: test.get('host-scheduling-form') });
assert.equal(test.requests.at(-1).path, '/api/v1/admin/hosts/7/scheduling');
assert.equal(test.requests.at(-1).method, 'PUT');
assert.deepEqual({ ...test.requests.at(-1).body }, policy);
assert.equal(test.reads.at(-1), '/api/v1/admin/hosts',
'A confirmed scheduling mutation did not reload the authoritative host projection.');
assert.equal(test.state.hosts[0].readiness.placement_ready, false);
assert.equal(test.state.hosts[0].needs_attention, true);
assert.equal(test.state.hostSummary.attention_hosts, 1);
assert.equal(test.state.hostRegions[0].summary.attention_hosts, 1,
'Scheduling cache retained stale region summary data after the mutation.');
const withSecond = {
...payload,
memberships: [membership, { ...membership, resource_pool_id: 12, pool_name: 'Standard', line_name: 'Global', scheduler_state: 'disabled', priority: 0, weight: 100, revision: 1 }],
};
test.respond(withSecond);
test.get('host-membership-pool').value = '12';
test.get('host-membership-new-state').value = 'disabled';
test.get('host-membership-new-priority').value = '0';
test.get('host-membership-new-weight').value = '100';
await test.createHostMembership({ preventDefault() {}, currentTarget: test.get('host-membership-create-form') });
assert.equal(test.requests.at(-1).path, '/api/v1/admin/hosts/7/scheduling/memberships/12');
assert.equal(test.requests.at(-1).method, 'PUT');
assert.deepEqual({ ...test.requests.at(-1).body }, {
scheduler_state: 'disabled', priority: 0, weight: 100, expected_revision: 0,
});
const updatedForms = test.descendants('host-membership-list');
const firstForm = updatedForms.find(node => node.dataset.hostMembershipForm === '' && node.dataset.poolId === '11');
firstForm.elements.namedItem('scheduler_state').value = 'draining';
firstForm.elements.namedItem('priority').value = '30';
firstForm.elements.namedItem('weight').value = '300';
test.respond({ ...withSecond, memberships: [{ ...membership, scheduler_state: 'draining', priority: 30, weight: 300, revision: 5 }, withSecond.memberships[1]] });
await test.saveHostMembership({ preventDefault() {}, currentTarget: firstForm });
assert.equal(test.requests.at(-1).path, '/api/v1/admin/hosts/7/scheduling/memberships/11');
assert.deepEqual({ ...test.requests.at(-1).body }, {
scheduler_state: 'draining', priority: 30, weight: 300, expected_revision: 4,
});
test.respond({ ...payload, memberships: [] });
await test.deleteHostMembership({ ...membership, revision: 5 }, null);
assert.equal(test.requests.at(-1).method, 'DELETE');
assert.equal(test.requests.at(-1).path, '/api/v1/admin/hosts/7/scheduling/memberships/11');
assert.deepEqual({ ...test.requests.at(-1).body }, { expected_revision: 5 });
const viewer = fixture(false);
viewer.respond(payload);
viewer.renderHostScheduling(payload);
const viewerForm = viewer.descendants('host-membership-list')
.find(node => node.dataset.hostMembershipForm === '');
assert.equal(viewerForm.elements.namedItem('scheduler_state').disabled, true);
assert.equal(viewerForm.elements.namedItem('priority').disabled, true);
assert.equal(viewerForm.elements.namedItem('weight').disabled, true);
assert.equal(viewer.descendants('host-membership-list')
.some(node => Object.hasOwn(node.dataset, 'hostMembershipSave')), false);
await viewer.saveHostScheduling({ preventDefault() {}, currentTarget: viewer.get('host-scheduling-form') });
await viewer.createHostMembership({ preventDefault() {}, currentTarget: viewer.get('host-membership-create-form') });
assert.equal(viewer.requests.length, 0,
'Read-only administrators could submit host scheduling mutations.');
console.log('Administrator host capacity, independent membership and read-only UI behavior passed.');