@cavulsqa/create 2.9.2 → 2.10.0

package/templates/m3e-app/tests/locales.test.ts

@@ -0,0 +1,73 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, test, vi } from "vite-plus/test";
+
+/** Read raw: the app's i18n plugin compiles imported locale JSON into message functions. */
+const load = (name: string) =>
+  JSON.parse(readFileSync(new URL(`../src/locales/${name}.json`, import.meta.url), "utf8")) as Tree;
+const en = load("en");
+const fr = load("fr");
+const ar = load("ar");
+
+vi.mock("framework7-vue", () => ({ f7: undefined }));
+
+const { fromDevice, pluralRule } = await import("../src/plugins/i18n.plugin.js");
+
+type Tree = { [key: string]: string | Tree };
+
+function strings(tree: Tree, path = ""): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const [key, value] of Object.entries(tree)) {
+    const here = path ? `${path}.${key}` : key;
+    if (typeof value === "string") out.set(here, value);
+    else for (const [k, v] of strings(value, here)) out.set(k, v);
+  }
+  return out;
+}
+
+const placeholders = (text: string) =>
+  [...new Set([...text.matchAll(/\{(\w+)\}/g)].map((match) => match[1]))].sort().join();
+
+describe("locales", () => {
+  const source = strings(en);
+
+  test.each([
+    ["fr", fr],
+    ["ar-DZ", ar],
+  ])("%s has every English key, with its placeholders", (_, messages) => {
+    const target = strings(messages);
+    expect([...target.keys()].sort()).toEqual([...source.keys()].sort());
+    for (const [key, text] of source) {
+      expect(placeholders(target.get(key)!), key).toBe(placeholders(text));
+    }
+  });
+
+  test("an Arabic plural carries all six forms", () => {
+    for (const [key, text] of strings(ar)) {
+      if (text.includes("|")) expect(text.split("|"), key).toHaveLength(6);
+    }
+  });
+});
+
+describe("Arabic plurals", () => {
+  const pick = pluralRule("ar-DZ");
+  test.each([
+    [0, 0],
+    [1, 1],
+    [2, 2],
+    [3, 3],
+    [10, 3],
+    [11, 4],
+    [99, 4],
+    [100, 5],
+    [102, 5],
+  ])("%i takes form %i of six", (count, form) => {
+    expect(pick(count, 6)).toBe(form);
+  });
+});
+
+test("a device language finds its app locale whatever the region", () => {
+  expect(fromDevice("ar")).toBe("ar-DZ");
+  expect(fromDevice("ar-SA")).toBe("ar-DZ");
+  expect(fromDevice("fr-DZ")).toBe("fr");
+  expect(fromDevice("de")).toBeNull();
+});

package/templates/m3e-app/tests/migrations.test.ts

@@ -0,0 +1,74 @@
+import { expect, test } from "vite-plus/test";
+import { Kysely } from "kysely";
+import { Migrator } from "kysely/migration";
+import { createSqlJsDialect } from "@cavulsqa/mobile-db/testing";
+import { migrations } from "../src/shared/database/migrations.js";
+import type { Database } from "../src/shared/database/schema.js";
+
+async function migrate(db: Kysely<Database>, set = migrations) {
+  return new Migrator({
+    db,
+    provider: { getMigrations: () => Promise.resolve(set) },
+  }).migrateToLatest();
+}
+
+test("a fresh database gets every table the schema declares", async () => {
+  const db = new Kysely<Database>({ dialect: await createSqlJsDialect() });
+  const result = await migrate(db);
+  expect(result.error).toBeUndefined();
+
+  const names = (await db.introspection.getTables()).map((t) => t.name);
+  for (const table of [
+    "customer",
+    "product",
+    "sales_order",
+    "order_line",
+    "tag",
+    "customer_tag",
+    "bench_region",
+    "bench_city",
+    "bench_customer",
+    "bench_category",
+    "bench_product",
+    "bench_warehouse",
+    "bench_stock",
+    "bench_order",
+    "bench_order_line",
+    "bench_payment",
+  ]) {
+    expect(names, table).toContain(table);
+  }
+
+  // The two-table benchmark 003 replaced must be gone, not merely unused.
+  expect(names).not.toContain("bench_parent");
+  expect(names).not.toContain("bench_child");
+});
+
+/**
+ * The failure this exists for: deleting an already-applied migration instead of emptying it. Kysely
+ * records applied migrations by key, so a recorded key the provider no longer offers makes it refuse
+ * the entire set - applying nothing, reporting the error in its return value rather than throwing,
+ * and leaving an app whose first query fails with "no such table".
+ */
+test("dropping an applied migration is refused, and the refusal is visible", async () => {
+  const db = new Kysely<Database>({ dialect: await createSqlJsDialect() });
+  expect((await migrate(db)).error).toBeUndefined();
+
+  const { "002_benchmark": _removed, ...withoutTombstone } = migrations;
+  const result = await migrate(db, withoutTombstone);
+
+  expect(result.error, "kysely must object to the missing migration").toBeDefined();
+});
+
+test("running twice is a no-op, and every key is still there", async () => {
+  const db = new Kysely<Database>({ dialect: await createSqlJsDialect() });
+  const first = await migrate(db);
+  const second = await migrate(db);
+
+  expect(first.error).toBeUndefined();
+  expect(second.error).toBeUndefined();
+  expect(second.results ?? []).toEqual([]);
+
+  // The tombstone counts: a key may stop doing work but may not stop existing.
+  expect(Object.keys(migrations)).toEqual(["001_sales", "002_benchmark", "003_benchmark_scale"]);
+});

