WFDASH-WEBAPP/src/app/api/v1/pos/checkout/route.test.ts

import { describe, it, expect, vi, beforeEach } from "vitest";
import { NextRequest } from "next/server";
import { POST } from "./route";
import { checkoutSale } from "@/lib/server/pos-service";

vi.mock("@/lib/server/pos-service", () => ({
  checkoutSale: vi.fn(),
}));
vi.mock("@/lib/server/pocketbase-admin", () => ({
  getAdminPocketBase: vi.fn().mockResolvedValue({}),
}));

const POS_API_KEY = "test-pos-key";

function checkoutRequest(
  body: unknown,
  authHeader: string | null = `Bearer ${POS_API_KEY}`,
): NextRequest {
  const headers: Record<string, string> = { "content-type": "application/json" };
  if (authHeader !== null) headers.authorization = authHeader;
  return new NextRequest("http://localhost/api/v1/pos/checkout", {
    method: "POST",
    headers,
    body: JSON.stringify(body),
  });
}

describe("POST /api/v1/pos/checkout", () => {
  beforeEach(() => {
    process.env.POS_API_KEY = POS_API_KEY;
    vi.mocked(checkoutSale).mockReset();
  });

  it("returns 200 with the sale on success", async () => {
    vi.mocked(checkoutSale).mockResolvedValue({
      ok: true,
      sale: { id: "sale-1", total: 100 } as never,
      items: [],
      stockErrors: [],
      duplicate: false,
      deliveryNote: null,
    });
    const res = await POST(
      checkoutRequest({
        items: [{ stock_item_id: "si1", qty: 1, unit_price: 100 }],
        payment_method: "cash",
        cash_given: 100,
      }),
    );
    expect(res.status).toBe(200);
    const body = await res.json();
    expect(body.ok).toBe(true);
    expect(body.sale.id).toBe("sale-1");
  });

  it("returns 400 when a stock item can't be found (e.g. deleted since being added to the cart)", async () => {
    vi.mocked(checkoutSale).mockResolvedValue({
      ok: false,
      reason: "pb_error",
      message: "Stock item si1 could not be found (it may have been deleted) — remove it from the cart and try again: not found",
    });
    const res = await POST(
      checkoutRequest({
        items: [{ stock_item_id: "si1", qty: 5, unit_price: 10 }],
        payment_method: "cash",
      }),
    );
    expect(res.status).toBe(400);
  });

  it("returns 400 for other checkout failures", async () => {
    vi.mocked(checkoutSale).mockResolvedValue({
      ok: false,
      reason: "no_items",
      message: "items must be a non-empty array",
    });
    const res = await POST(checkoutRequest({ items: [], payment_method: "cash" }));
    expect(res.status).toBe(400);
  });

  // All four tender types the POS UI offers must survive the round trip.
  // Coercing eft/account to cash would book money into the drawer that
  // was never taken.
  it.each(["cash", "card", "eft", "account"] as const)(
    "passes payment_method %s through unchanged",
    async (method) => {
      vi.mocked(checkoutSale).mockResolvedValue({
        ok: true,
        sale: { id: "sale-1" } as never,
        items: [],
        stockErrors: [],
        duplicate: false,
        deliveryNote: null,
      });
      await POST(
        checkoutRequest({
          items: [{ stock_item_id: "si1", qty: 1, unit_price: 10 }],
          payment_method: method,
        }),
      );
      expect(checkoutSale).toHaveBeenCalledWith(
        expect.anything(),
        expect.objectContaining({ payment_method: method }),
      );
    },
  );

  it("defaults an unrecognised payment_method to cash", async () => {
    vi.mocked(checkoutSale).mockResolvedValue({
      ok: true,
      sale: { id: "sale-1" } as never,
      items: [],
      stockErrors: [],
      duplicate: false,
      deliveryNote: null,
    });
    await POST(
      checkoutRequest({
        items: [{ stock_item_id: "si1", qty: 1, unit_price: 10 }],
        payment_method: "bitcoin",
      }),
    );
    expect(checkoutSale).toHaveBeenCalledWith(
      expect.anything(),
      expect.objectContaining({ payment_method: "cash" }),
    );
  });

  it("forwards client_ref so a replayed offline sale stays idempotent", async () => {
    vi.mocked(checkoutSale).mockResolvedValue({
      ok: true,
      sale: { id: "sale-1" } as never,
      items: [],
      stockErrors: [],
      duplicate: true,
      deliveryNote: null,
    });
    await POST(
      checkoutRequest({
        items: [{ stock_item_id: "si1", qty: 1, unit_price: 10 }],
        payment_method: "cash",
        client_ref: "local-42",
      }),
    );
    expect(checkoutSale).toHaveBeenCalledWith(
      expect.anything(),
      expect.objectContaining({ client_ref: "local-42" }),
    );
  });

  it("returns 401 without a valid POS_API_KEY", async () => {
    const res = await POST(checkoutRequest({ items: [] }, "Bearer wrong"));
    expect(res.status).toBe(401);
  });
});