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.
215 lines
9.6 KiB
JavaScript
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.');
|