package/templates/m3e-app/tests/navigationGuard.test.ts

@@ -0,0 +1,82 @@
+import { expect, test } from "vite-plus/test";
+import { installNavigationGuard } from "../src/shared/composables/navigation/useNavigationGuard.js";
+
+function makeRouter() {
+  const calls: string[] = [];
+  const router = {
+    allowPageChange: true,
+    navigate(url: string) {
+      calls.push(`navigate:${url}`);
+    },
+    back() {
+      calls.push("back");
+    },
+  };
+  return { router, calls };
+}
+
+test("drops a navigate issued while a transition is still in flight", () => {
+  const { router, calls } = makeRouter();
+  installNavigationGuard(router as never);
+
+  router.allowPageChange = false;
+  router.navigate("/home/feature/1/");
+
+  expect(calls).toEqual([]);
+});
+
+test("drops a back issued while a transition is still in flight", () => {
+  const { router, calls } = makeRouter();
+  installNavigationGuard(router as never);
+
+  router.allowPageChange = false;
+  router.back();
+
+  expect(calls).toEqual([]);
+});
+
+test("lets navigation through while the router is idle", () => {
+  const { router, calls } = makeRouter();
+  installNavigationGuard(router as never);
+
+  router.navigate("/home/feature/1/");
+  router.back();
+
+  expect(calls).toEqual(["navigate:/home/feature/1/", "back"]);
+});
+
+test("still allows Framework7's own recursive calls after it locks the router", () => {
+  // back() re-enters itself with { force: true }, and navigate() re-enters for named routes, both
+  // after allowPageChange is already false. Dropping those would break normal navigation.
+  const calls: string[] = [];
+  const router = {
+    allowPageChange: true,
+    navigate(url: string) {
+      calls.push(`navigate:${url}`);
+      router.allowPageChange = false;
+      if (url === "outer") router.navigate("inner");
+    },
+    back() {
+      calls.push("back");
+      router.allowPageChange = false;
+      router.navigate("from-back");
+    },
+  };
+  installNavigationGuard(router as never);
+
+  router.navigate("outer");
+  router.allowPageChange = true;
+  router.back();
+
+  expect(calls).toEqual(["navigate:outer", "navigate:inner", "back", "navigate:from-back"]);
+});
+
+test("installing twice does not wrap the router twice", () => {
+  const { router, calls } = makeRouter();
+  installNavigationGuard(router as never);
+  installNavigationGuard(router as never);
+
+  router.navigate("/demo/");
+
+  expect(calls).toEqual(["navigate:/demo/"]);
+});

package/templates/m3e-app/tests/openDatabase.test.ts

