WFDASH-WEBAPP/src/lib/server/stock-pick-service.test.ts

import { describe, it, expect, vi } from "vitest";
import {
  escapePbFilterString,
  searchStockItemsForPick,
  STOCK_PICK_LIMIT_MAX,
} from "./stock-pick-service";

/**
 * The service's whole job is building one PocketBase filter string.
 * A malformed filter doesn't throw — PocketBase answers 400 and the
 * operator sees an empty dropdown, which reads as "no stock matches"
 * rather than "our query is broken". So the string itself is the
 * thing worth asserting on.
 */

type Captured = { filter?: string; sort?: string; fields?: string; expand?: string };

function fakePb(items: Array<Record<string, unknown>> = []) {
  const captured: Captured = {};
  const getList = vi.fn(
    async (
      _page: number,
      _perPage: number,
      opts?: {
        filter?: string;
        sort?: string;
        fields?: string;
        expand?: string;
      },
    ) => {
      Object.assign(captured, opts);
      return { items };
    },
  );
  return {
    captured,
    pb: { collection: () => ({ getList }) },
    getList,
  };
}

describe("escapePbFilterString", () => {
  it("neutralises a double quote so the filter literal can't be closed", () => {
    // Without escaping, `q = 'x" || is_active=false || "'` rewrites the
    // filter into something that returns a different (or no) result set.
    expect(escapePbFilterString('x" || is_active=false || "')).toBe(
      'x\\" || is_active=false || \\"',
    );
  });

  it("escapes backslashes before quotes, in that order", () => {
    // Order matters: escaping quotes first would double-escape the
    // backslash that quote-escaping introduces.
    expect(escapePbFilterString('a\\b"c')).toBe('a\\\\b\\"c');
  });
});

describe("searchStockItemsForPick", () => {
  it("searches sku, name AND description", () => {
    // Description is included because the counter operator often
    // searches for what a part does, not what it's called.
    const { pb, captured } = fakePb();
    void searchStockItemsForPick(pb, "nitrile", 10);
    expect(captured.filter).toContain('sku ~ "nitrile"');
    expect(captured.filter).toContain('name ~ "nitrile"');
    expect(captured.filter).toContain('description ~ "nitrile"');
    expect(captured.filter).toContain("is_active=true");
  });

  it("expands the supplier and projects only the columns the picker renders", () => {
    const { pb, captured } = fakePb();
    void searchStockItemsForPick(pb, "bolt", 10);
    expect(captured.expand).toBe("supplier");
    expect(captured.fields).toBe(
      "id,sku,name,description,unit,current_qty,supplier",
    );
  });

  it("clamps the limit to the documented max", () => {
    const { pb, getList } = fakePb();
    void searchStockItemsForPick(pb, "bolt", 9999);
    expect(getList.mock.calls[0][1]).toBe(STOCK_PICK_LIMIT_MAX);
  });

  it("escapes a quote in the user query rather than emitting a broken filter", () => {
    const { pb, captured } = fakePb();
    void searchStockItemsForPick(pb, 'bo"lt', 10);
    // Every quote inside the filter must be escaped — an odd count of
    // raw quotes is exactly what produces the silent 400.
    const raw = (captured.filter ?? "").match(/"/g) ?? [];
    const escaped = (captured.filter ?? "").match(/\\"/g) ?? [];
    expect(raw.length).toBeGreaterThan(0);
    expect(escaped.length).toBeGreaterThan(0);
    expect(captured.filter).toContain('bo\\"lt');
  });

  it("normalises a sparse row into a renderable shape", async () => {
    // PB omits null fields rather than sending them. `current_qty` has
    // to come back as a number or the dropdown renders "qty null".
    const { pb } = fakePb([
      { id: "abc123", name: "Hex bolt M8" },
    ]);
    const items = await searchStockItemsForPick(pb, "hex", 10);
    expect(items[0]).toMatchObject({
      id: "abc123",
      name: "Hex bolt M8",
      sku: "",
      description: "",
      current_qty: 0,
    });
    expect(items[0].unit).toBeUndefined();
    expect(items[0].supplier).toBeUndefined();
    expect(items[0].expand).toBeUndefined();
  });

  it("resolves the supplier name through the expand", async () => {
    const { pb } = fakePb([
      {
        id: "abc123",
        name: "Hex bolt M8",
        sku: "BOLT-M8",
        description: "Zinc plated",
        unit: "EA",
        current_qty: 12,
        supplier: "sup1",
        expand: { supplier: { suppliername: "Afrisan" } },
      },
    ]);
    const items = await searchStockItemsForPick(pb, "hex", 10);
    expect(items).toHaveLength(1);
    expect(items[0]).toMatchObject({
      id: "abc123",
      sku: "BOLT-M8",
      unit: "EA",
      current_qty: 12,
      supplier: "sup1",
    });
    expect(items[0].expand?.supplier?.suppliername).toBe("Afrisan");
  });

  it("coerces a null current_qty to 0 rather than leaking null", async () => {
    const { pb } = fakePb([
      { id: "abc123", name: "Hex bolt M8", current_qty: null },
    ]);
    const items = await searchStockItemsForPick(pb, "hex", 10);
    expect(items[0].current_qty).toBe(0);
  });

  it("returns an empty array when PB returns nothing, not undefined", async () => {
    const { pb } = fakePb([]);
    await expect(searchStockItemsForPick(pb, "zzzz", 10)).resolves.toEqual(
      [],
    );
  });
});