@7365admin1/layer-common 4.0.3-staging.233 → 4.0.3-staging.235

package/utils/promo-code-form.test.ts

@@ -1,437 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import {
-  promoExpiryDate,
-  promoCodeFormValues,
-  promoCodeUpdatePayload,
-  validatePromoCodeEdit,
-  promoCodeApiError,
-} from "./promo-code-form.ts";
-
-/**
- * THE PROMO CODE EDITOR AND THE THREE WRITE CALLS BEHIND IT.
- *
- * Two halves, both pinned here:
- *
- *  1. the rules the edit form applies before it sends anything - taken from
- *     the MERGED backend (`promoCodeUpdateSchema` in `@7365admin1/core`), not
- *     from a guess about it;
- *  2. what `usePromoCode()` actually puts on the wire. The composable is three
- *     `$api` calls, and the thing that can silently be wrong about it is the
- *     verb, the path or the body - a `PUT` to the wrong path, or a body that
- *     carries `code` and so looks as though it renamed a code it cannot.
- *
- * The composable reaches for `useNuxtApp()`, which only exists inside a Nuxt
- * app, so one stub stands in for it and records the call.
- */
-
-const NOW = new Date(2026, 7, 20, 12, 0, 0); // 20 Aug 2026, midday
-
-// ---------------------------------------------------------------------------
-// The expiry rule
-// ---------------------------------------------------------------------------
-
-test("an expiry date is read as the END of its day, in both stored formats", () => {
-  // A code dated today is good for all of today, so a check at midday passes.
-  const usFormat = promoExpiryDate("08/20/2026");
-  assert.ok(usFormat);
-  assert.equal(usFormat!.getHours(), 23);
-  assert.ok(usFormat!.getTime() > NOW.getTime());
-
-  const iso = promoExpiryDate("2026-08-20");
-  assert.ok(iso);
-  assert.equal(iso!.getTime(), usFormat!.getTime());
-});
-
-test("a date that is not a date is no expiry at all, never an Invalid Date", () => {
-  assert.equal(promoExpiryDate(""), null);
-  assert.equal(promoExpiryDate(null), null);
-  assert.equal(promoExpiryDate("whenever"), null);
-  // Month 13 rolls into the next year in JavaScript rather than failing, so
-  // it is caught explicitly - otherwise 13/01/2026 would read as Jan 2027.
-  assert.equal(promoExpiryDate("13/01/2026"), null);
-});
-
-// ---------------------------------------------------------------------------
-// Loading a record into the form, and building the body back out
-// ---------------------------------------------------------------------------
-
-test("the form loads from the record and does NOT carry the code", () => {
-  const values = promoCodeFormValues({
-    _id: "652f1a2b3c4d5e6f70819293",
-    code: "WELCOME2026",
-    description: "Launch offer",
-    type: "fixed",
-    fixed_rate: 12,
-    expiresAt: "12/31/2026",
-    status: "active",
-  });
-
-  assert.equal((values as any).code, undefined);
-  assert.deepEqual(values, {
-    description: "Launch offer",
-    type: "fixed",
-    fixed_rate: 12,
-    expiresAt: "12/31/2026",
-    tiers: [],
-  });
-});
-
-test("a tiered record keeps its bands; a fixed one is given none", () => {
-  const tiered = promoCodeFormValues({
-    type: "tiered",
-    tiers: [{ min: 1, max: 10, price: 9 }, { min: 11, max: 0, price: 7 }],
-  });
-  assert.equal(tiered.tiers.length, 2);
-  assert.deepEqual(tiered.tiers[1], { min: 11, max: 0, price: 7 });
-
-  // A code stored as fixed but carrying leftover bands must not send them:
-  // `promoCodeUpdateSchema` FORBIDS `tiers` on a fixed code and would 400.
-  const fixed = promoCodeFormValues({
-    type: "fixed",
-    fixed_rate: 5,
-    tiers: [{ min: 1, max: 10, price: 9 }],
-  });
-  assert.deepEqual(fixed.tiers, []);
-});
-
-test("an empty record gives a usable, valid, fixed-price form", () => {
-  const values = promoCodeFormValues(null);
-  assert.deepEqual(values, {
-    description: "",
-    type: "fixed",
-    fixed_rate: 0,
-    expiresAt: "",
-    tiers: [],
-  });
-  assert.equal(validatePromoCodeEdit(promoCodeUpdatePayload(values), NOW), null);
-});
-
-test("the payload never contains code, _id or status", () => {
-  const payload = promoCodeUpdatePayload({
-    description: "Launch offer",
-    type: "fixed",
-    fixed_rate: 12,
-    expiresAt: "12/31/2026",
-    tiers: [],
-  });
-
-  assert.deepEqual(Object.keys(payload).sort(), [
-    "description",
-    "expiresAt",
-    "fixed_rate",
-    "type",
-  ]);
-});
-
-test("a tiered payload sends bands and no fixed_rate, and the reverse", () => {
-  const tiered = promoCodeUpdatePayload({
-    description: "",
-    type: "tiered",
-    fixed_rate: 99,
-    expiresAt: "",
-    tiers: [{ min: 1, max: 10, price: 9 }],
-  });
-  assert.deepEqual(tiered.tiers, [{ min: 1, max: 10, price: 9 }]);
-  assert.equal("fixed_rate" in tiered, false);
-
-  const fixed = promoCodeUpdatePayload({
-    description: "",
-    type: "fixed",
-    fixed_rate: 9,
-    expiresAt: "",
-    tiers: [{ min: 1, max: 10, price: 9 }],
-  });
-  assert.equal("tiers" in fixed, false);
-  assert.equal(fixed.fixed_rate, 9);
-});
-
-test("a price nobody has typed is NOT quietly saved as free", () => {
-  // `Number("")` is 0. Coercing a blank field would turn "not filled in" into
-  // "every seat is free" - a real price, saved without anyone choosing it.
-  const payload = promoCodeUpdatePayload({
-    description: "",
-    type: "fixed",
-    fixed_rate: "" as any,
-    expiresAt: "",
-    tiers: [],
-  });
-  assert.equal(payload.fixed_rate, "");
-  assert.match(
-    String(validatePromoCodeEdit(payload, NOW)),
-    /Enter a price per seat/
-  );
-
-  // A deliberate 0, however, is a real answer and goes through.
-  const free = promoCodeUpdatePayload({
-    description: "",
-    type: "fixed",
-    fixed_rate: 0,
-    expiresAt: "",
-    tiers: [],
-  });
-  assert.equal(free.fixed_rate, 0);
-  assert.equal(validatePromoCodeEdit(free, NOW), null);
-});
-
-test("band numbers typed as text reach the API as numbers", () => {
-  const payload = promoCodeUpdatePayload({
-    description: "",
-    type: "tiered",
-    fixed_rate: 0,
-    expiresAt: "",
-    tiers: [{ min: "1", max: "10", price: "9.5" } as any],
-  });
-  assert.deepEqual(payload.tiers, [{ min: 1, max: 10, price: 9.5 }]);
-});
-
-// ---------------------------------------------------------------------------
-// What the form refuses, in the API's terms
-// ---------------------------------------------------------------------------
-
-test("a valid edit is refused nothing", () => {
-  assert.equal(
-    validatePromoCodeEdit(
-      { type: "fixed", fixed_rate: 0, expiresAt: "", description: "" },
-      NOW
-    ),
-    null
-  );
-  assert.equal(
-    validatePromoCodeEdit(
-      {
-        type: "tiered",
-        tiers: [{ min: 1, max: 10, price: 9 }, { min: 11, max: 0, price: 7 }],
-        expiresAt: "12/31/2026",
-      },
-      NOW
-    ),
-    null
-  );
-});
-
-test("an expiry already in the past is refused, and says what to do", () => {
-  const message = validatePromoCodeEdit(
-    { type: "fixed", fixed_rate: 5, expiresAt: "01/01/2020" },
-    NOW
-  );
-  assert.match(String(message), /already passed/);
-  assert.match(String(message), /clear the date/);
-});
-
-test("TODAY is not in the past - a code expiring today is still savable", () => {
-  assert.equal(
-    validatePromoCodeEdit(
-      { type: "fixed", fixed_rate: 5, expiresAt: "08/20/2026" },
-      NOW
-    ),
-    null
-  );
-});
-
-test("no expiry at all is allowed - that is a code with no end date", () => {
-  assert.equal(
-    validatePromoCodeEdit({ type: "fixed", fixed_rate: 5, expiresAt: "" }, NOW),
-    null
-  );
-});
-
-test("an unreadable expiry names the format instead of guessing", () => {
-  assert.match(
-    String(
-      validatePromoCodeEdit(
-        { type: "fixed", fixed_rate: 5, expiresAt: "next Tuesday" },
-        NOW
-      )
-    ),
-    /MM\/DD\/YYYY/
-  );
-});
-
-test("a free BAND is refused, because Joi's positive() refuses it", () => {
-  const message = validatePromoCodeEdit(
-    { type: "tiered", tiers: [{ min: 1, max: 10, price: 0 }] },
-    NOW
-  );
-  assert.match(String(message), /^Band 1: /);
-  assert.match(String(message), /above 0/);
-  // ...and it says the way to actually make seats free, which is the other
-  // pricing shape. `fixed_rate` is `min(0)`, not `positive()`.
-  assert.equal(
-    validatePromoCodeEdit({ type: "fixed", fixed_rate: 0 }, NOW),
-    null
-  );
-});
-
-test("the refused band is named, not just 'a band'", () => {
-  assert.match(
-    String(
-      validatePromoCodeEdit(
-        {
-          type: "tiered",
-          tiers: [
-            { min: 1, max: 10, price: 9 },
-            { min: 11, max: 5, price: 7 },
-          ],
-        },
-        NOW
-      )
-    ),
-    /^Band 2: /
-  );
-});
-
-test("a band with no upper limit is allowed - 0 means 'and above'", () => {
-  assert.equal(
-    validatePromoCodeEdit(
-      { type: "tiered", tiers: [{ min: 5, max: 0, price: 7 }] },
-      NOW
-    ),
-    null
-  );
-});
-
-test("a tiered code with no bands is refused, and offers the other shape", () => {
-  assert.match(
-    String(validatePromoCodeEdit({ type: "tiered", tiers: [] }, NOW)),
-    /at least one quantity band/
-  );
-});
-
-test("a negative fixed price is refused; a missing one is refused too", () => {
-  assert.match(
-    String(validatePromoCodeEdit({ type: "fixed", fixed_rate: -1 }, NOW)),
-    /cannot be less than 0/
-  );
-  assert.match(
-    String(validatePromoCodeEdit({ type: "fixed", fixed_rate: "" }, NOW)),
-    /Enter a price per seat/
-  );
-});
-
-test("a code with no pricing shape is refused first, before anything else", () => {
-  assert.equal(
-    validatePromoCodeEdit({ expiresAt: "01/01/2020" }, NOW),
-    "Choose how this code prices seats."
-  );
-});
-
-// ---------------------------------------------------------------------------
-// What a refusal from the server reads like
-// ---------------------------------------------------------------------------
-
-test("the API's own wording is what the screen shows", () => {
-  assert.equal(
-    promoCodeApiError(
-      { response: { _data: { message: "Promo code not found." } } },
-      "Could not save."
-    ),
-    "Promo code not found."
-  );
-});
-
-test("'Not authorized.' is replaced with something a person can act on", () => {
-  const message = promoCodeApiError(
-    { data: { message: "Not authorized." } },
-    "Could not save."
-  );
-  assert.match(message, /Seven365 staff account/);
-  assert.match(message, /Ask a Seven365 administrator/);
-});
-
-test("an unreadable failure falls back rather than dumping the error", () => {
-  assert.equal(
-    promoCodeApiError(new Error("fetch failed"), "Could not save the changes."),
-    "Could not save the changes."
-  );
-});
-
-// ---------------------------------------------------------------------------
-// The composable: verb, path and body of every write
-// ---------------------------------------------------------------------------
-
-const calls: Array<{ path: string; options: any }> = [];
-
-(globalThis as any).useNuxtApp = () => ({
-  $api: (path: string, options: any = {}) => {
-    calls.push({ path, options });
-    return Promise.resolve({ message: "ok" });
-  },
-});
-
-const promoCodeApi = (await import("../composables/usePromoCode.ts")).default();
-
-function lastCall() {
-  return calls[calls.length - 1];
-}
-
-const ID = "652f1a2b3c4d5e6f70819293";
-
-test("getById reads the one record, from the path the API mounts", async () => {
-  await promoCodeApi.getById(ID);
-  assert.equal(lastCall().path, `/api/promo-codes/id/${ID}`);
-  assert.equal(lastCall().options.method, "GET");
-});
-
-test("update is a PUT to /api/promo-codes/:id", async () => {
-  await promoCodeApi.update(ID, {
-    description: "Launch offer",
-    type: "fixed",
-    fixed_rate: 12,
-    expiresAt: "12/31/2026",
-  } as any);
-
-  assert.equal(lastCall().path, `/api/promo-codes/${ID}`);
-  assert.equal(lastCall().options.method, "PUT");
-  assert.equal(lastCall().options.body.description, "Launch offer");
-});
-
-test("update NEVER sends code, however it is called", async () => {
-  // The screen loads a record and could easily send it back whole. `code` is
-  // immutable on the server; sending it would be accepted and dropped, and
-  // the person would watch a rename succeed and change nothing.
-  await promoCodeApi.update(ID, {
-    code: "RENAMED",
-    type: "fixed",
-    fixed_rate: 1,
-  } as any);
-
-  assert.equal("code" in lastCall().options.body, false);
-  assert.equal(lastCall().options.body.type, "fixed");
-});
-
-test("updateStatus is a PATCH carrying only the new status", async () => {
-  await promoCodeApi.updateStatus(ID, "disabled");
-  assert.equal(lastCall().path, `/api/promo-codes/${ID}/status`);
-  assert.equal(lastCall().options.method, "PATCH");
-  assert.deepEqual(lastCall().options.body, { status: "disabled" });
-
-  await promoCodeApi.updateStatus(ID, "active");
-  assert.deepEqual(lastCall().options.body, { status: "active" });
-});
-
-test("remove is a DELETE, with no body to get wrong", async () => {
-  await promoCodeApi.remove(ID);
-  assert.equal(lastCall().path, `/api/promo-codes/${ID}`);
-  assert.equal(lastCall().options.method, "DELETE");
-  assert.equal(lastCall().options.body, undefined);
-});
-
-test("the four reads and writes are all on the composable", () => {
-  for (const name of [
-    "add",
-    "getPromoCodes",
-    "getByCode",
-    "getById",
-    "update",
-    "updateStatus",
-    "remove",
-  ]) {
-    assert.equal(
-      typeof (promoCodeApi as any)[name],
-      "function",
-      `usePromoCode() is missing ${name}`
-    );
-  }
-});

