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

package/utils/data.test.ts

@@ -1,179 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import { findServiceProviderIdBySite, levelCount } from "./data.ts";
-
-const SITE = "68f05fcc0c11062938dadada";
-const OTHER_SITE = "68f05fcc0c11062938d00001";
-const PROVIDER = "68f05fcc0c11062938d00002";
-
-test("returns the provider that covers this site", () => {
-  assert.equal(
-    findServiceProviderIdBySite(
-      "service-provider",
-      [{ _id: PROVIDER, siteId: SITE }],
-      SITE
-    ),
-    PROVIDER
-  );
-});
-
-test("a non-service-provider account is not scoped by provider at all", () => {
-  assert.equal(findServiceProviderIdBySite("customer", [], SITE), null);
-  assert.equal(findServiceProviderIdBySite("", undefined, SITE), null);
-});
-
-/**
- * Returning null here would drop the provider filter and show the whole site -
- * another provider's work orders included. Refusing is the correct behaviour.
- */
-test("refuses rather than falling back to an unscoped request", () => {
-  assert.throws(() =>
-    findServiceProviderIdBySite(
-      "service-provider",
-      [{ _id: PROVIDER, siteId: OTHER_SITE }],
-      SITE
-    )
-  );
-});
-
-/**
- * The thrown message is rendered verbatim in a toast on six applications, so it
- * is part of the user interface. Assert what it SAYS, not that it throws: the
- * old message passed a "throws" assertion while quoting a raw ObjectId at a
- * security officer and naming no action.
- */
-test("the message names an action and never quotes an internal id", () => {
-  for (const providers of [[{ _id: PROVIDER, siteId: OTHER_SITE }], [], undefined]) {
-    let message = "";
-    try {
-      findServiceProviderIdBySite("service-provider", providers, SITE);
-      assert.fail("expected it to refuse");
-    } catch (error: any) {
-      message = error.message;
-    }
-    assert.doesNotMatch(message, /[0-9a-f]{24}/i, `leaks an id: ${message}`);
-    assert.doesNotMatch(message, /siteId/i, `internal wording: ${message}`);
-    assert.match(message, /not linked to this site/i);
-    assert.match(message, /administrator/i);
-  }
-});
-
-/**
- * An account with no serviceProviders field at all used to die on
- * `undefined.find(...)` - a TypeError, which the toast renders as a raw
- * JavaScript error instead of the sentence above.
- */
-test("an account with no provider list still gets the sentence, not a TypeError", () => {
-  assert.throws(
-    () => findServiceProviderIdBySite("service-provider", undefined, SITE),
-    (error: any) => error.constructor === Error && !/undefined/.test(error.message)
-  );
-});
-
-/**
- * A block whose record carries no `levels` array used to throw during render
- * (`Cannot read properties of undefined (reading 'length')`), which blanks the
- * entire blocks table - not just the offending row.
- */
-test("a block with no levels field counts as zero instead of throwing", () => {
-  assert.equal(levelCount({ levels: undefined }), 0);
-  assert.equal(levelCount({}), 0);
-  assert.equal(levelCount(undefined), 0);
-  assert.equal(levelCount(null), 0);
-});
-
-test("a block with no levels field is not confused with a block that has none", () => {
-  assert.equal(levelCount({ levels: [] }), 0);
-  assert.equal(levelCount({ levels: [{ name: "1" }, { name: "2" }] }), 2);
-});
-
-test("a non-array levels value is counted as zero, not as its own length", () => {
-  // The API has been seen to answer with a count rather than the array.
-  assert.equal(levelCount({ levels: 7 as unknown as [] }), 0);
-  assert.equal(levelCount({ levels: "12" as unknown as [] }), 0);
-});
-
-import { cameraErrorConverter } from "./data.ts";
-
-/** Shape of an ofetch failure: the status and body live under `response`. */
-const apiError = (status: number, message?: string) => ({
-  response: { status, _data: message === undefined ? {} : { message } },
-});
-
-test("a duplicate reads as a duplicate", () => {
-  assert.match(
-    cameraErrorConverter(apiError(400, "ANPR already exist."), "ip"),
-    /already exists on this site/
-  );
-  assert.match(
-    cameraErrorConverter(apiError(409), "ip"),
-    /already exists on this site/
-  );
-});
-
-test("a failure that is NOT a duplicate never says duplicate", () => {
-  const notDuplicate = [
-    cameraErrorConverter(apiError(401), "ip"),
-    cameraErrorConverter(apiError(403), "ip"),
-    cameraErrorConverter(apiError(404), "ip"),
-    cameraErrorConverter(apiError(429), "ip"),
-    cameraErrorConverter(apiError(500, "Failed to create ANPR."), "ip"),
-    cameraErrorConverter(new Error("Network request failed"), "ip"),
-  ];
-
-  for (const message of notDuplicate) {
-    assert.doesNotMatch(message, /already exist/i, message);
-  }
-});
-
-test("each cause gets its own message", () => {
-  assert.match(cameraErrorConverter(apiError(401), "ip"), /session has expired/);
-  assert.match(
-    cameraErrorConverter(apiError(403), "ip"),
-    /do not have permission/
-  );
-  assert.match(cameraErrorConverter(apiError(404), "ip"), /no longer exists/);
-  assert.match(cameraErrorConverter(apiError(429), "ip"), /Too many attempts/);
-  assert.match(
-    cameraErrorConverter(apiError(500, "Failed to create ANPR."), "ip"),
-    /could not save this CCTV camera/
-  );
-});
-
-test("no response at all reads as a connection problem, not a server refusal", () => {
-  assert.match(
-    cameraErrorConverter(new Error("Failed to fetch"), "ip"),
-    /Could not reach the server/
-  );
-});
-
-test("a rejected field is named the way the form names it", () => {
-  assert.equal(
-    cameraErrorConverter(apiError(400, '"host" is required'), "ip"),
-    "URL is required."
-  );
-  assert.equal(
-    cameraErrorConverter(apiError(400, '"name" is not allowed to be empty'), "ip"),
-    "Camera Name cannot be empty."
-  );
-  // A field with no friendly label still reads as a sentence.
-  assert.equal(
-    cameraErrorConverter(apiError(400, '"guardPost" must be a number'), "ip"),
-    "guardPost must be a number."
-  );
-});
-
-test("a plain 400 sentence from the API is passed through unchanged", () => {
-  assert.equal(
-    cameraErrorConverter(apiError(400, "Invalid _id format"), "ip"),
-    "Invalid _id format"
-  );
-});
-
-test("the camera type decides the wording", () => {
-  assert.match(cameraErrorConverter(apiError(404), "anpr"), /ANPR camera/);
-  assert.match(cameraErrorConverter(apiError(404), "ip"), /CCTV camera/);
-  // Unknown/absent type falls back to CCTV, which is what the panel defaults to.
-  assert.match(cameraErrorConverter(apiError(404)), /CCTV camera/);
-});

