Jeppe Bundgaard
ebcd52a019
- Implement `endpoint_mode` (manual/auto) and related configuration in i18n across multiple locales. - Add new utility methods for channel rollback and runtime confirmation workflows. - Update unit and E2E tests to cover runtime refresh behavior, channel switching mechanics, and release references. - Enhance `SessionUser` and related services to improve error handling during release runtime refresh. - Add data-test attributes for frontend components to support improved test coverage.
444 lines
15 KiB
JavaScript
444 lines
15 KiB
JavaScript
import { expect, test } from "@playwright/test";
|
|
import { mockApi, seedAuthenticatedState } from "./support/network.js";
|
|
|
|
const json = (body, status = 200) => ({
|
|
status,
|
|
contentType: "application/json",
|
|
headers: {
|
|
"access-control-allow-origin": "*",
|
|
"access-control-allow-headers":
|
|
"Content-Type, Authorization, X-Customer-Number, X-Release-Trace, X-Release-Channel, X-Frontend-Version, *",
|
|
"access-control-allow-methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
|
|
},
|
|
body: JSON.stringify(body),
|
|
});
|
|
const GUARD_TIMEOUT_MS = 30_000;
|
|
|
|
const unavailableRuntime = {
|
|
generated_at: "2026-05-19T09:00:00.000Z",
|
|
trace_id: "trace-unavailable-channel",
|
|
channel: {
|
|
id: 2,
|
|
slug: "canary",
|
|
name: "Canary",
|
|
description: "Early production validation before broader rollout.",
|
|
enabled: true,
|
|
default_channel: false,
|
|
},
|
|
versions: { frontend: null, api: null, bundle_id: null },
|
|
availability: {
|
|
configured: false,
|
|
missing: ["release_bundle", "frontend_version", "api_version"],
|
|
status: "unconfigured",
|
|
},
|
|
capture_policy: {
|
|
enabled: false,
|
|
capture_level: "metadata",
|
|
all_failure_metadata: true,
|
|
retention_days: 14,
|
|
},
|
|
};
|
|
|
|
const availableRuntime = () => ({
|
|
...unavailableRuntime,
|
|
versions: {
|
|
frontend: { version_label: "frontend-canary", commit_sha: "c0ffee" },
|
|
api: { version_label: "api-canary", commit_sha: "feedface" },
|
|
bundle_id: 31,
|
|
},
|
|
availability: {
|
|
configured: true,
|
|
missing: [],
|
|
status: "ready",
|
|
},
|
|
});
|
|
|
|
const runtimeWithSelectableReleaseDetails = () => ({
|
|
...unavailableRuntime,
|
|
versions: {
|
|
frontend: null,
|
|
api: null,
|
|
bundle_id: null,
|
|
},
|
|
availability: {
|
|
configured: false,
|
|
missing: ["release_bundle"],
|
|
status: "unconfigured",
|
|
},
|
|
available_channels: [
|
|
{
|
|
channel: {
|
|
id: 1,
|
|
slug: "stable",
|
|
name: "Stable",
|
|
description: "Standard production channel.",
|
|
enabled: true,
|
|
default_channel: true,
|
|
},
|
|
versions: {
|
|
frontend: {
|
|
version_label: "frontend-stable",
|
|
commit_sha: "abc1234567890000111122223333444455556666",
|
|
deployed_at: "2026-05-18T07:45:00.000Z",
|
|
},
|
|
api: {
|
|
version_label: "api-stable",
|
|
commit_sha: "def456789abc0000111122223333444455556666",
|
|
deployed_at: "2026-05-18T07:47:00.000Z",
|
|
},
|
|
bundle_id: 31,
|
|
bundle: {
|
|
id: 31,
|
|
promoted_at: "2026-05-18T08:00:00.000Z",
|
|
},
|
|
},
|
|
availability: {
|
|
configured: true,
|
|
missing: [],
|
|
status: "ready",
|
|
},
|
|
},
|
|
{
|
|
channel: unavailableRuntime.channel,
|
|
versions: {
|
|
frontend: {
|
|
version_label: "frontend-canary",
|
|
commit_sha: "c0ffee0000001111222233334444555566667777",
|
|
deployed_at: "2026-05-19T08:15:00.000Z",
|
|
},
|
|
api: {
|
|
version_label: "api-canary",
|
|
commit_sha: "feedface00001111222233334444555566667777",
|
|
deployed_at: "2026-05-19T08:18:00.000Z",
|
|
},
|
|
bundle_id: null,
|
|
},
|
|
availability: {
|
|
configured: false,
|
|
missing: ["release_bundle"],
|
|
status: "unconfigured",
|
|
},
|
|
},
|
|
],
|
|
});
|
|
|
|
const runtimeWithFailingBetaSwitch = () => ({
|
|
generated_at: "2026-05-19T09:10:00.000Z",
|
|
trace_id: "trace-stable-channel",
|
|
channel: {
|
|
id: 1,
|
|
slug: "stable",
|
|
name: "Stable",
|
|
description: "Standard production channel.",
|
|
enabled: true,
|
|
default_channel: true,
|
|
},
|
|
versions: {
|
|
frontend: { version_label: "frontend-stable", commit_sha: "abc123" },
|
|
api: { version_label: "api-stable", commit_sha: "def456" },
|
|
bundle_id: 31,
|
|
},
|
|
availability: {
|
|
configured: true,
|
|
missing: [],
|
|
status: "ready",
|
|
},
|
|
available_channels: [
|
|
{
|
|
channel: {
|
|
id: 1,
|
|
slug: "stable",
|
|
name: "Stable",
|
|
description: "Standard production channel.",
|
|
enabled: true,
|
|
default_channel: true,
|
|
},
|
|
availability: {
|
|
configured: true,
|
|
missing: [],
|
|
status: "ready",
|
|
},
|
|
},
|
|
{
|
|
channel: {
|
|
id: 3,
|
|
slug: "beta",
|
|
name: "Beta",
|
|
description: "Beta validation channel.",
|
|
enabled: true,
|
|
default_channel: false,
|
|
},
|
|
availability: {
|
|
configured: true,
|
|
missing: [],
|
|
status: "ready",
|
|
},
|
|
},
|
|
],
|
|
});
|
|
|
|
async function boot(page, runtime = unavailableRuntime, locale = "en") {
|
|
await page.addInitScript((selectedLocale) => {
|
|
window.localStorage.setItem("locale", selectedLocale);
|
|
window.localStorage.removeItem("release_channel_unavailable_ignore_until");
|
|
}, locale);
|
|
|
|
await mockApi(page, {
|
|
authenticated: true,
|
|
permissions: ["user"],
|
|
sessionData: {
|
|
runtime_config: {
|
|
release: runtime,
|
|
},
|
|
},
|
|
});
|
|
await seedAuthenticatedState(page, "release-channel-token");
|
|
}
|
|
|
|
test("users assigned to an unconfigured release channel can ignore the guard temporarily", async ({ page }) => {
|
|
await boot(page);
|
|
await page.route("**/release/runtime", async (route) => {
|
|
await route.fulfill(json({ data: unavailableRuntime }));
|
|
});
|
|
|
|
await page.goto("/user", { waitUntil: "domcontentloaded" });
|
|
const guard = page.getByTestId("release-channel-unavailable-page");
|
|
await expect(guard).toBeVisible({ timeout: GUARD_TIMEOUT_MS });
|
|
await expect(guard).toContainText("Release channel is not ready");
|
|
await expect(guard).toContainText("Canary");
|
|
await expect(page.getByTestId("release-channel-missing")).toContainText("Release bundle");
|
|
await expect(page.getByTestId("release-channel-missing")).toContainText("Frontend version");
|
|
await expect(page.getByTestId("release-channel-missing")).toContainText("API version");
|
|
await expect(page.getByTestId("release-channel-next-check")).toContainText("Checking again in");
|
|
|
|
await page.getByTestId("release-channel-ignore").click();
|
|
await expect(guard).toHaveCount(0);
|
|
await page.evaluate(() => window.localStorage.removeItem("release_channel_unavailable_ignore_until"));
|
|
});
|
|
|
|
test("invalid release runtime JSON shows the unavailable guard instead of crashing bootstrap", async ({ page }) => {
|
|
const internalRuntime = {
|
|
...unavailableRuntime,
|
|
channel: {
|
|
...unavailableRuntime.channel,
|
|
slug: "internal",
|
|
name: "Internal",
|
|
default_channel: false,
|
|
},
|
|
versions: { frontend: null, api: null, bundle_id: null },
|
|
availability: {
|
|
configured: false,
|
|
missing: ["release_runtime"],
|
|
status: "unconfigured",
|
|
},
|
|
};
|
|
const consoleErrors = [];
|
|
|
|
page.on("console", (message) => {
|
|
if (message.type() === "error") {
|
|
consoleErrors.push(message.text());
|
|
}
|
|
});
|
|
await boot(page, internalRuntime);
|
|
await page.addInitScript(() => {
|
|
window.localStorage.setItem("release_channel_selected_slug", "internal");
|
|
});
|
|
await page.route("**/release/runtime**", async (route) => {
|
|
await route.fulfill({
|
|
status: 200,
|
|
contentType: "text/html",
|
|
headers: {
|
|
"access-control-allow-origin": "*",
|
|
"access-control-allow-headers":
|
|
"Content-Type, Authorization, X-Customer-Number, X-Release-Trace, X-Release-Channel, X-Frontend-Version, *",
|
|
"access-control-allow-methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
|
|
},
|
|
body: '<br /><b>Warning</b> Composer autoload warning {"success":true}',
|
|
});
|
|
});
|
|
|
|
await page.goto("/user", { waitUntil: "domcontentloaded" });
|
|
const guard = page.getByTestId("release-channel-unavailable-page");
|
|
await expect(guard).toBeVisible({ timeout: GUARD_TIMEOUT_MS });
|
|
await expect(guard).toContainText("Internal");
|
|
await expect(page.getByTestId("release-channel-missing")).toContainText("Release runtime");
|
|
expect(consoleErrors.join("\n")).not.toContain("Cannot read properties of null");
|
|
});
|
|
|
|
test("selected channel auth session 404 shows the release channel guard", async ({ page }) => {
|
|
const internalRuntime = {
|
|
...availableRuntime(),
|
|
channel: {
|
|
...unavailableRuntime.channel,
|
|
slug: "internal",
|
|
name: "Internal",
|
|
default_channel: false,
|
|
},
|
|
frontend_base_url: null,
|
|
api_base_url: "https://api-v2.truckwash.io/internal/api",
|
|
urls: {
|
|
frontend_base_url: null,
|
|
api_base_url: "https://api-v2.truckwash.io/internal/api",
|
|
},
|
|
availability: {
|
|
configured: true,
|
|
missing: [],
|
|
status: "ready",
|
|
},
|
|
};
|
|
const channelApiRequests = [];
|
|
|
|
await boot(page, internalRuntime);
|
|
await page.addInitScript(() => {
|
|
window.localStorage.setItem("release_channel_selected_slug", "internal");
|
|
});
|
|
await page.route("**/release/runtime**", async (route) => {
|
|
await route.fulfill(json({ data: internalRuntime }));
|
|
});
|
|
await page.route("https://api-v2.truckwash.io/internal/api/auth/session**", async (route) => {
|
|
channelApiRequests.push(route.request().url());
|
|
await route.fulfill(json({ data: { message: "Not found" } }, 404));
|
|
});
|
|
|
|
await page.goto("/user", { waitUntil: "domcontentloaded" });
|
|
|
|
const guard = page.getByTestId("release-channel-unavailable-page");
|
|
await expect(guard).toBeVisible({ timeout: GUARD_TIMEOUT_MS });
|
|
await expect(guard).toContainText("Internal");
|
|
await expect(page.getByTestId("release-channel-missing")).toContainText("API URL");
|
|
await expect(page.locator(".swal2-popup")).toHaveCount(0);
|
|
await expect.poll(() => channelApiRequests.length).toBeGreaterThan(0);
|
|
expect(channelApiRequests.every((url) => url.startsWith("https://api-v2.truckwash.io/internal/api/"))).toBe(true);
|
|
});
|
|
|
|
test("release channel choices show git commit and release time when available", async ({ page }) => {
|
|
const runtime = runtimeWithSelectableReleaseDetails();
|
|
await boot(page, runtime);
|
|
await page.route("**/release/runtime", async (route) => {
|
|
await route.fulfill(json({ data: runtime }));
|
|
});
|
|
|
|
await page.goto("/user", { waitUntil: "domcontentloaded" });
|
|
const guard = page.getByTestId("release-channel-unavailable-page");
|
|
await expect(guard).toBeVisible({ timeout: GUARD_TIMEOUT_MS });
|
|
|
|
const canary = page.getByTestId("release-channel-option-canary");
|
|
await expect(canary).toBeVisible();
|
|
await expect(canary).toContainText("Release bundle");
|
|
await expect(page.getByTestId("release-channel-option-canary-frontend-release")).toContainText("c0ffee000000");
|
|
await expect(page.getByTestId("release-channel-option-canary-frontend-release")).toContainText(
|
|
/May 19, 2026|19 May 2026/
|
|
);
|
|
await expect(page.getByTestId("release-channel-option-canary-api-release")).toContainText("feedface0000");
|
|
await expect(page.getByTestId("release-channel-option-canary-api-release")).toContainText(/May 19, 2026|19 May 2026/);
|
|
|
|
await expect(page.getByTestId("release-channel-option-stable-bundle-release")).toContainText("#31");
|
|
await expect(page.getByTestId("release-channel-option-stable-bundle-release")).toContainText(
|
|
/May 18, 2026|18 May 2026/
|
|
);
|
|
});
|
|
|
|
test("failed sidebar release channel switches keep the previous channel active", async ({ page }, testInfo) => {
|
|
test.skip(testInfo.project.name.includes("mobile"), "The sidebar release selector is hidden in the mobile layout.");
|
|
|
|
const runtime = runtimeWithFailingBetaSwitch();
|
|
await boot(page, runtime);
|
|
const runtimeRequests = [];
|
|
|
|
await page.route("**/release/runtime**", async (route) => {
|
|
const url = new URL(route.request().url());
|
|
const selectedChannel = url.searchParams.get("release_channel") || "";
|
|
runtimeRequests.push(selectedChannel || "default");
|
|
if (selectedChannel === "beta") {
|
|
await route.fulfill(json({ data: { message: "Beta runtime unavailable" } }, 502));
|
|
return;
|
|
}
|
|
await route.fulfill(json({ data: runtime }));
|
|
});
|
|
|
|
await page.goto("/user", { waitUntil: "domcontentloaded" });
|
|
const stable = page.getByTestId("release-channel-option-stable");
|
|
const beta = page.getByTestId("release-channel-option-beta");
|
|
|
|
await expect(stable).toBeVisible({ timeout: GUARD_TIMEOUT_MS });
|
|
await expect(stable).toHaveAttribute("aria-pressed", "true");
|
|
await expect(beta).toHaveAttribute("aria-pressed", "false");
|
|
|
|
await beta.click();
|
|
await expect(stable).toHaveAttribute("aria-pressed", "true");
|
|
await expect(beta).toHaveAttribute("aria-pressed", "false");
|
|
await expect(page.getByRole("alert")).toContainText("previous channel is still active");
|
|
await expect.poll(() => page.evaluate(() => window.localStorage.getItem("release_channel_selected_slug"))).toBeNull();
|
|
expect(runtimeRequests).toContain("beta");
|
|
});
|
|
|
|
test("predefined release channel text is localized on the guard page", async ({ page }) => {
|
|
const internalRuntime = {
|
|
...unavailableRuntime,
|
|
channel: {
|
|
...unavailableRuntime.channel,
|
|
slug: "internal",
|
|
name: "Internal",
|
|
description: "Internal staff and superuser validation channel.",
|
|
},
|
|
versions: {
|
|
frontend: {
|
|
version_label: "frontend-internal",
|
|
commit_sha: "130cc2fc106a1111222233334444555566667777",
|
|
deployed_at: "2026-05-20T09:32:00.000Z",
|
|
},
|
|
api: {
|
|
version_label: "api-internal",
|
|
commit_sha: "24ac681365511111222233334444555566667777",
|
|
deployed_at: "2026-05-20T09:32:00.000Z",
|
|
},
|
|
bundle_id: 10,
|
|
bundle: {
|
|
id: 10,
|
|
promoted_at: "2026-05-20T09:33:00.000Z",
|
|
},
|
|
},
|
|
availability: {
|
|
configured: false,
|
|
missing: ["frontend_base_url"],
|
|
status: "unconfigured",
|
|
},
|
|
};
|
|
|
|
await boot(page, internalRuntime, "da");
|
|
await page.route("**/release/runtime", async (route) => {
|
|
await route.fulfill(json({ data: internalRuntime }));
|
|
});
|
|
|
|
await page.goto("/user", { waitUntil: "domcontentloaded" });
|
|
const guard = page.getByTestId("release-channel-unavailable-page");
|
|
await expect(guard).toBeVisible({ timeout: GUARD_TIMEOUT_MS });
|
|
await expect(guard).toContainText("Release-kanalen er ikke klar");
|
|
await expect(guard).toContainText("Intern");
|
|
await expect(guard).toContainText("Intern kanal til medarbejdere");
|
|
await expect(page.getByTestId("release-channel-missing")).toContainText("Frontend-URL");
|
|
await expect(page.getByTestId("release-channel-missing")).not.toContainText("frontend_base_url");
|
|
await expect(guard).not.toContainText("Internal staff");
|
|
await expect(guard).not.toContainText(/\binternal\b/);
|
|
await expect(guard).not.toContainText(/\p{L}\?\p{L}|\?\p{L}/u);
|
|
});
|
|
|
|
test("users assigned to an unconfigured release channel can check again when it becomes ready", async ({ page }) => {
|
|
await boot(page);
|
|
let releaseRuntime = unavailableRuntime;
|
|
|
|
await page.route("**/release/runtime", async (route) => {
|
|
await route.fulfill(json({ data: releaseRuntime }));
|
|
});
|
|
|
|
await page.goto("/user", { waitUntil: "domcontentloaded" });
|
|
const guard = page.getByTestId("release-channel-unavailable-page");
|
|
await expect(guard).toBeVisible({ timeout: GUARD_TIMEOUT_MS });
|
|
|
|
const currentUrl = page.url();
|
|
releaseRuntime = availableRuntime();
|
|
await page.getByTestId("release-channel-check-again").click();
|
|
await expect(guard).toHaveCount(0);
|
|
await expect(page).toHaveURL(currentUrl);
|
|
});
|