package/utils/role.test.ts

@@ -1,69 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { test } from "node:test";
-
-import { showSiteField } from "./role.ts";
-
-/**
- * QA on the admin app (PR #18) reported "no site options" on Create Role. The
- * Site field is read-only by design - it shows the site a role belongs to -
- * but an admin role has no site, so it drew permanently disabled and empty.
- * `RolePermissionFormCreate` defaulted `siteState` to `true` and
- * `RolePermissionMain` neither declared nor forwarded it, and its root is a
- * `<div>`, so a fallthrough attribute could not reach the dialog either: no
- * consuming app could switch the field off.
- */
-test("an admin role never shows the site field", () => {
-  assert.equal(showSiteField(true, "admin"), false);
-  assert.equal(showSiteField(false, "admin"), false);
-});
-
-test("every other role type keeps what the app asked for", () => {
-  for (const type of [
-    "app",
-    "organization",
-    "security_agency",
-    "cleaning_services",
-  ]) {
-    assert.equal(showSiteField(true, type), true, type);
-    assert.equal(showSiteField(false, type), false, type);
-  }
-});
-
-test("RolePermissionMain declares site-state and forwards it to the dialog", () => {
-  const src = readFileSync(
-    new URL("../components/RolePermissionMain.vue", import.meta.url),
-    "utf8"
-  );
-
-  assert.match(src, /siteState:\s*\{/, "site-state must be a declared prop");
-  assert.match(
-    src,
-    /:site-state="siteFieldShown"/,
-    "the dialog must receive the resolved value, not a fallthrough attribute"
-  );
-});
-
-/**
- * The category expand toggle carried no class, so it fell back to raw Vuetify
- * `inset` styling: a white thumb on a white card, measured 1.02:1 light /
- * 1.04:1 dark against the dialog surface. `.app-switch` (primitives.css) is
- * this layer's switch shape and is what makes the thumb visible. `inset` is
- * removed with it - Vuetify's inset dimensions beat the `.app-switch` rules on
- * source order and collapse the control to zero width.
- */
-for (const file of [
-  "RolePermissionFormCreate.vue",
-  "RolePermissionFormPreviewUpdate.vue",
-]) {
-  test(`${file} styles its category toggle with .app-switch`, () => {
-    const src = readFileSync(
-      new URL(`../components/${file}`, import.meta.url),
-      "utf8"
-    );
-    const sw = src.slice(src.indexOf("<v-switch"), src.indexOf("/>", src.indexOf("<v-switch")));
-
-    assert.ok(sw.includes('class="app-switch"'), "missing .app-switch");
-    assert.ok(!/\binset\b/.test(sw), "inset fights the .app-switch dimensions");
-  });
-}

package/utils/route-name.test.ts

@@ -1,85 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { test } from "node:test";
-
-import { pickRouteName } from "./route-name.ts";
-
-const routerWith = (...names: string[]) => ({
-  hasRoute: (name: string) => names.includes(name),
-});
-
-test("picks the first candidate this app actually has", () => {
-  const router = routerWith("org-site-keys-visitor-pass-add");
-  assert.equal(
-    pickRouteName(router, "org-site-keys-visitor-pass-add", "keys-visitor-pass-add"),
-    "org-site-keys-visitor-pass-add"
-  );
-});
-
-test("falls through to a later candidate for a flatter app", () => {
-  const router = routerWith("keys-visitor-pass-add");
-  assert.equal(
-    pickRouteName(router, "org-site-keys-visitor-pass-add", "keys-visitor-pass-add"),
-    "keys-visitor-pass-add"
-  );
-});
-
-test("candidate order wins when an app has both", () => {
-  const router = routerWith("keys-visitor-pass-add", "org-site-keys-visitor-pass-add");
-  assert.equal(
-    pickRouteName(router, "org-site-keys-visitor-pass-add", "keys-visitor-pass-add"),
-    "org-site-keys-visitor-pass-add"
-  );
-});
-
-test("null when the app has no such page - the caller hides the control", () => {
-  assert.equal(pickRouteName(routerWith("org-site-work-orders"), "org-site-work-orders-id"), null);
-  assert.equal(pickRouteName(routerWith()), null);
-});
-
-// The five names two app-side audits found dead. Each is now resolved through
-// `pickRouteName`, so none may reappear as a literal anywhere in the layer.
-// `organizations-create` is deliberately absent: it is real in web-app-org and
-// is only reached there, so it was never dead.
-const DEAD_NAMES = [
-  "keys-visitor-pass-add",
-  "org-organizations-customers-add",
-  "work-order-details",
-  "org-site-service-provider-mgmt-billing",
-];
-
-function sourceFiles(dir: string, out: string[] = []): string[] {
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const path = join(dir, entry.name);
-    if (entry.isDirectory()) sourceFiles(path, out);
-    else if (/\.(vue|ts)$/.test(entry.name)) out.push(path);
-  }
-  return out;
-}
-
-test("no dead route name survives as a literal in the layer", () => {
-  const root = fileURLToPath(new URL("..", import.meta.url));
-  const files = ["components", "pages", "layouts", "composables", "middleware", "plugins"]
-    .flatMap((d) => sourceFiles(join(root, d)))
-    .filter((f) => !f.endsWith(".test.ts"));
-
-  assert.ok(files.length > 100, `expected to scan the layer, scanned ${files.length} files`);
-
-  const offenders: string[] = [];
-  for (const file of files) {
-    const source = readFileSync(file, "utf8");
-    for (const dead of DEAD_NAMES) {
-      // Only a `name:` BINDING counts. The same string also appears as a bare
-      // argument in a `pickRouteName(...)` candidate list, which is the fix, not
-      // the fault. Plain string matching on purpose - a backslash class inside a
-      // template literal silently loses its escape and matches nothing.
-      const bound = [`"${dead}"`, `'${dead}'`].some(
-        (quoted) => source.includes(`name: ${quoted}`) || source.includes(`name:${quoted}`)
-      );
-      if (bound) offenders.push(`${file.slice(root.length)} -> ${dead}`);
-    }
-  }
-  assert.deepEqual(offenders, [], `dead route names still bound:\n${offenders.join("\n")}`);
-});

