toanhoang
abec58d239
Nullable FK from License to PurchaseOrder for supply-side traceability (which PO a license came in through), mirroring AssetItem.purchaseOrderId's just-merged pattern exactly. Separate commit from the earlier License.vendorId retrofit per the project's 1-commit-per-business-change convention.
723 lines
23 KiB
TypeScript
723 lines
23 KiB
TypeScript
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import type { Mock } from "vitest";
|
|
import type { Session } from "next-auth";
|
|
import {
|
|
createLicense,
|
|
listLicenses,
|
|
validateCreateLicenseInput,
|
|
} from "@/lib/licenses";
|
|
import { prisma } from "@/lib/prisma";
|
|
|
|
// Note: this file has two layers of coverage, mirroring tests/assets.test.ts:
|
|
// - lib-level tests below exercise src/lib/licenses.ts directly (validation,
|
|
// seatsUsed always 0, list ordering).
|
|
// - route-level tests (further down) exercise src/app/api/licenses/route.ts
|
|
// over HTTP, including the auth() gate — mirrors tests/assets.test.ts's
|
|
// @/auth mocking pattern.
|
|
vi.mock("@/auth", () => ({ auth: vi.fn() }));
|
|
|
|
import { GET, POST } from "@/app/api/licenses/route";
|
|
import { auth } from "@/auth";
|
|
|
|
const mockedAuth = auth as unknown as Mock<() => Promise<Session | null>>;
|
|
|
|
const testSession: Session = {
|
|
user: { id: "test-user-id" },
|
|
expires: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
|
|
};
|
|
|
|
function postRequest(body: unknown): Request {
|
|
return new Request("http://localhost/api/licenses", {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json" },
|
|
body: JSON.stringify(body),
|
|
});
|
|
}
|
|
|
|
// License.vendorId is a real FK to Vendor (see schema.prisma /
|
|
// src/lib/licenses.ts) — tests that need a valid vendorId create a real
|
|
// Vendor row first and use its id, rather than an arbitrary string. Mirrors
|
|
// tests/requests.test.ts's createTestEmployee() helper.
|
|
function createTestVendor(overrides: { name?: string } = {}) {
|
|
return prisma.vendor.create({
|
|
data: {
|
|
name: overrides.name ?? "Test Vendor",
|
|
contactEmail: "[email protected]",
|
|
contactPhone: "0281234567",
|
|
address: "123 Test Street",
|
|
},
|
|
});
|
|
}
|
|
|
|
// License.purchaseOrderId is a real FK to PurchaseOrder (see schema.prisma /
|
|
// src/lib/licenses.ts) — tests that need a valid purchaseOrderId create a
|
|
// real PurchaseOrder row first and use its id. Mirrors
|
|
// tests/assets.test.ts's createTestPurchaseOrder() helper.
|
|
function createTestPurchaseOrder(overrides: { vendorId?: string } = {}) {
|
|
return prisma.purchaseOrder.create({
|
|
data: {
|
|
vendorId: overrides.vendorId as string,
|
|
orderDate: new Date("2026-08-01"),
|
|
expectedDate: new Date("2026-08-10"),
|
|
},
|
|
});
|
|
}
|
|
|
|
beforeEach(async () => {
|
|
// Each test starts from empty tables so listing/order assertions are
|
|
// deterministic. licenses must be cleared before purchase_orders/vendors
|
|
// since licenses has FKs (ON DELETE RESTRICT to vendors, ON DELETE SET
|
|
// NULL to purchase_orders) to both. purchase_orders must be cleared
|
|
// before vendors (ON DELETE RESTRICT to vendors, mirrors
|
|
// tests/assets.test.ts).
|
|
await prisma.license.deleteMany();
|
|
await prisma.purchaseOrder.deleteMany();
|
|
await prisma.vendor.deleteMany();
|
|
// Default to a logged-in session — the lib-level tests below don't go
|
|
// through the route at all (so this is a no-op for them), and the
|
|
// route-level tests exercise business logic, not auth gating (that's
|
|
// covered by the "auth gating" describe block further down).
|
|
mockedAuth.mockResolvedValue(testSession);
|
|
});
|
|
|
|
describe("validateCreateLicenseInput", () => {
|
|
it("accepts valid input with an expiryDate", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: 10,
|
|
expiryDate: "2027-01-15",
|
|
licenseType: "subscription",
|
|
});
|
|
|
|
expect(result.ok).toBe(true);
|
|
if (result.ok) {
|
|
expect(result.value).toMatchObject({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
});
|
|
expect(result.value.expiryDate).toBeInstanceOf(Date);
|
|
}
|
|
});
|
|
|
|
it("accepts valid input with no expiryDate (perpetual license)", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Windows Server 2022",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: 5,
|
|
licenseType: "perpetual",
|
|
});
|
|
|
|
expect(result.ok).toBe(true);
|
|
if (result.ok) {
|
|
expect(result.value.expiryDate).toBeUndefined();
|
|
}
|
|
});
|
|
|
|
it("rejects an empty name", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
});
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) {
|
|
expect(result.error).toMatch(/name/i);
|
|
}
|
|
});
|
|
|
|
it("rejects a vendorId that is not a valid UUID", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "not-a-uuid",
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
});
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) {
|
|
expect(result.error).toMatch(/vendorId/i);
|
|
}
|
|
});
|
|
|
|
it("rejects a missing vendorId", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
});
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) {
|
|
expect(result.error).toMatch(/vendorId/i);
|
|
}
|
|
});
|
|
|
|
it("rejects a zero seatsTotal", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: 0,
|
|
licenseType: "subscription",
|
|
});
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) {
|
|
expect(result.error).toMatch(/seatsTotal/i);
|
|
}
|
|
});
|
|
|
|
it("rejects a negative seatsTotal", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: -5,
|
|
licenseType: "subscription",
|
|
});
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) {
|
|
expect(result.error).toMatch(/seatsTotal/i);
|
|
}
|
|
});
|
|
|
|
it("rejects a non-integer seatsTotal", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: 3.5,
|
|
licenseType: "subscription",
|
|
});
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) {
|
|
expect(result.error).toMatch(/seatsTotal/i);
|
|
}
|
|
});
|
|
|
|
it("rejects an invalid expiryDate", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: 10,
|
|
expiryDate: "not-a-date",
|
|
licenseType: "subscription",
|
|
});
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) {
|
|
expect(result.error).toMatch(/expiryDate/i);
|
|
}
|
|
});
|
|
|
|
it("rejects an invalid licenseType", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: 10,
|
|
licenseType: "trial",
|
|
});
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) {
|
|
expect(result.error).toMatch(/licenseType/i);
|
|
}
|
|
});
|
|
|
|
it("rejects a missing licenseType", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: 10,
|
|
});
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) {
|
|
expect(result.error).toMatch(/licenseType/i);
|
|
}
|
|
});
|
|
|
|
it("rejects a purchaseOrderId that is not a valid UUID", () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "11111111-1111-1111-1111-111111111111",
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
purchaseOrderId: "not-a-uuid",
|
|
});
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) {
|
|
expect(result.error).toMatch(/purchaseOrderId/i);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("createLicense", () => {
|
|
it("creates a license with seatsUsed always 0, regardless of client input", async () => {
|
|
const vendor = await createTestVendor();
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 10,
|
|
// @ts-expect-error -- seatsUsed is intentionally not part of
|
|
// CreateLicenseInput; this simulates a client trying to sneak it in.
|
|
seatsUsed: 999,
|
|
expiryDate: "2027-01-15",
|
|
licenseType: "subscription",
|
|
});
|
|
expect(result.ok).toBe(true);
|
|
if (!result.ok) return;
|
|
|
|
const created = await createLicense(result.value);
|
|
expect(created.ok).toBe(true);
|
|
if (!created.ok) return;
|
|
const record = created.value;
|
|
|
|
expect(record.seats_used).toBe(0);
|
|
expect(record).toMatchObject({
|
|
name: "Adobe Creative Cloud",
|
|
vendor_id: vendor.id,
|
|
seats_total: 10,
|
|
license_type: "subscription",
|
|
});
|
|
expect(typeof record.id).toBe("string");
|
|
expect(record.id.length).toBeGreaterThan(0);
|
|
expect(Number.isNaN(Date.parse(record.expiry_date as string))).toBe(false);
|
|
expect(Number.isNaN(Date.parse(record.created_at))).toBe(false);
|
|
});
|
|
|
|
it("creates a perpetual license with no expiryDate", async () => {
|
|
const vendor = await createTestVendor();
|
|
const result = validateCreateLicenseInput({
|
|
name: "Windows Server 2022",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 5,
|
|
licenseType: "perpetual",
|
|
});
|
|
expect(result.ok).toBe(true);
|
|
if (!result.ok) return;
|
|
|
|
const created = await createLicense(result.value);
|
|
expect(created.ok).toBe(true);
|
|
if (!created.ok) return;
|
|
const record = created.value;
|
|
|
|
expect(record.expiry_date).toBeNull();
|
|
expect(record.seats_used).toBe(0);
|
|
expect(record.license_type).toBe("perpetual");
|
|
});
|
|
|
|
it("returns a clean error when vendorId doesn't reference an existing vendor", async () => {
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "00000000-0000-0000-0000-000000000000",
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
});
|
|
expect(result.ok).toBe(true);
|
|
if (!result.ok) return;
|
|
|
|
const created = await createLicense(result.value);
|
|
expect(created.ok).toBe(false);
|
|
if (created.ok) return;
|
|
expect(created.error).toMatch(/vendorId/i);
|
|
expect(created.error).toMatch(/does not reference an existing vendor/i);
|
|
|
|
const remaining = await prisma.license.findMany();
|
|
expect(remaining).toHaveLength(0);
|
|
});
|
|
|
|
it("creates a license with a purchaseOrderId that references a real purchase order", async () => {
|
|
const vendor = await createTestVendor();
|
|
const purchaseOrder = await createTestPurchaseOrder({ vendorId: vendor.id });
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
purchaseOrderId: purchaseOrder.id,
|
|
});
|
|
expect(result.ok).toBe(true);
|
|
if (!result.ok) return;
|
|
|
|
const created = await createLicense(result.value);
|
|
expect(created.ok).toBe(true);
|
|
if (!created.ok) return;
|
|
expect(created.value.purchase_order_id).toBe(purchaseOrder.id);
|
|
});
|
|
|
|
it("creates a license with no purchaseOrderId (stays null)", async () => {
|
|
const vendor = await createTestVendor();
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
});
|
|
expect(result.ok).toBe(true);
|
|
if (!result.ok) return;
|
|
|
|
const created = await createLicense(result.value);
|
|
expect(created.ok).toBe(true);
|
|
if (!created.ok) return;
|
|
expect(created.value.purchase_order_id).toBeNull();
|
|
});
|
|
|
|
it("returns a clean error when purchaseOrderId doesn't reference an existing purchase order", async () => {
|
|
const vendor = await createTestVendor();
|
|
const result = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
purchaseOrderId: "00000000-0000-0000-0000-000000000000",
|
|
});
|
|
expect(result.ok).toBe(true);
|
|
if (!result.ok) return;
|
|
|
|
const created = await createLicense(result.value);
|
|
expect(created.ok).toBe(false);
|
|
if (created.ok) return;
|
|
expect(created.error).toMatch(/purchaseOrderId/i);
|
|
expect(created.error).toMatch(/does not reference an existing purchase order/i);
|
|
|
|
const remaining = await prisma.license.findMany();
|
|
expect(remaining).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe("listLicenses", () => {
|
|
it("lists created licenses, newest first", async () => {
|
|
const vendor1 = await createTestVendor({ name: "Microsoft VN" });
|
|
const vendor2 = await createTestVendor({ name: "Adobe VN" });
|
|
|
|
const first = validateCreateLicenseInput({
|
|
name: "Windows Server 2022",
|
|
vendorId: vendor1.id,
|
|
seatsTotal: 5,
|
|
licenseType: "perpetual",
|
|
});
|
|
expect(first.ok).toBe(true);
|
|
if (first.ok) await createLicense(first.value);
|
|
|
|
// Ensure a distinct created_at ordering even on fast filesystems/clocks.
|
|
await new Promise((resolve) => setTimeout(resolve, 5));
|
|
|
|
const second = validateCreateLicenseInput({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: vendor2.id,
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
});
|
|
expect(second.ok).toBe(true);
|
|
if (second.ok) await createLicense(second.value);
|
|
|
|
const records = await listLicenses();
|
|
|
|
expect(records).toHaveLength(2);
|
|
// newest first
|
|
expect(records[0]).toMatchObject({ name: "Adobe Creative Cloud", vendor_id: vendor2.id });
|
|
expect(records[1]).toMatchObject({ name: "Windows Server 2022", vendor_id: vendor1.id });
|
|
});
|
|
|
|
it("returns an empty list when there are no licenses", async () => {
|
|
const records = await listLicenses();
|
|
expect(records).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("POST /api/licenses", () => {
|
|
it("creates a license with seatsUsed always 0 on valid input", async () => {
|
|
const vendor = await createTestVendor();
|
|
const res = await POST(
|
|
postRequest({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 10,
|
|
expiryDate: "2027-01-15",
|
|
licenseType: "subscription",
|
|
})
|
|
);
|
|
|
|
expect(res.status).toBe(201);
|
|
const body = await res.json();
|
|
|
|
expect(body).toMatchObject({
|
|
name: "Adobe Creative Cloud",
|
|
vendor_id: vendor.id,
|
|
seats_total: 10,
|
|
seats_used: 0,
|
|
license_type: "subscription",
|
|
});
|
|
expect(typeof body.id).toBe("string");
|
|
expect(body.id.length).toBeGreaterThan(0);
|
|
expect(Number.isNaN(Date.parse(body.expiry_date))).toBe(false);
|
|
expect(Number.isNaN(Date.parse(body.created_at))).toBe(false);
|
|
});
|
|
|
|
it("creates a perpetual license with no expiryDate", async () => {
|
|
const vendor = await createTestVendor();
|
|
const res = await POST(
|
|
postRequest({
|
|
name: "Windows Server 2022",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 5,
|
|
licenseType: "perpetual",
|
|
})
|
|
);
|
|
|
|
expect(res.status).toBe(201);
|
|
const body = await res.json();
|
|
expect(body.expiry_date).toBeNull();
|
|
expect(body.seats_used).toBe(0);
|
|
});
|
|
|
|
it("rejects an empty name", async () => {
|
|
const vendor = await createTestVendor();
|
|
const res = await POST(
|
|
postRequest({ name: "", vendorId: vendor.id, seatsTotal: 10, licenseType: "subscription" })
|
|
);
|
|
|
|
expect(res.status).toBe(400);
|
|
const body = await res.json();
|
|
expect(body.error).toMatch(/name/i);
|
|
});
|
|
|
|
it("rejects a vendorId that is not a valid UUID", async () => {
|
|
const res = await POST(
|
|
postRequest({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "not-a-uuid",
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
})
|
|
);
|
|
|
|
expect(res.status).toBe(400);
|
|
const body = await res.json();
|
|
expect(body.error).toMatch(/vendorId/i);
|
|
});
|
|
|
|
it("rejects a vendorId that is a well-formed UUID but doesn't reference an existing vendor", async () => {
|
|
const res = await POST(
|
|
postRequest({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: "00000000-0000-0000-0000-000000000000",
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
})
|
|
);
|
|
|
|
expect(res.status).toBe(400);
|
|
const body = await res.json();
|
|
expect(body.error).toMatch(/vendorId/i);
|
|
expect(body.error).toMatch(/does not reference an existing vendor/i);
|
|
|
|
// And it must not have created anything.
|
|
const remaining = await prisma.license.findMany();
|
|
expect(remaining).toHaveLength(0);
|
|
});
|
|
|
|
it("rejects a zero seatsTotal", async () => {
|
|
const vendor = await createTestVendor();
|
|
const res = await POST(
|
|
postRequest({ name: "Adobe Creative Cloud", vendorId: vendor.id, seatsTotal: 0, licenseType: "subscription" })
|
|
);
|
|
|
|
expect(res.status).toBe(400);
|
|
const body = await res.json();
|
|
expect(body.error).toMatch(/seatsTotal/i);
|
|
});
|
|
|
|
it("rejects an invalid expiryDate", async () => {
|
|
const vendor = await createTestVendor();
|
|
const res = await POST(
|
|
postRequest({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 10,
|
|
expiryDate: "not-a-date",
|
|
licenseType: "subscription",
|
|
})
|
|
);
|
|
|
|
expect(res.status).toBe(400);
|
|
const body = await res.json();
|
|
expect(body.error).toMatch(/expiryDate/i);
|
|
});
|
|
|
|
it("rejects an invalid licenseType", async () => {
|
|
const vendor = await createTestVendor();
|
|
const res = await POST(
|
|
postRequest({ name: "Adobe Creative Cloud", vendorId: vendor.id, seatsTotal: 10, licenseType: "trial" })
|
|
);
|
|
|
|
expect(res.status).toBe(400);
|
|
const body = await res.json();
|
|
expect(body.error).toMatch(/licenseType/i);
|
|
});
|
|
|
|
it("creates a license with a purchaseOrderId that references a real purchase order", async () => {
|
|
const vendor = await createTestVendor();
|
|
const purchaseOrder = await createTestPurchaseOrder({ vendorId: vendor.id });
|
|
const res = await POST(
|
|
postRequest({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
purchaseOrderId: purchaseOrder.id,
|
|
})
|
|
);
|
|
|
|
expect(res.status).toBe(201);
|
|
const body = await res.json();
|
|
expect(body.purchase_order_id).toBe(purchaseOrder.id);
|
|
});
|
|
|
|
it("creates a license with no purchaseOrderId (stays null)", async () => {
|
|
const vendor = await createTestVendor();
|
|
const res = await POST(
|
|
postRequest({ name: "Adobe Creative Cloud", vendorId: vendor.id, seatsTotal: 10, licenseType: "subscription" })
|
|
);
|
|
|
|
expect(res.status).toBe(201);
|
|
const body = await res.json();
|
|
expect(body.purchase_order_id).toBeNull();
|
|
});
|
|
|
|
it("rejects a purchaseOrderId that is a well-formed UUID but doesn't reference an existing purchase order", async () => {
|
|
const vendor = await createTestVendor();
|
|
const res = await POST(
|
|
postRequest({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
purchaseOrderId: "00000000-0000-0000-0000-000000000000",
|
|
})
|
|
);
|
|
|
|
expect(res.status).toBe(400);
|
|
const body = await res.json();
|
|
expect(body.error).toMatch(/purchaseOrderId/i);
|
|
expect(body.error).toMatch(/does not reference an existing purchase order/i);
|
|
|
|
// And it must not have created anything.
|
|
const remaining = await prisma.license.findMany();
|
|
expect(remaining).toHaveLength(0);
|
|
});
|
|
|
|
it("rejects a purchaseOrderId that is not a valid UUID", async () => {
|
|
const vendor = await createTestVendor();
|
|
const res = await POST(
|
|
postRequest({
|
|
name: "Adobe Creative Cloud",
|
|
vendorId: vendor.id,
|
|
seatsTotal: 10,
|
|
licenseType: "subscription",
|
|
purchaseOrderId: "not-a-uuid",
|
|
})
|
|
);
|
|
|
|
expect(res.status).toBe(400);
|
|
const body = await res.json();
|
|
expect(body.error).toMatch(/purchaseOrderId/i);
|
|
});
|
|
|
|
it("rejects an invalid JSON body", async () => {
|
|
const req = new Request("http://localhost/api/licenses", {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json" },
|
|
body: "not json",
|
|
});
|
|
|
|
const res = await POST(req);
|
|
expect(res.status).toBe(400);
|
|
const body = await res.json();
|
|
expect(body.error).toMatch(/JSON/i);
|
|
});
|
|
|
|
it("rejects a non-object JSON body", async () => {
|
|
// Note: arrays are `typeof "object"` in JS, so they pass the route's
|
|
// object check (same behavior as /api/assets) — use a JSON string
|
|
// primitive here to actually exercise the "not an object" branch.
|
|
const res = await POST(postRequest("not an object"));
|
|
|
|
expect(res.status).toBe(400);
|
|
const body = await res.json();
|
|
expect(body.error).toMatch(/JSON object/i);
|
|
});
|
|
});
|
|
|
|
describe("GET /api/licenses", () => {
|
|
it("lists created licenses, newest first", async () => {
|
|
const vendor1 = await createTestVendor({ name: "Microsoft VN" });
|
|
const vendor2 = await createTestVendor({ name: "Adobe VN" });
|
|
|
|
await POST(
|
|
postRequest({ name: "Windows Server 2022", vendorId: vendor1.id, seatsTotal: 5, licenseType: "perpetual" })
|
|
);
|
|
// Ensure a distinct created_at ordering even on fast filesystems/clocks.
|
|
await new Promise((resolve) => setTimeout(resolve, 5));
|
|
await POST(
|
|
postRequest({ name: "Adobe Creative Cloud", vendorId: vendor2.id, seatsTotal: 10, licenseType: "subscription" })
|
|
);
|
|
|
|
const res = await GET();
|
|
expect(res.status).toBe(200);
|
|
|
|
const body = await res.json();
|
|
expect(Array.isArray(body)).toBe(true);
|
|
expect(body).toHaveLength(2);
|
|
|
|
// newest first
|
|
expect(body[0]).toMatchObject({ name: "Adobe Creative Cloud", vendor_id: vendor2.id });
|
|
expect(body[1]).toMatchObject({ name: "Windows Server 2022", vendor_id: vendor1.id });
|
|
});
|
|
|
|
it("returns an empty list when there are no licenses", async () => {
|
|
const res = await GET();
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json();
|
|
expect(body).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("auth gating on /api/licenses", () => {
|
|
// Mirrors tests/assets.test.ts's "auth gating" block — only checks
|
|
// session presence, per the flat permission model (no role/permission
|
|
// logic).
|
|
it("POST /api/licenses returns 401 without a session", async () => {
|
|
const vendor = await createTestVendor();
|
|
mockedAuth.mockResolvedValue(null);
|
|
|
|
const res = await POST(
|
|
postRequest({ name: "Adobe Creative Cloud", vendorId: vendor.id, seatsTotal: 10, licenseType: "subscription" })
|
|
);
|
|
|
|
expect(res.status).toBe(401);
|
|
const body = await res.json();
|
|
expect(body).toEqual({ error: "Unauthorized" });
|
|
|
|
// And it must not have created anything.
|
|
const remaining = await prisma.license.findMany();
|
|
expect(remaining).toHaveLength(0);
|
|
});
|
|
|
|
it("GET /api/licenses returns 401 without a session", async () => {
|
|
mockedAuth.mockResolvedValue(null);
|
|
|
|
const res = await GET();
|
|
|
|
expect(res.status).toBe(401);
|
|
const body = await res.json();
|
|
expect(body).toEqual({ error: "Unauthorized" });
|
|
});
|
|
});
|