@@ -0,0 +1,54 @@
+import { afterEach, expect, test, vi } from "vite-plus/test";
+import { storageChain } from "../src/app/storage.config.js";
+import { closeDatabase, openDatabase } from "../src/shared/database/database.js";
+
+afterEach(async () => {
+  await closeDatabase();
+  vi.restoreAllMocks();
+});
+
+/**
+ * Nothing in this environment can open a database, which is the point: what is under test is how
+ * many times the chain gets walked, not whether it succeeds.
+ *
+ * The guard used to be `if (database) return database` - a value, not a promise - so two callers in
+ * the same tick both walked it. The pool VFSes take their OPFS directory exclusively, so the second
+ * walk collided with the first, retried, failed, and fell through to a slower engine that the app
+ * then reported as its choice.
+ */
+test("concurrent callers share one walk of the chain", async () => {
+  const probes = storageChain.map((candidate) => vi.spyOn(candidate, "probe"));
+
+  const [first, second] = await Promise.allSettled([openDatabase(), openDatabase()]);
+
+  expect(first.status).toBe("rejected");
+  expect(second.status).toBe("rejected");
+
+  for (const [index, probe] of probes.entries()) {
+    expect(probe, storageChain[index]?.id).toHaveBeenCalledTimes(1);
+  }
+});
+
+test("a caller arriving after a failed walk gets a fresh attempt", async () => {
+  await expect(openDatabase()).rejects.toThrow(/No storage engine could open the database/);
+
+  const probes = storageChain.map((candidate) => vi.spyOn(candidate, "probe"));
+  await expect(openDatabase()).rejects.toThrow(/No storage engine could open the database/);
+
+  // Memoising the promise must not memoise the failure: a retry has to be able to try again.
+  for (const probe of probes) expect(probe).toHaveBeenCalledTimes(1);
+});
+
+test("the failure names every candidate and why it was passed over", async () => {
+  const failure = await openDatabase().then(
+    () => null,
+    (error: unknown) => (error instanceof Error ? error.message : String(error)),
+  );
+
+  // "the database would not open" on its own helps nobody: every attempt has to say what happened.
+  expect(failure).toBeTruthy();
+  for (const candidate of storageChain) {
+    expect(failure).toContain(candidate.id);
+  }
+  expect(failure).toContain("unsupported");
+});

package/templates/m3e-app/tests/sales.repository.test.ts

