@podosoft/podokit 1.5.0 → 1.6.1

package/dist/templates/modules/admin-dashboard/files/tests/api/exclusive.api.spec.ts

@@ -1,75 +0,0 @@
-import { expect, test } from "@playwright/test";
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, utimesSync, writeFileSync } from "node:fs";
-import { rm } from "node:fs/promises";
-import { join } from "node:path";
-import { exclusive, lockPath } from "../helpers/exclusive";
-
-// Checks the lock that specs changing shared settings hold. Names are unique per
-// run so these never wait on, or release, a lock a real spec holds.
-const unique = (label: string): string => `self-test-${label}-${process.pid}-${Date.now()}`;
-
-test("exclusive releases its locks when the body fails", async () => {
-  const first = unique("first");
-  const second = unique("second");
-  await expect(
-    exclusive([second, first], async () => {
-      expect(existsSync(lockPath(first))).toBe(true);
-      expect(existsSync(lockPath(second))).toBe(true);
-      throw new Error("body failed");
-    }),
-  ).rejects.toThrow("body failed");
-  expect(existsSync(lockPath(first))).toBe(false);
-  expect(existsSync(lockPath(second))).toBe(false);
-
-  // The next holder gets the lock without waiting.
-  const started = Date.now();
-  await exclusive(first, async () => undefined);
-  expect(Date.now() - started).toBeLessThan(1_000);
-});
-
-test("exclusive runs holders of one lock one at a time", async () => {
-  const name = unique("serial");
-  const events: string[] = [];
-  const hold = (id: string): Promise<void> =>
-    exclusive(name, async () => {
-      events.push(`${id} start`);
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      events.push(`${id} end`);
-    });
-  await Promise.all([hold("a"), hold("b")]);
-  expect(events.map((event) => event.split(" ")[1])).toEqual(["start", "end", "start", "end"]);
-  expect(existsSync(lockPath(name))).toBe(false);
-});
-
-test("exclusive takes over a lock left by a run that was killed", async () => {
-  const name = unique("stale");
-  mkdirSync(lockPath(name));
-  const longAgo = new Date(Date.now() - 10 * 60_000);
-  utimesSync(lockPath(name), longAgo, longAgo);
-  await expect(exclusive(name, async () => "acquired")).resolves.toBe("acquired");
-  expect(existsSync(lockPath(name))).toBe(false);
-});
-
-test("exclusive takes over a lock whose holder exited, such as after Ctrl-C", async () => {
-  const name = unique("exited");
-  const exited = spawnSync(process.execPath, ["-e", ""]).pid;
-  mkdirSync(lockPath(name));
-  writeFileSync(join(lockPath(name), "owner"), String(exited));
-  const started = Date.now();
-  await expect(exclusive(name, async () => "acquired")).resolves.toBe("acquired");
-  expect(Date.now() - started).toBeLessThan(1_000);
-  expect(existsSync(lockPath(name))).toBe(false);
-});
-
-test("exclusive waits for a lock whose holder is still running", async () => {
-  const name = unique("alive");
-  mkdirSync(lockPath(name));
-  writeFileSync(join(lockPath(name), "owner"), String(process.pid));
-  const waiting = exclusive(name, async () => "acquired");
-  await new Promise((resolve) => setTimeout(resolve, 500));
-  expect(existsSync(lockPath(name))).toBe(true);
-  // The holder finishes; the waiter then gets the lock.
-  await rm(lockPath(name), { recursive: true, force: true });
-  await expect(waiting).resolves.toBe("acquired");
-});

package/dist/templates/modules/admin-dashboard/files/tests/helpers/exclusive.ts

@@ -1,80 +0,0 @@
-import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-// Locks for server-wide settings that specs in more than one file change. The
-// suite runs on one worker by default; with --workers above 1, specs of the api
-// and ui projects run at the same time, and two that flip the same setting
-// would undo each other mid-test:
-//
-// - `require2fa`, `magic-link`, `oidc-provider`: feature flags
-// - `session-idle-timeout`: automatic logout in the auth configuration
-// - `social-providers`: any social sign-in provider in the auth configuration
-// - `site-general`: the General settings form, which saves all of its fields
-//   (name, footer, locale, maintenance mode, public sign-up, ...) at once
-// - `site-theme`: the Appearance settings
-//
-// A spec that holds a lock calls `test.slow()`, since waiting for another
-// holder counts against its timeout.
-
-// Longer than any spec holds a lock. A lock whose holder process has exited is
-// taken over at once; this bounds the wait when the holder cannot be checked.
-const STALE_MS = 120_000;
-const OWNER_FILE = "owner";
-
-/** The lock directory for `name`, shared by every worker on this machine. */
-export function lockPath(name: string): string {
-  return join(tmpdir(), `podokit-e2e-${name}.lock`);
-}
-
-/** Whether the worker that holds `lock` has exited, such as after Ctrl-C. */
-async function holderExited(lock: string): Promise<boolean> {
-  const pid = Number(await readFile(join(lock, OWNER_FILE), "utf8").catch(() => ""));
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return false;
-  } catch (error) {
-    return (error as NodeJS.ErrnoException).code === "ESRCH";
-  }
-}
-
-async function acquire(lock: string): Promise<void> {
-  for (;;) {
-    const created = await mkdir(lock).then(
-      () => true,
-      (error: NodeJS.ErrnoException) => {
-        if (error.code === "EEXIST") return false;
-        throw error;
-      },
-    );
-    if (created) {
-      await writeFile(join(lock, OWNER_FILE), String(process.pid)).catch(async (error: unknown) => {
-        await rm(lock, { recursive: true, force: true });
-        throw error;
-      });
-      return;
-    }
-    const age = await stat(lock).then((info) => Date.now() - info.mtimeMs, () => 0);
-    if (age > STALE_MS || (await holderExited(lock))) await rm(lock, { recursive: true, force: true });
-    else await new Promise((resolve) => setTimeout(resolve, 200));
-  }
-}
-
-/** Runs `body` while no other Playwright worker on this machine holds any of
- *  the named locks, and releases them however `body` ends. */
-export async function exclusive<T>(names: string | string[], body: () => Promise<T>): Promise<T> {
-  // One acquisition order for every caller, so two specs that each need
-  // several locks cannot wait on each other.
-  const locks = [...new Set([names].flat())].sort().map(lockPath);
-  const held: string[] = [];
-  try {
-    for (const lock of locks) {
-      await acquire(lock);
-      held.push(lock);
-    }
-    return await body();
-  } finally {
-    for (const lock of held.reverse()) await rm(lock, { recursive: true, force: true });
-  }
-}