speedtest/tests/e2e/worker-lifecycle.spec.js
sstidl a19536661e
Some checks failed
Docker / e2e (push) Has been cancelled
Docker / build (./Dockerfile, , ghcr.io/${{ github.repository }}) (push) Has been cancelled
Docker / build (./Dockerfile.alpine, -alpine, ghcr.io/${{ github.repository }}) (push) Has been cancelled
Fix Speedtest worker lifecycle cleanup (#852)
* Fix Speedtest worker lifecycle cleanup

* Preserve telemetry during aborted worker cleanup

---------

Co-authored-by: Stefan Stidl <sti-github@stidl.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: sstidl <12804296+sstidl@users.noreply.github.com>
2026-11-12 23:41:29 +01:00

255 lines
7.2 KiB
JavaScript

const fs = require("node:fs");
const path = require("node:path");
const { test, expect } = require("@playwright/test");
const speedtestSource = fs.readFileSync(
path.join(__dirname, "..", "..", "speedtest.js"),
"utf8"
);
async function installSpeedtest(page) {
await page.goto("about:blank");
await page.evaluate(() => {
window.__workers = [];
window.Worker = class FakeWorker {
constructor(url) {
this.url = url;
this.messages = [];
this.terminated = false;
this.terminateCount = 0;
window.__workers.push(this);
}
postMessage(message) {
this.messages.push(message);
}
terminate() {
this.terminated = true;
this.terminateCount++;
}
emit(data) {
this.onmessage(new MessageEvent("message", { data: JSON.stringify(data) }));
}
};
});
await page.addScriptTag({ content: speedtestSource });
}
function terminalState(testState) {
return { testState: testState };
}
test.describe("Speedtest worker lifecycle", () => {
test.beforeEach(async ({ page }) => {
await installSpeedtest(page);
});
test("terminates a worker after normal completion", async ({ page }) => {
const result = await page.evaluate((data) => {
const speedtest = new Speedtest();
speedtest.start();
const worker = window.__workers[0];
worker.emit(data);
return {
state: speedtest.getState(),
worker: speedtest.worker,
updater: speedtest.updater,
terminated: worker.terminated,
terminateCount: worker.terminateCount
};
}, terminalState(4));
expect(result).toEqual({
state: 4,
worker: null,
updater: null,
terminated: true,
terminateCount: 1
});
});
test("can start again after normal completion", async ({ page }) => {
const result = await page.evaluate((data) => {
const speedtest = new Speedtest();
speedtest.start();
const first = window.__workers[0];
first.emit(data);
speedtest.start();
const second = window.__workers[1];
return {
state: speedtest.getState(),
firstTerminated: first.terminated,
secondTerminated: second.terminated,
activeWorkerIsSecond: speedtest.worker === second
};
}, terminalState(4));
expect(result).toEqual({
state: 3,
firstTerminated: true,
secondTerminated: false,
activeWorkerIsSecond: true
});
});
test("can start again after an abort response", async ({ page }) => {
const result = await page.evaluate((data) => {
const speedtest = new Speedtest();
speedtest.start();
const first = window.__workers[0];
speedtest.abort();
first.emit(data);
speedtest.start();
const second = window.__workers[1];
return {
state: speedtest.getState(),
firstTerminated: first.terminated,
secondTerminated: second.terminated,
activeWorkerIsSecond: speedtest.worker === second
};
}, terminalState(5));
expect(result).toEqual({
state: 3,
firstTerminated: true,
secondTerminated: false,
activeWorkerIsSecond: true
});
});
test("does not terminate a worker started synchronously by onend", async ({ page }) => {
const result = await page.evaluate((data) => {
const speedtest = new Speedtest();
let endCalls = 0;
speedtest.onend = () => {
endCalls++;
speedtest.start();
};
speedtest.start();
const first = window.__workers[0];
first.emit(data);
const second = window.__workers[1];
return {
endCalls: endCalls,
state: speedtest.getState(),
firstTerminated: first.terminated,
secondTerminated: second.terminated,
activeWorkerIsSecond: speedtest.worker === second
};
}, terminalState(4));
expect(result).toEqual({
endCalls: 1,
state: 3,
firstTerminated: true,
secondTerminated: false,
activeWorkerIsSecond: true
});
});
test("forces a single aborted completion when a worker does not respond", async ({ page }) => {
await page.evaluate(() => {
window.__speedtest = new Speedtest();
window.__endCalls = 0;
window.__speedtest.onend = (aborted) => {
if (aborted) window.__endCalls++;
};
window.__speedtest.start();
window.__speedtest.abort();
});
await expect
.poll(() =>
page.evaluate(() => ({
state: window.__speedtest.getState(),
worker: window.__speedtest.worker,
updater: window.__speedtest.updater,
terminated: window.__workers[0].terminated,
endCalls: window.__endCalls
}))
)
.toEqual({
state: 4,
worker: null,
updater: null,
terminated: true,
endCalls: 1
});
await page.waitForTimeout(1100);
expect(await page.evaluate(() => window.__endCalls)).toBe(1);
});
test("keeps a responsive worker alive while aborted-run telemetry is pending", async ({ page }) => {
await page.evaluate(() => {
window.__speedtest = new Speedtest();
window.__speedtest.start();
window.__speedtest.abort();
window.__worker = window.__workers[0];
window.__telemetryStatus = setInterval(
() => window.__worker.emit({ testState: 3, abortPending: true }),
100
);
});
await page.waitForTimeout(1100);
await page.evaluate(() => clearInterval(window.__telemetryStatus));
expect(
await page.evaluate(() => ({
state: window.__speedtest.getState(),
terminated: window.__worker.terminated
}))
).toEqual({ state: 3, terminated: false });
const result = await page.evaluate((data) => {
window.__worker.emit(data);
return {
state: window.__speedtest.getState(),
terminated: window.__worker.terminated
};
}, terminalState(5));
expect(result).toEqual({ state: 4, terminated: true });
});
test("ignores delayed events and an old abort timeout after a new run starts", async ({ page }) => {
await page.evaluate((data) => {
window.__speedtest = new Speedtest();
window.__endCalls = 0;
window.__updates = 0;
window.__speedtest.onupdate = () => window.__updates++;
window.__speedtest.onend = () => {
window.__endCalls++;
window.__speedtest.start();
};
window.__speedtest.start();
window.__first = window.__workers[0];
window.__speedtest.abort();
window.__first.emit(data);
window.__second = window.__workers[1];
}, terminalState(5));
await page.waitForTimeout(1100);
const result = await page.evaluate((data) => {
window.__first.emit(data);
return {
endCalls: window.__endCalls,
updates: window.__updates,
state: window.__speedtest.getState(),
firstTerminated: window.__first.terminated,
secondTerminated: window.__second.terminated,
activeWorkerIsSecond: window.__speedtest.worker === window.__second
};
}, terminalState(5));
expect(result).toEqual({
endCalls: 1,
updates: 1,
state: 3,
firstTerminated: true,
secondTerminated: false,
activeWorkerIsSecond: true
});
});
});