@@ -0,0 +1,329 @@
+import { beforeEach, expect, test } from "vite-plus/test";
+import { Kysely } from "kysely";
+import { Migrator } from "kysely/migration";
+import { createSqlJsDialect } from "@cavulsqa/mobile-db/testing";
+import {
+  advanceOrderStatus,
+  clearAll,
+  createOrder,
+  ensureReferenceData,
+  listCustomers,
+  loadDashboardStats,
+  searchOrders,
+  seedSampleData,
+  deleteOrder,
+  nextOrderReference,
+  saveOrder,
+  setOrderStatus,
+  loadOrderDetail,
+} from "../src/domains/sales/sales.repository.js";
+import { migrations } from "../src/shared/database/migrations.js";
+import type { Database } from "../src/shared/database/schema.js";
+
+/**
+ * The queries run against real SQLite here - sql.js, the same dialect the packages use for their own
+ * tests - so the joins, the aggregates and the migration are executed rather than just type-checked.
+ * A schema this template ships broken would cost whoever generates from it an afternoon.
+ */
+let db: Kysely<Database>;
+
+beforeEach(async () => {
+  db = new Kysely<Database>({ dialect: await createSqlJsDialect() });
+  await new Migrator({
+    db,
+    provider: { getMigrations: () => Promise.resolve(migrations) },
+  }).migrateToLatest();
+});
+
+test("the migration creates every table the schema declares", async () => {
+  const tables = await db.introspection.getTables();
+  const names = tables.map((table) => table.name).sort();
+
+  expect(names).toContain("customer");
+  expect(names).toContain("product");
+  expect(names).toContain("sales_order");
+  expect(names).toContain("order_line");
+  expect(names).toContain("tag");
+  expect(names).toContain("customer_tag");
+});
+
+test("an empty database reports zeroes rather than nulls", async () => {
+  expect(await loadDashboardStats(db)).toEqual({
+    customers: 0,
+    products: 0,
+    orders: 0,
+    draft: 0,
+    confirmed: 0,
+    delivered: 0,
+    revenueCents: 0,
+    committedCents: 0,
+  });
+});
+
+/**
+ * The app seeds this at startup, so it runs on every launch. Running twice has to leave the same
+ * database it left the first time, or a second launch doubles the catalogue.
+ */
+test("reference data gives the app a catalogue and customers, and is idempotent", async () => {
+  await ensureReferenceData(db);
+  const first = await loadDashboardStats(db);
+
+  expect(first.products).toBeGreaterThan(0);
+  expect(first.customers).toBeGreaterThan(0);
+  // Reference data is what you need to write an order, not orders themselves.
+  expect(first.orders).toBe(0);
+
+  await ensureReferenceData(db);
+  expect(await loadDashboardStats(db)).toEqual(first);
+});
+
+test("seeding adds demo orders on top of the reference data", async () => {
+  await ensureReferenceData(db);
+  const before = await loadDashboardStats(db);
+
+  await seedSampleData(db, 4);
+  const stats = await loadDashboardStats(db);
+
+  expect(stats.customers).toBe(before.customers + 4);
+  expect(stats.products).toBe(before.products);
+  // Two orders per customer the seed adds.
+  expect(stats.orders).toBe(8);
+  expect(stats.revenueCents).toBeGreaterThan(0);
+});
+
+test("the order list joins the customer and totals its lines", async () => {
+  await seedSampleData(db, 2);
+  const orders = await searchOrders(db, "");
+
+  expect(orders.length).toBe(4);
+  const first = orders[0];
+  expect(first?.customerName).toMatch(/^Customer /);
+  expect(first?.city.length).toBeGreaterThan(0);
+  expect(first?.lines).toBeGreaterThan(0);
+  expect(first?.totalCents).toBeGreaterThan(0);
+});
+
+test("search filters on the customer name and the reference together", async () => {
+  await seedSampleData(db, 3);
+  const all = await searchOrders(db, "");
+
+  // Taken from the data rather than hard-coded: the reference customers are numbered first, so the
+  // ones the seed adds do not start at 1.
+  const name = all[0]?.customerName ?? "";
+  const byCustomer = await searchOrders(db, name);
+  expect(byCustomer.length).toBeGreaterThan(0);
+  expect(byCustomer.every((order) => order.customerName === name)).toBe(true);
+
+  const reference = all[0]?.reference ?? "";
+  const byReference = await searchOrders(db, reference);
+  expect(byReference.some((order) => order.reference === reference)).toBe(true);
+
+  expect(await searchOrders(db, "nothing-matches-this")).toEqual([]);
+});
+
+test("advancing a status cycles draft to confirmed to delivered and back", async () => {
+  await seedSampleData(db, 1);
+  const [order] = await searchOrders(db, "");
+  const id = order?.id ?? 0;
+
+  expect(order?.status).toBe("draft");
+
+  await advanceOrderStatus(db, id);
+  expect((await searchOrders(db, "")).find((row) => row.id === id)?.status).toBe("confirmed");
+
+  await advanceOrderStatus(db, id);
+  expect((await searchOrders(db, "")).find((row) => row.id === id)?.status).toBe("delivered");
+
+  await advanceOrderStatus(db, id);
+  expect((await searchOrders(db, "")).find((row) => row.id === id)?.status).toBe("draft");
+});
+
+test("advancing an order that does not exist is a no-op, not a throw", async () => {
+  await expect(advanceOrderStatus(db, 9999)).resolves.toBeUndefined();
+});
+
+test("customers come back ordered by name", async () => {
+  await seedSampleData(db, 3);
+  const customers = await listCustomers(db);
+  const names = customers.map((customer) => customer.name);
+
+  expect(names).toEqual([...names].sort());
+});
+
+test("clearing leaves every table empty", async () => {
+  await seedSampleData(db, 3);
+  await clearAll(db);
+
+  expect(await loadDashboardStats(db)).toEqual({
+    customers: 0,
+    products: 0,
+    orders: 0,
+    draft: 0,
+    confirmed: 0,
+    delivered: 0,
+    revenueCents: 0,
+    committedCents: 0,
+  });
+  expect(await searchOrders(db, "")).toEqual([]);
+});
+
+test("an order's total is quantity times unit price, summed over its lines", async () => {
+  await db
+    .insertInto("customer")
+    .values({ created_at: "now", name: "Solo", city: "Oran" })
+    .execute();
+  await db
+    .insertInto("product")
+    .values({ created_at: "now", name: "Widget", price_cents: 1000 })
+    .execute();
+
+  const customer = await db.selectFrom("customer").select("id").executeTakeFirstOrThrow();
+  const product = await db
+    .selectFrom("product")
+    .select(["id", "price_cents"])
+    .executeTakeFirstOrThrow();
+
+  // Two lines, quantities 1 and 2 at 1000 each: 1000 + 2000.
+  await createOrder(db, customer.id, [product, product]);
+
+  const [order] = await searchOrders(db, "");
+  expect(order?.lines).toBe(2);
+  expect(order?.totalCents).toBe(3000);
+});
+
+test("committed revenue counts only confirmed and delivered orders", async () => {
+  await seedSampleData(db, 2);
+  const before = await loadDashboardStats(db);
+
+  // Everything starts as a draft, so nothing is committed yet.
+  expect(before.draft).toBe(4);
+  expect(before.committedCents).toBe(0);
+  expect(before.revenueCents).toBeGreaterThan(0);
+
+  const [first] = await searchOrders(db, "");
+  await setOrderStatus(db, first?.id ?? 0, "confirmed");
+
+  const after = await loadDashboardStats(db);
+  expect(after.draft).toBe(3);
+  expect(after.confirmed).toBe(1);
+  expect(after.committedCents).toBe(first?.totalCents ?? -1);
+});
+
+test("the next reference counts up and survives a deletion without reuse", async () => {
+  expect(await nextOrderReference(db)).toBe("SO-0001");
+
+  const customer = await db
+    .insertInto("customer")
+    .values({ created_at: "now", name: "Solo", city: "Oran" })
+    .returning("id")
+    .executeTakeFirstOrThrow();
+  await db
+    .insertInto("product")
+    .values({ created_at: "now", name: "Widget", price_cents: 500 })
+    .execute();
+  const product = await db.selectFrom("product").select("id").executeTakeFirstOrThrow();
+
+  await saveOrder(db, {
+    customerId: customer.id,
+    reference: "SO-0001",
+    lines: [{ productId: product.id, quantity: 2, unitPriceCents: 500 }],
+  });
+  expect(await nextOrderReference(db)).toBe("SO-0002");
+
+  await saveOrder(db, {
+    customerId: customer.id,
+    reference: "SO-0002",
+    lines: [{ productId: product.id, quantity: 1, unitPriceCents: 500 }],
+  });
+
+  // Removing the highest must not hand the same reference out twice.
+  const orders = await searchOrders(db, "SO-0002");
+  await deleteOrder(db, orders[0]?.id ?? 0);
+  expect(await nextOrderReference(db)).toBe("SO-0002");
+});
+
+test("saving writes the order and all of its lines together", async () => {
+  const customer = await db
+    .insertInto("customer")
+    .values({ created_at: "now", name: "Solo", city: "Oran" })
+    .returning("id")
+    .executeTakeFirstOrThrow();
+  await db
+    .insertInto("product")
+    .values({ created_at: "now", name: "Widget", price_cents: 250 })
+    .execute();
+  const product = await db.selectFrom("product").select("id").executeTakeFirstOrThrow();
+
+  await saveOrder(db, {
+    customerId: customer.id,
+    reference: "SO-0007",
+    lines: [
+      { productId: product.id, quantity: 3, unitPriceCents: 250 },
+      { productId: product.id, quantity: 1, unitPriceCents: 250 },
+    ],
+  });
+
+  const [order] = await searchOrders(db, "SO-0007");
+  expect(order?.lines).toBe(2);
+  expect(order?.totalCents).toBe(1000);
+  expect(order?.status).toBe("draft");
+});
+
+test("deleting an order takes its lines with it", async () => {
+  await seedSampleData(db, 1);
+  const [order] = await searchOrders(db, "");
+  const id = order?.id ?? 0;
+
+  await deleteOrder(db, id);
+
+  expect((await searchOrders(db, "")).some((row) => row.id === id)).toBe(false);
+  const orphans = await db
+    .selectFrom("order_line")
+    .select("id")
+    .where("order_id", "=", id)
+    .execute();
+  expect(orphans).toEqual([]);
+});
+
+test("seeding twice adds customers without duplicating the catalogue or throwing", async () => {
+  await seedSampleData(db, 2);
+  const first = await loadDashboardStats(db);
+
+  // This threw "UNIQUE constraint failed: tag.label" before the seed became additive.
+  await seedSampleData(db, 2);
+  const second = await loadDashboardStats(db);
+
+  expect(second.customers).toBe(first.customers + 2);
+  expect(second.orders).toBe(first.orders + 4);
+  // The catalogue is fixed, so a second press must not double it.
+  expect(second.products).toBe(first.products);
+
+  const tags = await db.selectFrom("tag").select("label").execute();
+  expect(new Set(tags.map((tag) => tag.label)).size).toBe(tags.length);
+
+  const names = (await listCustomers(db)).map((customer) => customer.name);
+  expect(new Set(names).size).toBe(names.length);
+});
+
+test("the order detail reads its lines, product names and customer tags", async () => {
+  await seedSampleData(db, 1);
+  const [row] = await searchOrders(db, "");
+  const detail = await loadOrderDetail(db, row?.id ?? 0);
+
+  expect(detail?.reference).toBe(row?.reference);
+  expect(detail?.customerName).toBe(row?.customerName);
+  expect(detail?.lines.length).toBe(row?.lines);
+  expect(detail?.lines.every((line) => line.productName.length > 0)).toBe(true);
+  expect(detail?.totalCents).toBe(row?.totalCents);
+  // Seeding attaches one tag per customer.
+  expect(detail?.tags.length).toBeGreaterThan(0);
+
+  // Each line total is quantity times unit price.
+  for (const line of detail?.lines ?? []) {
+    expect(line.lineTotalCents).toBe(line.quantity * line.unitPriceCents);
+  }
+});
+
+test("the order detail is null for an id that does not exist", async () => {
+  expect(await loadOrderDetail(db, 4242)).toBeNull();
+});