package/utils/status.test.ts

@@ -1,110 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import { statusTone, statusToneClass } from "./status.ts";
-
-test("the handoff's mapping, word for word", () => {
-  for (const s of ["Completed", "Paid", "Available", "Open"]) {
-    assert.equal(statusTone(s), "ok", s);
-  }
-
-  assert.equal(statusTone("Pending"), "warn");
-
-  for (const s of ["In Use", "Closed", "Checkout"]) {
-    assert.equal(statusTone(s), "err", s);
-  }
-
-  assert.equal(statusTone("Role"), "info");
-});
-
-/** The same status arrives spelled three ways from three endpoints. */
-test("casing, spacing and underscores do not change a status's colour", () => {
-  for (const s of ["in use", "IN USE", "In_Use", "in-use", "  In Use  "]) {
-    assert.equal(statusTone(s), "err", s);
-  }
-});
-
-/**
- * The important one. A status the design never named must NOT be guessed into
- * a colour - a wrong green on a failed job reads as success. Neutral is
- * visible, honest, and gets it noticed.
- */
-test("an unmapped status comes out neutral rather than guessed", () => {
-  for (const s of ["Cancelled", "Overdue", "Draft", "", null, undefined]) {
-    assert.equal(statusTone(s), "neutral", String(s));
-  }
-});
-
-/**
- * PHASE 4. Each of these words is on a module screen today with a colour a
- * per-screen `getStatusColor` gave it. The list has to keep giving it the SAME
- * tone, or adopting the shared chip would quietly repaint a status.
- */
-test("the product's own status words keep the tone the screens already gave them", () => {
-  for (const s of ["Accepted", "Approved", "Resolved", "Active"]) {
-    assert.equal(statusTone(s), "ok", s);
-  }
-
-  for (const s of ["Rejected", "Deleted", "Suspended"]) {
-    assert.equal(statusTone(s), "err", s);
-  }
-
-  for (const s of ["In Progress", "In-Progress", "To-Do", "Awaiting Approval", "Replaced", "Returned"]) {
-    assert.equal(statusTone(s), "warn", s);
-  }
-
-  for (const s of ["Ongoing", "For Review", "Assigned"]) {
-    assert.equal(statusTone(s), "info", s);
-  }
-
-  for (const s of ["Inactive", "Expired"]) {
-    assert.equal(statusTone(s), "neutral", s);
-  }
-});
-
-/**
- * HID enrolment. These two are the whole point of the Status column on
- * `HidUserEnrollment` - if they were left unlisted they would BOTH be neutral
- * and the column would stop distinguishing anything, so they are pinned.
- */
-test("Mapped and Unmapped keep the tones the enrolment screen already gave them", () => {
-  assert.equal(statusTone("Mapped"), "ok");
-  assert.equal(statusTone("Unmapped"), "warn");
-});
-
-/**
- * HID intercom SIP state. "Disabled" and "Not connected" must stay NEUTRAL -
- * painting an intentionally-off intercom red would read as a fault.
- */
-/**
- * HID access authorization, landing on `staging` in b0667a7. Pinned before that
- * merge so the words cannot arrive and quietly render neutral - the difference
- * between a granted and a denied door is the whole point of the column.
- */
-test("HID authorization states are known to the shared map before b0667a7 merges", () => {
-  assert.equal(statusTone("Authorized"), "ok");
-  assert.equal(statusTone("Not Authorized"), "err");
-  assert.equal(statusTone("Unknown"), "warn");
-});
-
-test("intercom SIP states keep the tones the intercom screen already gave them", () => {
-  assert.equal(statusTone("Connected"), "ok");
-  assert.equal(statusTone("Connecting"), "warn");
-  assert.equal(statusTone("Not connected"), "neutral");
-  assert.equal(statusTone("Disabled"), "neutral");
-  assert.equal(statusTone("Failed"), "err");
-});
-
-/**
- * The one place the handoff and the old per-screen colour disagree: `Open` was
- * grey on the cleaning schedules and the design names it `ok`. Pinned so the
- * disagreement is a decision on the record rather than a surprise.
- */
-test("Open follows the design, not the old grey", () => {
-  assert.equal(statusTone("open"), "ok");
-});
-
-test("the class name matches what tokens.css actually defines", () => {
-  assert.equal(statusToneClass("Paid"), "tone-ok");
-  assert.equal(statusToneClass("Whatever"), "tone-neutral");
-});