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/CloudVpcPageBehaviorTest.mjs

404 lines
20 KiB
JavaScript

import assert from 'node:assert/strict';
import { readFile } from 'node:fs/promises';
import vm from 'node:vm';
const source = (await readFile(new URL('../public/cloud/vpcs.js', import.meta.url), 'utf8'))
.split('const requestUserConfirmation')[1];
const template = await readFile(new URL('../resources/views/venix/cloud/pages/vpcs.tpl', import.meta.url), 'utf8');
class Node {
constructor(tag, document) {
Object.assign(this, { tagName: tag.toUpperCase(), document, children: [], attributes: new Map(),
dataset: {}, listeners: new Map(), className: '', value: '', hidden: false, disabled: false,
checked: false, open: false, text: '' });
this.classList = {
contains: name => this.className.split(/\s+/).includes(name),
toggle: (name, force) => {
const names = new Set(this.className.split(/\s+/).filter(Boolean));
const on = force ?? !names.has(name);
if (on) names.add(name); else names.delete(name);
this.className = [...names].join(' ');
},
add: name => this.classList.toggle(name, true),
remove: name => this.classList.toggle(name, false),
};
}
set textContent(value) { this.text = String(value); this.replaceChildren(); }
get textContent() { return this.text + this.children.map(child => child.textContent).join(''); }
append(...children) { for (const child of children) { child.parent = this; this.children.push(child); } }
replaceChildren(...children) {
for (const child of this.children) child.parent = null;
this.children = []; this.append(...children);
}
setAttribute(name, value) { this.attributes.set(name, String(value)); }
getAttribute(name) { return this.attributes.get(name) ?? null; }
removeAttribute(name) { this.attributes.delete(name); }
querySelectorAll(selector) {
const matches = node => {
if (selector === '[data-vpc-focus]') return Boolean(node.dataset.vpcFocus);
if (selector.startsWith('.')) return node.classList.contains(selector.slice(1));
if (selector === 'th:last-child') return node.tagName === 'TH' && node.parent.children.at(-1) === node;
return node.tagName === selector.toUpperCase();
};
return this.children.flatMap(child => [...(matches(child) ? [child] : []), ...child.querySelectorAll(selector)]);
}
querySelector(selector) { return this.querySelectorAll(selector)[0] || null; }
addEventListener(name, listener) {
if (!this.listeners.has(name)) this.listeners.set(name, []);
this.listeners.get(name).push(listener);
}
async fire(name) {
await Promise.all((this.listeners.get(name) || []).map(fn => fn({ target: this, preventDefault() {} })));
await tick();
}
focus() { this.document.activeElement = this; }
scrollIntoView() {}
get isConnected() { return Boolean(this.parent); }
showModal() { this.open = true; }
close() { this.open = false; }
}
const tick = () => new Promise(resolve => setImmediate(resolve));
const A = 'a'.repeat(32), B = 'b'.repeat(32), C = 'c'.repeat(32);
const href = key => `#/${key}/instances`;
const network = (key, overrides = {}) => ({
vpc_key: key, name: key === A ? 'production' : 'staging',
region_id: 1, region_name: '香港', cidr: '10.0.1.0/24', gateway: '10.0.1.1',
state: 'active', port_count: 2, can_delete: false, ...overrides,
});
const member = (id, overrides = {}) => ({
id: String(id), name: `vm-${id}`, region_id: 1, public_ipv4: `192.0.2.${id}`,
can_detach: true, can_attach: false,
port: { vpc_key: A, state: 'attached', private_ip: `10.0.1.${id}`, mac_address: '02:11:22:33:44:55' },
...overrides,
});
const candidate = (id, overrides = {}) => member(id, { port: null, can_detach: false, can_attach: true, ...overrides });
function fixtures() {
return {
user: { id: 7 }, maximum: 16, used: 2,
items: [network(A), network(B, { port_count: 0, can_delete: true })],
regions: [{ id: 1, name: '香港', available: 200 }, { id: 2, name: '新加坡' }],
instances: [member(1), member(2), ...[3, 4, 5, 6, 7].map(id => candidate(id)),
candidate(8, { can_attach: false, action_unavailable_reason: '实例服务已到期' }),
candidate(9, { region_id: 2 })],
membership_batches: [],
};
}
async function setup(hash = '#/', payload = fixtures()) {
const document = {};
document.createElement = tag => new Node(tag, document);
document.documentElement = document.createElement('html');
const nodes = new Map();
for (const match of template.matchAll(/<([a-z][a-z0-9]*)\b[^>]*\bid="([^"]+)"[^>]*>/g)) {
const node = document.createElement(match[1]);
nodes.set(match[2], node); document.documentElement.append(node);
}
document.activeElement = document.documentElement;
const calls = [], observations = [], storage = new Map(), events = new Map();
const location = new URL(`https://panel.example.test/user/cloud/vpcs${hash}`);
const window = { location, VenixDialog: { confirm: async () => true },
addEventListener: (name, listener) => events.set(name, listener) };
let data = structuredClone(payload);
let respond = async (url, options) => {
if (!options.method) return structuredClone(data);
throw Error(`Unexpected mutation ${url}`);
};
const context = vm.createContext({
window, document, URL, AbortController, console,
sessionStorage: { getItem: key => storage.get(key) || null,
setItem: (key, value) => storage.set(key, value), removeItem: key => storage.delete(key) },
byId: id => nodes.get(id), readBootstrap: () => structuredClone(data),
initializeSession: async () => true,
api: async (url, options = {}) => { calls.push({ url, ...options }); return respond(url, options); },
showError: (id, message) => {
assert.ok(nodes.has(id), `Unexpected page initialization error: ${message}`);
nodes.get(id).textContent = message; nodes.get(id).hidden = !message;
},
toast() {}, announceTaskAccepted() {},
taskUrl: receipt => receipt?.task_id && receipt?.status_url ? receipt.status_url : '',
observeTask: (receipt, options) => {
const handle = { url: receipt.status_url, done: new Promise(() => {}), stop() {} };
observations.push({ receipt, options, handle }); return handle;
},
recoveryTaskFailureNotice: () => '', resolvedTaskFailureNotice: () => '',
taskSucceededWithoutRecovery: task => task.status === 'succeeded' && task.terminal === true,
});
vm.runInContext(('const requestUserConfirmation' + source)
.replace('export async function initialize()', 'async function initialize()')
+ '\nglobalThis.page = { initialize, apply, routeChanged };', context, { filename: 'vpcs.js' });
await context.page.initialize();
return {
nodes, calls, observations, storage, location, data: () => data,
update: next => { data = structuredClone(next); context.page.apply(structuredClone(next)); },
respond: fn => { respond = fn; },
event: (name, event = {}) => events.get(name)?.(event),
async go(hash) { location.hash = hash; events.get('hashchange')(); await tick(); },
async confirm(accept = true) {
if (accept) {
nodes.get('cloud-vpc-confirm-restart').checked = true;
await nodes.get('cloud-vpc-confirm-restart').fire('change');
await nodes.get('cloud-vpc-confirm-form').fire('submit');
} else await nodes.get('cloud-vpc-confirm-cancel').fire('click');
await tick();
},
};
}
const checks = t => t.nodes.get('cloud-vpc-instance-manager').querySelectorAll('input');
const control = (t, focus) => t.nodes.get('cloud-vpc-instance-manager')
.querySelectorAll('[data-vpc-focus]').find(node => node.dataset.vpcFocus === focus);
const mutations = t => t.calls.filter(call => call.method);
const plain = value => JSON.parse(JSON.stringify(value));
async function select(t, id) { const node = control(t, `select-${id}`); node.checked = true; await node.fire('change'); }
async function submit(t) { await control(t, 'submit-selection').fire('click'); }
for (const [query, page, joining] of [
['?view=create', 'create', false], [`?vpc=${A}`, 'members', false],
[`?vpc=${A}&view=join`, 'members', true], ['?vpc=invalid', 'missing', false],
['?vpc[]=invalid', 'missing', false], ['?view=join', 'missing', false],
]) {
const t = await setup(query);
assert.equal(t.nodes.get(`cloud-vpcs-${page}`).hidden, false, `Query route is not hydrated: ${query}`);
if (page === 'members') assert.equal(t.nodes.get('cloud-vpc-instance-manager').querySelector('section').classList.contains('joining'), joining);
assert.equal(t.calls.length, 0, 'A valid embedded library triggered an extra list request.');
}
{
const t = await setup();
assert.equal(t.nodes.get('cloud-vpcs-home').hidden, false);
assert.equal(t.nodes.get('cloud-vpcs-create').hidden, true);
assert.equal(t.nodes.get('cloud-vpcs-list').querySelector('tbody').children.length, 2);
assert.equal(t.nodes.get('cloud-vpcs-list').querySelectorAll('th').length, 4);
assert.equal(t.nodes.get('cloud-vpcs-list').textContent.includes('管理实例'), false);
assert.equal(t.nodes.get('cloud-vpcs-list').querySelectorAll('details').length, 0);
await t.go('#/create');
assert.equal(t.nodes.get('cloud-vpcs-create').hidden, false);
assert.equal(t.nodes.get('cloud-vpc-region').textContent.includes('200'), false);
await t.go(href(A));
assert.equal(t.nodes.get('cloud-vpcs-members').hidden, false);
assert.match(t.nodes.get('cloud-vpc-members-link').textContent, /2/);
assert.match(t.nodes.get('cloud-vpc-join-link').textContent, /5/);
assert.equal(t.nodes.get('cloud-vpc-instance-manager').querySelectorAll('th').length, 5);
assert.equal(t.nodes.get('cloud-vpc-delete').disabled, true);
await t.go(`${href(B)}/join`);
assert.equal(t.nodes.get('cloud-vpc-join-link').getAttribute('aria-current'), 'page');
assert.equal(t.nodes.get('cloud-vpc-delete').disabled, false);
for (const route of ['#/does-not-exist', href(C)]) {
await t.go(route); assert.equal(t.nodes.get('cloud-vpcs-missing').hidden, false);
}
await t.go('#/');
assert.equal(t.nodes.get('cloud-vpcs-home').hidden, false);
assert.equal(mutations(t).length, 0, 'Navigation must never mutate a VPC');
}
{
const t = await setup(`${href(A)}/join`);
const search = control(t, 'instance-search');
assert.equal(search.placeholder, '搜索实例或公网 IP');
search.value = '192.0.2.4';
await search.fire('input');
const rows = t.nodes.get('cloud-vpc-instance-manager')
.querySelectorAll('.cloud-vpc-instance-row');
assert.deepEqual(rows.filter(row => !row.hidden)
.map(row => row.querySelector('input').value), ['4']);
const selectAll = control(t, 'select-all');
selectAll.checked = true;
await selectAll.fire('change');
assert.deepEqual(checks(t).filter(node => node.value && node.checked)
.map(node => node.value), ['4'], 'Select all must apply only to filtered results');
t.update(t.data());
assert.equal(control(t, 'instance-search').value, '192.0.2.4',
'The search query must survive a status refresh');
const refreshedSearch = control(t, 'instance-search');
refreshedSearch.value = 'not-found';
await refreshedSearch.fire('input');
assert.equal(t.nodes.get('cloud-vpc-instance-manager')
.querySelector('.cloud-vpc-search-empty').hidden, false);
assert.equal(control(t, 'submit-selection').disabled, false,
'A filtered-out prior selection must remain explicit and actionable');
}
{
const t = await setup(`${href(A)}/join`);
assert.deepEqual(checks(t).filter(node => node.value).map(node => node.value), ['3', '4', '5', '6', '7', '8']);
assert.equal(control(t, 'select-8').disabled, true);
await select(t, 'all');
assert.equal(checks(t).filter(node => node.value && node.checked).length, 5, 'No four-instance limit');
await submit(t);
assert.equal(t.nodes.get('cloud-vpc-confirm').open, true);
await t.nodes.get('cloud-vpc-confirm-form').fire('submit');
assert.equal(mutations(t).length, 0, 'Restart must be acknowledged');
await t.confirm(false);
assert.equal(mutations(t).length, 0, 'Cancel must not dispatch');
t.respond(async (url, options) => !options.method ? t.data() : { task_id: '500', status_url: '/api/v1/tasks/500' });
await submit(t); await t.confirm();
const [request] = mutations(t);
assert.equal(request.url, `/api/v1/vpcs/${A}/ports/batch`);
assert.deepEqual(plain(request.body), { action: 'attach', instance_ids: [3, 4, 5, 6, 7], confirm_restart: true });
assert.match(request.headers['Idempotency-Key'], /^[a-zA-Z0-9_.-]{16,128}$/);
assert.equal(request.expectedStatus, 202); assert.equal(request.requireTaskReceipt, true);
assert.equal(t.location.search, `?vpc=${A}`);
assert.equal(t.observations.length, 1);
await t.go('#/'); await t.go(`${href(B)}/join`);
assert.equal(t.observations.length, 1, 'Navigation must not duplicate observers');
}
{
const t = await setup(href(A));
await select(t, 1); await submit(t);
const changed = t.data(); changed.instances[0].can_detach = false; t.update(changed);
await t.confirm();
assert.equal(mutations(t).length, 0, 'Eligibility must be rechecked after confirmation');
assert.match(t.nodes.get('cloud-vpcs-status').textContent, /状态已变化/);
}
{
const data = fixtures();
data.items[1].port_count = 1;
data.items[1].can_delete = false;
data.instances.push(member(10, {
port: { vpc_key: B, state: 'preparing' }, can_detach: false, can_retry_attach: true,
}));
data.membership_batches = [{ vpc_key: A, state: 'blocked', total: 2, succeeded: 1,
failed: 0, unknown: 1, action: 'attach', task_id: '501', status_url: '/api/v1/tasks/501',
can_cancel: true, batch_key: 'd'.repeat(32) }];
const t = await setup(href(A), data);
assert.equal(checks(t).every(node => node.disabled), true);
assert.match(t.nodes.get('cloud-vpc-batch-status').textContent, /1 台待核对/);
assert.match(t.nodes.get('cloud-vpc-batch-status').textContent, /继续撤销并清理/);
assert.equal(t.observations.length, 0, 'Blocked batch must not be replayed');
await t.go(`${href(B)}/join`);
assert.equal(control(t, 'select-3').disabled, false, 'Other VPCs remain usable');
await t.go(href(B));
assert.match(t.nodes.get('cloud-vpc-instance-manager').textContent, /重试连接/);
assert.equal(mutations(t).length, 0);
}
{
const data = fixtures();
data.membership_batches = [{ vpc_key: A, state: 'ports', total: 2, succeeded: 0,
failed: 0, action: 'detach', task_id: '503', status_url: '/api/v1/tasks/503' }];
const t = await setup(href(A), data);
assert.equal(t.observations.length, 1, 'Reload must resume the original batch');
assert.equal(t.observations[0].receipt.task_id, '503');
assert.equal(mutations(t).length, 0, 'Resuming observation must not dispatch a new operation');
assert.equal(checks(t).every(node => node.disabled), true);
await t.go('#/'); await t.go(href(A));
assert.equal(t.observations.length, 1);
t.event('pagehide');
t.event('pageshow', { persisted: true });
await tick();
assert.equal(t.observations.length, 2, 'Back-forward cache restoration must resume observation');
assert.equal(t.observations[1].receipt.task_id, '503');
assert.equal(mutations(t).length, 0);
}
{
const itemStates = ['waiting_route', 'queued', 'succeeded', 'failed'];
const data = fixtures();
data.instances = itemStates.map((itemState, index) => member(index + 1, {
can_retry_attach: index === 0,
active_task: {
task_id: String(600 + index),
status_url: `/api/v1/tasks/${600 + index}`,
},
}));
data.items[0].port_count = itemStates.length;
data.membership_batches = [{
vpc_key: A, state: 'ports', total: itemStates.length, succeeded: 1,
failed: 1, unknown: 0, action: 'attach', task_id: '599',
status_url: '/api/v1/tasks/599',
items: itemStates.map((itemState, index) => ({
instance_id: String(index + 1), state: itemState,
})),
}];
const t = await setup(href(A), data);
const manager = t.nodes.get('cloud-vpc-instance-manager');
const rowTaskButtons = manager.querySelectorAll('button')
.filter(button => button.textContent === '查看任务');
assert.equal(rowTaskButtons.length, 0,
'Batch rows must not duplicate the batch task-center action');
assert.equal(manager.querySelectorAll('button').filter(button =>
['重试连接', '重试清理'].includes(button.textContent)).length, 0,
'Batch rows must not expose per-instance retry actions');
for (const label of ['等待中', '执行中', '已完成', '失败']) {
assert.match(manager.textContent, new RegExp(label),
`Batch rows must render ${label}`);
}
assert.equal(t.nodes.get('cloud-vpc-batch-status').querySelectorAll('button')
.filter(button => button.textContent === '查看任务').length, 1,
'The batch must retain one task-center action');
}
{
const data = fixtures();
data.membership_batches = [{ vpc_key: A, batch_key: 'd'.repeat(32), state: 'blocked',
action: 'attach', task_id: '504', status_url: '/api/v1/tasks/504', can_cancel: true }];
const t = await setup(href(A), data);
t.respond(async (url, options) => !options.method ? t.data()
: { task_id: '504', status_url: '/api/v1/tasks/504' });
const cleanup = t.nodes.get('cloud-vpc-batch-status').querySelectorAll('[data-vpc-focus]')[0];
await cleanup.fire('click');
assert.equal(mutations(t)[0].url, `/api/v1/vpcs/${A}/ports/batches/${'d'.repeat(32)}/cancel`);
assert.equal(mutations(t)[0].requireTaskReceipt, true);
}
{
const data = fixtures();
data.instances[0].can_detach = false;
data.instances[0].can_retry_attach = true;
data.instances[0].port.state = 'preparing';
const t = await setup(href(A), data);
t.respond(async (url, options) => !options.method ? t.data()
: { task_id: '505', status_url: '/api/v1/tasks/505' });
await control(t, 'retry-1').fire('click');
assert.equal(mutations(t)[0].url, '/api/v1/vms/1/vpc');
assert.equal(mutations(t)[0].method, 'PUT');
assert.deepEqual(plain(mutations(t)[0].body), { vpc_key: A, confirm_restart: true });
}
{
const t = await setup(`${href(A)}/join`);
t.respond(async (url, options) => {
if (!options.method) return t.data();
throw Object.assign(Error('Network timeout'), { mutationMayHaveApplied: true });
});
for (let attempt = 0; attempt < 2; attempt++) { await select(t, 3); await submit(t); await t.confirm(); }
const requests = mutations(t);
assert.equal(requests.length, 2);
assert.equal(requests[0].headers['Idempotency-Key'], requests[1].headers['Idempotency-Key'],
'An explicit retry after an uncertain response must reuse the original key');
assert.equal(t.storage.size, 1);
}
{
const t = await setup(href(A));
t.respond(async (url, options) => !options.method ? t.data() : { task_id: '502', status_url: '/api/v1/tasks/502' });
await select(t, 1); await submit(t); await t.confirm();
assert.deepEqual(plain(mutations(t)[0].body), { action: 'detach', instance_ids: [1], confirm_restart: true });
t.observations[0].options.onTerminal({ status: 'failed', terminal: true,
error: '连接结果待核对', effect_may_have_applied: true, safe_to_resubmit: false });
await tick();
assert.match(t.nodes.get('cloud-vpcs-status').textContent, /请勿重复提交/);
assert.equal(mutations(t).length, 1);
}
{
const t = await setup('#/create');
const created = network(C, { name: 'new-vpc', port_count: 0, can_delete: true });
t.respond(async (url, options) => {
if (options.method === 'POST') {
const next = t.data(); next.items.push(created); next.used++;
return { vpc: created };
}
return t.data();
});
t.nodes.get('cloud-vpc-name').value = 'new-vpc'; t.nodes.get('cloud-vpc-region').value = '1';
await t.nodes.get('cloud-vpc-create-form').fire('submit');
assert.equal(t.location.search, `?vpc=${C}&view=join`);
assert.equal(mutations(t).length, 1, 'Creation must not attach or restart instances');
assert.deepEqual(plain(mutations(t)[0].body), { name: 'new-vpc', region_id: 1 });
}
{
const t = await setup(href(B));
t.respond(async (url, options) => options.method === 'DELETE' ? { deleted: true }
: { ...t.data(), items: t.data().items.filter(item => item.vpc_key !== B), used: 1 });
await t.nodes.get('cloud-vpc-delete').fire('click');
assert.equal(t.location.pathname, '/user/cloud/vpcs');
assert.equal(t.location.search, '');
assert.equal(mutations(t)[0].url, `/api/v1/vpcs/${B}`);
}
{
const data = fixtures(); data.used = data.maximum;
const t = await setup('#/create', data);
assert.equal(t.nodes.get('cloud-vpc-create-submit').disabled, true);
assert.match(t.nodes.get('cloud-vpc-create-availability').textContent, /配额/);
t.update({ ...data, used: 0, regions: [] });
assert.match(t.nodes.get('cloud-vpc-create-availability').textContent, /暂无可用地区/);
}
console.log('VPC frontend navigation, selection, confirmation, task isolation, idempotency and lifecycle behavior passed.');