feat(forecast): integrate full forecast charts and complete SDL visualization

2026-10-06 17:40:45 +00:00
parent 5687596799
commit 372b997876
30 changed files with 4377 additions and 53 deletions
@@ -0,0 +1,157 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import vm from 'node:vm';
+
+const source = await readFile(new URL('./public/app.js', import.meta.url), 'utf8');
+const html = await readFile(new URL('./public/index.html', import.meta.url), 'utf8');
+const plannerSource = await readFile(new URL('./public/netplan-v4.js', import.meta.url), 'utf8');
+
+function section(start, end) {
+  const first = source.indexOf(start), last = source.indexOf(end, first + start.length);
+  assert.ok(first >= 0 && last > first, `integration source boundaries: ${start}`);
+  return source.slice(first, last);
+}
+const mountSource = section('  var integratedPlanner = null;', '  function faultDate(');
+const viewSource = section('  function showView(name)', '  async function loadPortalHealth(');
+const authSource = section('  function showAuth()', '  function workspaceOptions(');
+const importPattern = /import\(("\/netplan-v4\.js[^"\n]*")\)/;
+assert.match(mountSource, importPattern);
+const executableSource = mountSource.replace(importPattern, 'importPlanner($1)') + '\n' + viewSource + '\n' + authSource;
+
+function deferred() {
+  let resolve, reject;
+  const promise = new Promise((done, fail) => { resolve = done; reject = fail; });
+  return { promise, resolve, reject };
+}
+const settle = () => new Promise(resolve => setImmediate(resolve));
+function node(id, active = false) {
+  const classes = new Set(active ? ['active'] : []);
+  return {
+    id, textContent: '',
+    replaceChildren() { this.textContent = ''; },
+    classList: {
+      contains(name) { return classes.has(name); },
+      add(name) { classes.add(name); },
+      remove(name) { classes.delete(name); },
+      toggle(name, enabled) { if (enabled) classes.add(name); else classes.delete(name); }
+    }
+  };
+}
+function harness(options = {}) {
+  const nodes = new Map();
+  const byId = id => {
+    if (!nodes.has(id)) nodes.set(id, node(id, id === 'view-forecast' && options.active !== false));
+    return nodes.get(id);
+  };
+  const calls = { imports: [], api: [], mounted: [], disposed: [], rendered: [], legacyStatus: [], configuration: [] };
+  let plant = { id: 'A', installation_id: 'installation-A', manager_variant: 'manager_standard' };
+  const plannerModule = {
+    mountPlanner(host, config) {
+      calls.mounted.push(config.plantId); host.textContent = `mounted:${config.plantId}`;
+      return { ready: options.ready ? options.ready(config.plantId) : Promise.resolve(), dispose() { calls.disposed.push(config.plantId); host.replaceChildren(); } };
+    }
+  };
+  const state = { session: { csrfToken: 'test-only' }, forecastRequest: 0, forecastHistoryDays: 1 };
+  const context = vm.createContext({
+    state, byId, encodeURIComponent,
+    document: { querySelectorAll(selector) { return selector === '.view' ? [byId('view-forecast'), byId('view-overview')] : []; } },
+    history: { replaceState() {} }, location: { pathname: '/', search: '' }, window: { scrollTo() {} },
+    selectedPlant() { return plant; }, managerLabel(value) { return value; },
+    resetForecastChart() {}, renderForecastLicenseWarning() {},
+    setForecastState(message) { calls.legacyStatus.push(message); },
+    renderForecastResult(result) { calls.rendered.push(result); },
+    loadForecastConfiguration(selected, requestId) { calls.configuration.push({ plant: selected.id, requestId }); return Promise.resolve(); },
+    loadInvitations() {}, loadOrders() {}, updateFaults() {},
+    api(url) { calls.api.push(url); return options.api ? options.api(url) : Promise.resolve({ status: 'available', source: url }); },
+    importPlanner(url) { calls.imports.push(url); return options.importPlanner ? options.importPlanner(url, plannerModule) : Promise.resolve(plannerModule); }
+  });
+  vm.runInContext(executableSource + '\nthis.integration = {updateForecast, showView, showAuth, currentPlanner: () => integratedPlanner};', context);
+  return { state, calls, byId, module: plannerModule, ...context.integration, select(id, linked = true) { plant = id ? { id, installation_id: linked ? `installation-${id}` : null, manager_variant: 'manager_standard' } : null; } };
+}
+
+test('release assets expose the host, stylesheet and relative chart dependency', async () => {
+  assert.equal((html.match(/id="forecastPlanner"/g) || []).length, 1);
+  assert.match(html, /href="\/netplan-v4\.css\?[^"\s]+"/);
+  assert.equal(html.match(/src="\/app\.js[^"\s]*"/)?.[0], 'src="/app.js?v=20261006-forecast"', 'entrypoint version must invalidate the pre-integration cached app');
+  assert.ok(html.indexOf('id="forecastPlanner"') > html.indexOf('id="view-forecast"'));
+  assert.match(plannerSource, /export function mountPlanner\(/);
+  const dependency = plannerSource.match(/from ['"](\.\/forecast-chart\.js)['"]/);
+  assert.ok(dependency, 'chart import remains relative to the deployed planner module');
+  assert.ok((await readFile(new URL('./public/' + dependency[1], import.meta.url), 'utf8')).includes('export function renderForecastChart'));
+});
+
+test('inactive views and unlinked plants do not mount the planner', async () => {
+  const hidden = harness({ active: false }); await hidden.updateForecast(); await settle();
+  assert.equal(hidden.calls.imports.length, 0); assert.equal(hidden.calls.api.length, 0);
+  const unlinked = harness(); unlinked.select('A', false); await unlinked.updateForecast(); await settle();
+  assert.equal(unlinked.calls.mounted.length, 0); assert.equal(unlinked.calls.api.length, 1);
+});
+
+test('changing plants invalidates stale imports and legacy responses', async () => {
+  const imports = [deferred(), deferred()], results = [deferred(), deferred()];
+  let importIndex = 0, resultIndex = 0;
+  const app = harness({ importPlanner: () => imports[importIndex++].promise, api: () => results[resultIndex++].promise });
+  const first = app.updateForecast(); app.select('B'); const second = app.updateForecast();
+  imports[0].resolve(app.module); await settle(); assert.deepEqual(app.calls.mounted, []);
+  imports[1].resolve(app.module); results[1].resolve({ status: 'available', plant: 'B' });
+  results[0].resolve({ status: 'available', plant: 'A' }); await Promise.all([first, second]); await settle();
+  assert.deepEqual(app.calls.mounted, ['B']);
+  assert.deepEqual(app.calls.rendered.map(result => result.plant), ['B']);
+  assert.deepEqual(app.calls.configuration.map(entry => entry.plant), ['B']);
+});
+
+test('leaving the forecast view disposes the mounted planner and invalidates pending imports', async () => {
+  const app = harness(); await app.updateForecast(); await settle();
+  const revision = app.state.forecastRequest; app.showView('overview');
+  assert.equal(app.state.forecastRequest, revision + 1); assert.deepEqual(app.calls.disposed, ['A']);
+  assert.equal(app.currentPlanner(), null);
+  const imported = deferred(), pending = harness({ importPlanner: () => imported.promise });
+  await pending.updateForecast(); pending.showView('overview'); imported.resolve(pending.module); await settle();
+  assert.deepEqual(pending.calls.mounted, []);
+});
+
+test('returning to authentication disposes the planner and invalidates pending responses', async () => {
+  const ready = deferred(), app = harness({ ready: () => ready.promise });
+  await app.updateForecast(); await settle();
+  const revision = app.state.forecastRequest; app.showAuth();
+  assert.equal(app.state.forecastRequest, revision + 1);
+  assert.deepEqual(app.calls.disposed, ['A']); assert.equal(app.currentPlanner(), null);
+  assert.equal(app.byId('portalApp').classList.contains('hidden'), true);
+  ready.reject(new Error('late post-logout failure')); await settle();
+  assert.equal(app.byId('forecastPlanner').textContent, '');
+
+  const imported = deferred(), result = deferred();
+  const pending = harness({ importPlanner: () => imported.promise, api: () => result.promise });
+  const update = pending.updateForecast(); pending.showAuth();
+  imported.resolve(pending.module); result.resolve({ status: 'available', plant: 'A' });
+  await update; await settle();
+  assert.deepEqual(pending.calls.mounted, []);
+  assert.deepEqual(pending.calls.rendered, []);
+  assert.deepEqual(pending.calls.configuration, []);
+});
+
+test('legacy API failures do not clear or prevent the independent planner', async () => {
+  const app = harness({ api: () => Promise.reject(new Error('legacy unavailable')) });
+  await app.updateForecast(); await settle();
+  assert.deepEqual(app.calls.mounted, ['A']);
+  assert.equal(app.byId('forecastPlanner').textContent, 'mounted:A');
+  assert.equal(app.calls.legacyStatus.at(-1), 'legacy unavailable');
+});
+
+test('planner import failures remain inside the planner host', async () => {
+  const app = harness({ importPlanner: () => Promise.reject(new Error('planner unavailable')) });
+  await app.updateForecast(); await settle();
+  assert.equal(app.calls.rendered.length, 1);
+  assert.match(app.byId('forecastPlanner').textContent, /planner unavailable/);
+  assert.ok(!app.calls.legacyStatus.includes('planner unavailable'));
+});
+
+test('late planner errors cannot overwrite the next plant after disposal', async () => {
+  const ready = deferred(), app = harness({ ready: id => id === 'A' ? ready.promise : Promise.resolve() });
+  await app.updateForecast(); await settle(); app.select('B'); await app.updateForecast(); await settle();
+  ready.reject(new Error('late old failure')); await settle();
+  assert.deepEqual(app.calls.disposed, ['A']);
+  assert.deepEqual(app.calls.mounted, ['A', 'B']);
+  assert.equal(app.byId('forecastPlanner').textContent, 'mounted:B');
+});