package/utils/hid-discover.test.ts

@@ -1,115 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import test from "node:test";
-
-import useHidAmico, { isUnknownSiteFieldError } from "../composables/useHidAmico.ts";
-
-const root = join(dirname(fileURLToPath(import.meta.url)), "..");
-
-type Call = { url: string; body: Record<string, unknown> };
-
-/**
- * The composable calls the Nuxt auto-import `useNuxtApp().$api(...)`. Install a
- * stub for it so the request body can be read without a Nuxt app.
- */
-function stubApi(handler: (call: Call) => unknown) {
-  const calls: Call[] = [];
-  (globalThis as Record<string, unknown>).useNuxtApp = () => ({
-    $api: (url: string, options: { body: Record<string, unknown> }) => {
-      const call = { url, body: options.body };
-      calls.push(call);
-      return Promise.resolve(handler(call));
-    },
-  });
-  return calls;
-}
-
-function fetchError(message: string) {
-  return Object.assign(new Error("400 Bad Request"), { data: { message } });
-}
-
-test("discoverReader sends site in the request body", async () => {
-  const calls = stubApi(() => ({ data: { deviceId: "D1", portals: [] } }));
-
-  await useHidAmico().discoverReader({
-    baseUrl: "https://reader.example",
-    username: "operator",
-    password: "secret",
-    site: "0123456789abcdef01234567",
-  });
-
-  assert.equal(calls.length, 1);
-  assert.equal(calls[0].url, "/api/access-management/hid/readers/discover");
-  assert.equal(calls[0].body.site, "0123456789abcdef01234567");
-  assert.equal(calls[0].body.baseUrl, "https://reader.example");
-});
-
-test("discoverReader retries without site when the API predates core #1878", async () => {
-  const calls = stubApi((call) => {
-    if ("site" in call.body) throw fetchError('"site" is not allowed');
-    return { data: { deviceId: "D1", portals: [] } };
-  });
-
-  const response = await useHidAmico().discoverReader({
-    baseUrl: "https://reader.example",
-    username: "operator",
-    password: "secret",
-    site: "0123456789abcdef01234567",
-  });
-
-  assert.equal(calls.length, 2);
-  assert.equal("site" in calls[1].body, false);
-  assert.equal(calls[1].body.baseUrl, "https://reader.example");
-  assert.deepEqual(response, { data: { deviceId: "D1", portals: [] } });
-});
-
-test("discoverReader does not retry a real refusal", async () => {
-  const calls = stubApi(() => {
-    throw fetchError("You are not authorized to manage readers for this site.");
-  });
-
-  await assert.rejects(
-    useHidAmico().discoverReader({
-      baseUrl: "https://reader.example",
-      username: "operator",
-      password: "secret",
-      site: "0123456789abcdef01234567",
-    }),
-  );
-  assert.equal(calls.length, 1);
-});
-
-test("isUnknownSiteFieldError only matches the unknown-key message", () => {
-  assert.equal(isUnknownSiteFieldError(fetchError('"site" is not allowed')), true);
-  assert.equal(isUnknownSiteFieldError(new Error('"site" is not allowed')), true);
-  assert.equal(isUnknownSiteFieldError(fetchError('"site" is required')), false);
-  assert.equal(isUnknownSiteFieldError(fetchError('"baseUrl" is not allowed')), false);
-  assert.equal(isUnknownSiteFieldError(fetchError("Unauthorized")), false);
-  assert.equal(isUnknownSiteFieldError(null), false);
-});
-
-test("the reader form takes site as a prop and puts it in the discover call", () => {
-  const source = readFileSync(join(root, "components", "HidReaderForm.vue"), "utf8");
-  assert.match(source, /site:\s*\{\s*type:\s*String/);
-  assert.match(source, /discoverReader\(\{[\s\S]*?site:\s*props\.site[\s\S]*?\}\)/);
-});
-
-test("reader management passes its site prop down to the form, ONCE", () => {
-  const source = readFileSync(join(root, "components", "HidReaderManagement.vue"), "utf8");
-  const tag = source.match(/<HidReaderForm[\s\S]*?\/>/)?.[0] ?? "";
-
-  // Bound to `props.site`, which is the only name for it that exists in this
-  // component - a bare `site` resolves to nothing.
-  assert.match(tag, /:site="props\.site"/);
-
-  /*
-   * And exactly once. It was written twice - `props.site` and then a bare
-   * `site` - and Vite's Vue plugin treats a duplicate attribute as a COMPILE
-   * ERROR, so every consuming application's `nuxt build` failed on this file.
-   * The layer's own playground build does not import this component, so
-   * nothing here caught it; the first sign was a consumer failing to build.
-   */
-  assert.equal((tag.match(/:site=/g) ?? []).length, 1, tag);
-});

package/utils/list-page.test.ts

@@ -1,60 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { readListPage, NO_PAGE_RANGE } from "./list-page.ts";
-
-const rows = (n: number, from = 1) =>
-    Array.from({ length: n }, (_, i) => ({ _id: `row-${from + i}` }));
-
-describe("readListPage", () => {
-    it("keeps the server's total when it is bigger than the page - the failing case", () => {
-        // 47 announcements served 10 at a time. Deriving from the page gives
-        // "10" and one page, which is the defect this replaces.
-        const got = readListPage({ items: rows(10), pages: 5, pageRange: "1-10 of 47" });
-
-        assert.equal(got.items.length, 10);
-        assert.equal(got.pages, 5);
-        assert.equal(got.pageRange, "1-10 of 47");
-    });
-
-    it("keeps the server's page 2 range rather than re-slicing", () => {
-        const got = readListPage({ items: rows(10, 11), pages: 5, pageRange: "11-20 of 47" });
-
-        assert.equal(got.items.length, 10);
-        assert.equal(got.items[0]._id, "row-11");
-        assert.equal(got.pageRange, "11-20 of 47");
-    });
-
-    it("passes a single page through unchanged", () => {
-        const got = readListPage({ items: rows(7), pages: 1, pageRange: "1-7 of 7" });
-
-        assert.deepEqual(
-            { pages: got.pages, pageRange: got.pageRange, n: got.items.length },
-            { pages: 1, pageRange: "1-7 of 7", n: 7 }
-        );
-    });
-
-    it("reports a genuinely empty list as the server described it", () => {
-        const got = readListPage({ items: [], pages: 0, pageRange: "0 - 0 of 0" });
-
-        assert.deepEqual(got, { items: [], pages: 0, pageRange: "0 - 0 of 0" });
-    });
-
-    it("does not invent a zero when the request failed and there is no reply", () => {
-        for (const reply of [null, undefined]) {
-            const got = readListPage(reply);
-
-            assert.deepEqual(got.items, []);
-            assert.equal(got.pages, 0);
-            // "0 of 0" would be a statement about the data. This is not one.
-            assert.equal(got.pageRange, NO_PAGE_RANGE);
-        }
-    });
-
-    it("does not fall back to the page length when the envelope omits its totals", () => {
-        const got = readListPage({ items: rows(10) });
-
-        assert.equal(got.pages, 0);
-        assert.equal(got.pageRange, NO_PAGE_RANGE);
-        assert.notEqual(got.pageRange, "1-10 of 10");
-    });
-});

package/utils/nav-sections.test.ts

@@ -1,190 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import { NAV_SECTIONS, withSections } from "./nav-sections.ts";
-
-/** The Security menu, item for item and in `web-app-security`'s own order. */
-const SECURITY = [
-  "Dashboard",
-  "Feedbacks",
-  "Work Orders",
-  "Vehicle Mgmt",
-  "Building Mgmt",
-  "Visitor Mgmt",
-  "Pass & Key Mgmt",
-  "HID Face Reader",
-  "Daily Occurrence Books",
-  "Manpower",
-  "Virtual Patrol",
-  "Robot Mgmt",
-  "Incident Reports",
-  "Bulletin Board",
-  "Attendance",
-  "My Attendance",
-  "Invitations",
-  "Members",
-  "Roles & Permissions",
-  "Settings",
-].map((title) => ({ title }));
-
-/**
- * THE RULE THAT MATTERS. Grouping may reorder the rail; it may never change
- * the menu. Same objects, same count - nothing added, hidden or duplicated.
- */
-test("every menu item comes back exactly once, and nothing else does", () => {
-  const out = withSections(SECURITY);
-
-  assert.equal(out.length, SECURITY.length);
-  assert.deepEqual(
-    new Set(out.map((e) => e.item)),
-    new Set(SECURITY)
-  );
-});
-
-test("Security is labelled the way the design draws it", () => {
-  const labelled = withSections(SECURITY)
-    .filter((e) => e.section)
-    .map((e) => `${e.section}: ${e.item.title}`);
-
-  assert.deepEqual(labelled, [
-    "OVERVIEW: Dashboard",
-    "SERVICE DESK: Feedbacks",
-    "PROPERTY: Vehicle Mgmt",
-    "SECURITY OPERATIONS: HID Face Reader",
-    "COMMUNITY: Bulletin Board",
-    "WORKFORCE: Attendance",
-    "ADMINISTRATION: Invitations",
-  ]);
-});
-
-/**
- * A permission-gated menu is a SUBSET, and every application's is different.
- * Dropping the items a user cannot see must not leave a heading behind or move
- * one onto the wrong item.
- */
-test("a user who can only see three modules gets three correct headings", () => {
-  const out = withSections(
-    [{ title: "Dashboard" }, { title: "Work Orders" }, { title: "Settings" }]
-  );
-
-  assert.deepEqual(
-    out.map((e) => e.section),
-    ["OVERVIEW", "SERVICE DESK", "ADMINISTRATION"]
-  );
-});
-
-/**
- * The eleven applications add menu items without touching this layer. An
- * unknown title must appear where its author put it, under the heading it
- * follows - never suppressed, and never given a heading of its own.
- */
-test("an unmapped module inherits the section above it", () => {
-  const out = withSections([
-    { title: "Dashboard" },
-    { title: "Something New" },
-    { title: "Members" },
-  ]);
-
-  assert.deepEqual(
-    out.map((e) => e.section),
-    ["OVERVIEW", "", "ADMINISTRATION"]
-  );
-  assert.equal(out[1].item.title, "Something New");
-});
-
-test("an unmapped FIRST item prints no heading rather than a blank one", () => {
-  const out = withSections([{ title: "Something New" }, { title: "Members" }]);
-
-  assert.deepEqual(
-    out.map((e) => e.section),
-    ["", "ADMINISTRATION"]
-  );
-});
-
-/**
- * The applications do not agree on order: Landscape lists Feedbacks after its
- * equipment modules. Those two Feedbacks/Work Orders items are collected under
- * ONE SERVICE DESK heading instead of printing the heading twice.
- */
-test("a section that comes back later is grouped, not labelled twice", () => {
-  const out = withSections([
-    { title: "Feedbacks" },
-    { title: "Equipment Items" },
-    { title: "Work Orders" },
-  ]);
-
-  assert.deepEqual(
-    out.map((e) => `${e.section}|${e.item.title}`),
-    [
-      "SERVICE DESK|Feedbacks",
-      "|Work Orders",
-      "EQUIPMENT|Equipment Items",
-    ]
-  );
-});
-
-/**
- * Property Management is the screen that showed the defect: its own menu order
- * printed SERVICE DESK, PROPERTY and SECURITY OPERATIONS twice each.
- */
-test("Property Management prints each heading exactly once", () => {
-  const PM = [
-    "Dashboard",
-    "Service Providers",
-    "Feedbacks",
-    "Work Orders",
-    "Facility Mgmt",
-    "Pass & Key Mgmt",
-    "HID Face Reader",
-    "Online Forms",
-    "NFC Patrol",
-    "Bulletin Board",
-    "Bulletin Videos",
-    "Visitor Mgmt",
-    "Document Mgmt",
-    "Access Mgmt",
-  ].map((title) => ({ title }));
-
-  const out = withSections(PM);
-  const headings = out.map((e) => e.section).filter(Boolean);
-
-  assert.deepEqual(headings, [
-    "OVERVIEW",
-    "SERVICE DESK",
-    "PROPERTY",
-    "SECURITY OPERATIONS",
-    "COMMUNITY",
-  ]);
-  assert.equal(new Set(headings).size, headings.length);
-  assert.deepEqual(
-    out.map((e) => e.item.title),
-    [
-      "Dashboard",
-      "Service Providers",
-      "Feedbacks",
-      "Work Orders",
-      "Online Forms",
-      "Facility Mgmt",
-      "Pass & Key Mgmt",
-      "Visitor Mgmt",
-      "Document Mgmt",
-      "Access Mgmt",
-      "HID Face Reader",
-      "NFC Patrol",
-      "Bulletin Board",
-      "Bulletin Videos",
-    ]
-  );
-});
-
-test("a missing or empty title does not throw", () => {
-  const out = withSections([{}, { title: "" }] as Array<{ title?: string }>);
-  assert.equal(out.length, 2);
-});
-
-/** Every section name is the uppercase form the type scale is drawn for. */
-test("section names are uppercase", () => {
-  for (const section of Object.values(NAV_SECTIONS)) {
-    assert.equal(section, section.toUpperCase(), section);
-  }
-});

package/utils/nfc-patrol-report.test.ts

@@ -1,130 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import { collectAllPages, mapLogsToMonthlyRows } from "./nfc-patrol-report.ts";
-
-/**
- * THE DEFECT THIS FILE EXISTS FOR.
- *
- * The yearly patrol-compliance table was built from `page: 1, limit: 100` of a
- * paged endpoint and never looked at `pages`. A route patrolled daily produces
- * ~300 runs a year, so months past the first page rendered "0 / 0% / 0 / 0%" -
- * indistinguishable from a month in which every checkpoint was missed, in a
- * table a manager can print and hand to a client.
- */
-
-/** 12 months x 25 runs x (4 completed + 1 skipped). Every month is 80%/20%. */
-function yearOfLogs() {
-  const logs: Record<string, any>[] = [];
-  for (let m = 0; m < 12; m++) {
-    for (let d = 1; d <= 25; d++) {
-      const checkPoints = [
-        { status: "Completed" },
-        { status: "Completed" },
-        { status: "Completed" },
-        { status: "Completed" },
-        { status: "Skipped" },
-      ];
-      logs.push({
-        date: `2026-${String(m + 1).padStart(2, "0")}-${String(d).padStart(2, "0")}T08:00:00.000Z`,
-        checkPoints,
-      });
-    }
-  }
-  return logs;
-}
-
-function pagedFetcher(all: Record<string, any>[], limit = 100) {
-  const pages = Math.ceil(all.length / limit);
-  const seen: number[] = [];
-  return {
-    seen,
-    fetchPage: async (page: number) => {
-      seen.push(page);
-      return { items: all.slice((page - 1) * limit, page * limit), pages };
-    },
-  };
-}
-
-test("every page the endpoint reports is read, not just the first", async () => {
-  const all = yearOfLogs();
-  const { fetchPage, seen } = pagedFetcher(all);
-
-  const items = await collectAllPages(fetchPage);
-
-  assert.equal(items.length, all.length, "all 300 runs collected");
-  assert.deepEqual(seen, [1, 2, 3], "walked every page the reply declared");
-});
-
-test("a full year reports the same rate in every month", async () => {
-  const items = await collectAllPages(pagedFetcher(yearOfLogs()).fetchPage);
-  const rows = mapLogsToMonthlyRows(items);
-
-  assert.equal(rows.length, 12);
-  for (const row of rows) {
-    assert.equal(row.checked, 100, `${row.month} checked`);
-    assert.equal(row.missed, 25, `${row.month} missed`);
-    assert.equal(row.checkedPercentage, 80, `${row.month} % checked`);
-    assert.equal(row.missedPercentage, 20, `${row.month} % missed`);
-  }
-});
-
-test("only the first page would have zeroed the rest of the year", () => {
-  // What the screen used to do: one page of 100, the other 200 runs dropped.
-  const firstPageOnly = yearOfLogs().slice(0, 100);
-  const rows = mapLogsToMonthlyRows(firstPageOnly);
-
-  assert.equal(rows[0].checkedPercentage, 80, "January measured");
-  assert.equal(rows[4].checked, 0, "May had no runs on page 1");
-  assert.equal(
-    rows[4].checkedPercentage,
-    null,
-    "and it must NOT read 0% - nothing was measured",
-  );
-});
-
-test("a month with no checkpoint due reports no rate at all", () => {
-  const rows = mapLogsToMonthlyRows([]);
-
-  for (const row of rows) {
-    assert.equal(row.checked, 0);
-    assert.equal(row.missed, 0);
-    assert.equal(row.checkedPercentage, null);
-    assert.equal(row.missedPercentage, null);
-  }
-});
-
-test("a month where every checkpoint was missed still reports 0%", () => {
-  const rows = mapLogsToMonthlyRows([
-    { date: "2026-03-04T08:00:00.000Z", checkPoints: [{ status: "Skipped" }, { status: "Skipped" }] },
-  ]);
-
-  assert.equal(rows[2].checkedPercentage, 0, "0% here is a real measurement");
-  assert.equal(rows[2].missedPercentage, 100);
-  assert.equal(rows[0].checkedPercentage, null, "January measured nothing");
-});
-
-test("a single-page reply is not re-fetched", async () => {
-  const { fetchPage, seen } = pagedFetcher(yearOfLogs().slice(0, 10));
-  await collectAllPages(fetchPage);
-  assert.deepEqual(seen, [1]);
-});
-
-test("a reply with no page count is treated as one page", async () => {
-  const calls: number[] = [];
-  const items = await collectAllPages(async (page) => {
-    calls.push(page);
-    return { items: [{ date: "2026-01-02T00:00:00.000Z", checkPoints: [] }] };
-  });
-  assert.deepEqual(calls, [1]);
-  assert.equal(items.length, 1);
-});
-
-test("undated or malformed logs are skipped, not counted into January", () => {
-  const rows = mapLogsToMonthlyRows([
-    { date: "not-a-date", checkPoints: [{ status: "Completed" }] },
-    { checkPoints: [{ status: "Completed" }] },
-  ]);
-  assert.equal(rows[0].checked, 0);
-  assert.equal(rows[0].checkedPercentage, null);
-});