v0.33.3_hotfix

scripts/tests/dashboard_resume_rate_charts_ui_test.mjs

@@ -0,0 +1,114 @@
+// Simulated DOM/status regression: no holes or artificial zeros after tab resume.
+// This intentionally does not exercise the running Rust server or real browser.
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const code = file => fs.readFileSync(path.join(root, 'src/admin/web', file), 'utf8');
+const html = code('index.html');
+
+class Element {
+    constructor() { this.attributes = new Map(); this.style = {}; this.textContent = ''; this.children = []; this.hidden = false; }
+    getAttribute(key) { return this.attributes.get(key) ?? null; }
+    setAttribute(key, value) { this.attributes.set(key, String(value)); }
+    removeAttribute(key) { this.attributes.delete(key); }
+    append(...children) { this.children.push(...children); }
+    replaceChildren(...children) { this.children = children; }
+}
+const ids = new Map([...html.matchAll(/\bid="([^"]+)"/g)].map(([, id]) => [id, new Element()]));
+const widgets = new Map([...html.matchAll(/data-dashboard-widget="([^"]+)"/g)].map(([, id]) => [id, new Element()]));
+const listeners = new Map();
+const document = {
+    hidden: false,
+    addEventListener: (type, handler) => listeners.set(type, handler),
+    querySelector: selector => widgets.get(selector.match(/^\[data-dashboard-widget="([^"]+)"\]$/)?.[1]) || null,
+    createElement: () => new Element(),
+};
+const samples = {
+    getLimit: () => 60,
+    trim: values => { if (values.length > 60) values.splice(0, values.length - 60); },
+    onChange: () => {},
+};
+const window = {
+    addEventListener() {}, rustProxyOverviewSamples: samples,
+    rustProxyRefresh: { current: () => ({ overview_seconds: 3 }) },
+};
+let now = 1000;
+const context = vm.createContext({
+    window, document, performance: { now: () => now }, currentPanel: 'overview', latestStatus: null,
+    $: id => ids.get(id) || null, fmt: (value, n = 0) => Number(value).toFixed(n),
+    fmtBytes: value => `${value} B`, t: value => value,
+});
+for (const file of ['app/rate-sampling.js', 'app/overview-wide-metrics.js', 'app/web-overview.js'])
+    vm.runInContext(code(file), context, { filename: file });
+
+const web = {
+    requests: 200, status_2xx: 190, status_3xx: 2, status_4xx: 5, status_5xx: 3,
+    static_requests: 100, php_requests: 80, other_requests: 20,
+    methods: [160, 20, 10, 5, 5], selected_status: [0, 0, 0, 0, 0, 0, 0, 0],
+    response_headers_us: 300000, response_bytes: 1200000, active_headers: 2,
+};
+const php = {
+    metrics: { requests: 80, response_headers_us: 100000, response_bytes: 320000, failures: Array(9).fill(0) },
+    capacity_limit: 6, capacity_used: 1,
+};
+const status = {
+    revision: 4,
+    metrics: { requests: 200, http1_requests: 120, http2_requests: 60, http3_requests: 20,
+        compression_gzip: 10, compression_br: 20, compression_zstd: 5, compression_deflate: 8 },
+    cache: { hits: 50, misses: 30 },
+    transform_metrics: { applied: 10, cache_hits: 5, skipped: 1, errors: 0 },
+    web_server_metrics: { demo: { web, php } },
+};
+function advance(delta) {
+    for (const key of Object.keys(status.metrics)) status.metrics[key] += delta;
+    for (const key of ['hits', 'misses']) status.cache[key] += delta;
+    for (const key of Object.keys(status.transform_metrics)) status.transform_metrics[key] += delta;
+    for (const key of ['requests', 'status_2xx', 'static_requests', 'php_requests', 'response_headers_us', 'response_bytes']) web[key] += delta;
+    for (const key of ['requests', 'response_headers_us', 'response_bytes']) php.metrics[key] += delta;
+}
+function render() { window.rustProxyWideOverview.render(status); window.rustProxyWebOverview.render(status); }
+const line = id => ids.get(id).getAttribute('d') || '';
+const compression = 'overview-wide-wide_compression_activity-gzip-line';
+const website = 'www_requests-all-line';
+const phpLine = 'www_php_requests-line';
+const starts = path => (path.match(/M/g) || []).length;
+
+render(); // no first-interval rate: establish baseline only
+now = 4000; advance(12); render();
+const beforeWide = line(compression), beforeWeb = line(website);
+const beforePhp = ids.get(phpLine).getAttribute('points');
+assert.equal(starts(beforeWide), 1);
+assert.equal(starts(beforeWeb), 1);
+assert.ok(beforePhp);
+
+// Background tab -> a new generation, regardless of counter increments.
+document.hidden = true; listeners.get('visibilitychange')();
+document.hidden = false;
+now = 100000; advance(600); render();
+assert.equal(ids.get('overview-wide-wide_compression_activity-summary').textContent, '-');
+assert.equal(ids.get('www_requests-value').textContent, '-');
+assert.equal(line(compression), beforeWide, 'wide rate chart must not receive a null point');
+assert.equal(line(website), beforeWeb, 'WWW rate chart must not receive a null point');
+assert.equal(ids.get(phpLine).getAttribute('points'), beforePhp, 'small PHP chart must preserve valid history');
+
+// A fresh interval then connects to previous valid samples without a gap.
+now = 103000; advance(9); render();
+assert.equal(starts(line(compression)), 1, 'wide chart must have one connected path');
+assert.equal(starts(line(website)), 1, 'WWW chart must have one connected path');
+assert.ok(line(compression).includes('L'));
+assert.ok(line(website).includes('L'));
+
+// Real measured zeros must continue to be plotted, not treated as pauses.
+now = 106000; render();
+assert.equal(ids.get('overview-wide-wide_compression_activity-summary').textContent, '0.0/s');
+assert.equal(ids.get('www_requests-value').textContent, '0.0/s');
+assert.equal(starts(line(compression)), 1);
+assert.equal(starts(line(website)), 1);
+
+assert.match(code('web-server.js'), /if \(record && rate !== null\) \{ previous\.push\(rate\)/,
+    'Web Server chart must also skip unavailable rates instead of plotting a zero dip');
+console.log('PASS: resumed wide/WWW/PHP charts stay connected; first invalid rate is unavailable; measured zero persists');

scripts/tests/web_server_0330_ui_test.py

@@ -116,6 +116,24 @@ with sync_playwright() as p:
         }""", second)
         assert not details.get('missing') and details['rows'] == 7, (width, details)
         assert '18 / 32' in details['text'], (width, details)
+        # The first reading after an overdue browser interval must establish a
+        # fresh baseline without adding a fake 0/s dip to the service chart.
+        continuity = page.evaluate("""([first, second, paused, resumed]) => {
+            const api = window.rustProxyWebServer;
+            const chart = document.querySelector('#web-service-list [data-web-live-id="site-A"] polyline');
+            const rate = document.querySelector('#web-service-list [data-web-live-field="rate"]');
+            window.__clock = 5000; api.renderLive(first);
+            window.__clock = 8000; api.renderLive(second);
+            const before = chart.getAttribute('points');
+            window.__clock = 100000; api.renderLive(paused);
+            const during = chart.getAttribute('points'), unavailable = rate.textContent;
+            window.__clock = 103000; api.renderLive(resumed);
+            return { before, during, unavailable, after: chart.getAttribute('points'), resumedRate: rate.textContent };
+        }""", [observation(2), observation(3), observation(10), observation(11)])
+        assert continuity['before'] == continuity['during'], (width, continuity)
+        assert continuity['unavailable'] == '-', (width, continuity)
+        assert continuity['resumedRate'] != '-', (width, continuity)
+        assert continuity['after'] != continuity['before'], (width, continuity)
         assert not errors, (width, errors)
         old = page.evaluate("""() => {
             currentPanel = 'overview';