351 lines
13 KiB
TypeScript
351 lines
13 KiB
TypeScript
import { describe, expect, it, vi } from "vitest";
|
|
|
|
import { STORAGE_BYTES_PER_GB } from "@hivegrid/entitlements";
|
|
|
|
import {
|
|
assertTenantStorageReservation,
|
|
resolveTenantStorageCapacity,
|
|
resolveTenantStorageUsage,
|
|
TenantStorageCapacityError,
|
|
withTenantStorageWriteReservation,
|
|
} from "./storage-capacity.server";
|
|
|
|
const now = new Date("2026-07-30T12:00:00.000Z");
|
|
|
|
function subscription(overrides: Record<string, unknown> = {}) {
|
|
return {
|
|
status: "active",
|
|
planCode: "starter",
|
|
seatQuantity: 8,
|
|
officeSeatQuantity: 3,
|
|
fieldSeatQuantity: 6,
|
|
storageAddOnCodes: ["storage_100gb"],
|
|
trialEndsAt: null,
|
|
frozenAt: null,
|
|
cancelledAt: null,
|
|
products: [
|
|
{
|
|
createdAt: new Date("2026-07-01T00:00:00.000Z"),
|
|
cancelledAt: null,
|
|
endsAt: null,
|
|
currentPeriodStart: null,
|
|
planCode: "starter",
|
|
seatQuantity: 9,
|
|
officeSeatQuantity: 3,
|
|
fieldSeatQuantity: 6,
|
|
storageAddOnCodes: ["storage_100gb"],
|
|
quantity: 9,
|
|
subscriptionProduct: { code: "starter", lagoPlanCode: "starter", kind: "base_plan" },
|
|
},
|
|
],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe("tenant storage capacity", () => {
|
|
it("resolves the active commercial plan, role seats, and storage add-ons", async () => {
|
|
const client = {
|
|
tenantSubscription: { findUnique: vi.fn().mockResolvedValue(subscription()) },
|
|
};
|
|
|
|
await expect(resolveTenantStorageCapacity("tenant_1", client, now)).resolves.toEqual({
|
|
available: true,
|
|
capacity: {
|
|
planCode: "starter",
|
|
includedStorageGb: 100,
|
|
additionalSeatStorageGb: 20,
|
|
addOnStorageGb: 100,
|
|
totalStorageGb: 220,
|
|
totalStorageBytes: 220 * STORAGE_BYTES_PER_GB,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("fails closed for frozen billing and missing active base products", async () => {
|
|
const frozenClient = {
|
|
tenantSubscription: { findUnique: vi.fn().mockResolvedValue(subscription({ status: "frozen", frozenAt: now })) },
|
|
};
|
|
await expect(resolveTenantStorageCapacity("tenant_1", frozenClient, now)).resolves.toMatchObject({
|
|
available: false,
|
|
reason: "billing_read_only",
|
|
});
|
|
|
|
const missingPlanClient = {
|
|
tenantSubscription: { findUnique: vi.fn().mockResolvedValue(subscription({ products: [] })) },
|
|
};
|
|
await expect(resolveTenantStorageCapacity("tenant_1", missingPlanClient, now)).resolves.toMatchObject({
|
|
available: false,
|
|
reason: "plan_unknown",
|
|
});
|
|
});
|
|
|
|
it("counts stored files and in-progress reservations under the tenant lock", async () => {
|
|
const tx = {
|
|
$executeRaw: vi.fn().mockResolvedValue(1),
|
|
$queryRaw: vi.fn().mockResolvedValue([{ storedBytes: 50n, reservedBytes: 25n }]),
|
|
tenantSubscription: { findUnique: vi.fn().mockResolvedValue(subscription()) },
|
|
};
|
|
|
|
await expect(assertTenantStorageReservation(tx as never, "tenant_1", 100, now)).resolves.toMatchObject({
|
|
storedBytes: 50,
|
|
reservedBytes: 25,
|
|
requestedBytes: 100,
|
|
});
|
|
expect(tx.$executeRaw).toHaveBeenCalledOnce();
|
|
});
|
|
|
|
it("projects stored and in-progress bytes without taking the reservation lock", async () => {
|
|
const tx = {
|
|
$executeRaw: vi.fn(),
|
|
$queryRaw: vi.fn().mockResolvedValue([{ storedBytes: 50n, reservedBytes: 25n }]),
|
|
tenantSubscription: { findUnique: vi.fn().mockResolvedValue(subscription()) },
|
|
};
|
|
|
|
await expect(resolveTenantStorageUsage(tx as never, "tenant_1", now)).resolves.toMatchObject({
|
|
available: true,
|
|
storedBytes: 50,
|
|
reservedBytes: 25,
|
|
remainingBytes: 220 * STORAGE_BYTES_PER_GB - 75,
|
|
});
|
|
expect(tx.$executeRaw).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects reservations that exceed the paid capacity", async () => {
|
|
const tx = {
|
|
$executeRaw: vi.fn().mockResolvedValue(1),
|
|
$queryRaw: vi.fn().mockResolvedValue([{ storedBytes: BigInt(99 * STORAGE_BYTES_PER_GB), reservedBytes: 0n }]),
|
|
tenantSubscription: {
|
|
findUnique: vi.fn().mockResolvedValue(
|
|
subscription({
|
|
officeSeatQuantity: 2,
|
|
fieldSeatQuantity: 5,
|
|
storageAddOnCodes: [],
|
|
products: [
|
|
{
|
|
...subscription().products[0],
|
|
officeSeatQuantity: 2,
|
|
fieldSeatQuantity: 5,
|
|
storageAddOnCodes: [],
|
|
},
|
|
],
|
|
})
|
|
),
|
|
},
|
|
};
|
|
|
|
await expect(assertTenantStorageReservation(tx as never, "tenant_1", 2 * STORAGE_BYTES_PER_GB, now)).rejects.toMatchObject<TenantStorageCapacityError>({
|
|
code: "STORAGE_QUOTA_EXCEEDED",
|
|
});
|
|
});
|
|
|
|
it("persists a tenant-wide reservation before upload and swaps it for the File commit under the same lock", async () => {
|
|
let reservationStatus = "in_progress";
|
|
const events: string[] = [];
|
|
const tx = {
|
|
$executeRaw: vi.fn().mockImplementation(async () => {
|
|
events.push("lock");
|
|
return 1;
|
|
}),
|
|
$queryRaw: vi.fn().mockResolvedValue([{ storedBytes: 50n, reservedBytes: 25n }]),
|
|
tenantSubscription: { findUnique: vi.fn().mockResolvedValue(subscription()) },
|
|
file: { findFirst: vi.fn().mockResolvedValue({ id: "file_1" }) },
|
|
fileUpload: {
|
|
create: vi.fn().mockImplementation(async ({ data }) => {
|
|
events.push("reservation");
|
|
return { id: data.id, tenantId: data.tenantId, targetFileId: data.targetFileId, totalSizeBytes: data.totalSizeBytes };
|
|
}),
|
|
findFirst: vi.fn().mockImplementation(async () => ({ id: "reservation_1", status: reservationStatus })),
|
|
updateMany: vi.fn().mockImplementation(async ({ data }) => {
|
|
reservationStatus = data.status;
|
|
events.push(`reservation:${data.status}`);
|
|
return { count: 1 };
|
|
}),
|
|
},
|
|
};
|
|
|
|
await expect(
|
|
withTenantStorageWriteReservation({
|
|
reservation: {
|
|
reservationId: "reservation_1",
|
|
tenantId: "tenant_1",
|
|
actorUserId: "user_1",
|
|
targetFileId: "file_1",
|
|
originalFilename: "invoice.pdf",
|
|
mimeType: "application/pdf",
|
|
sizeBytes: 100,
|
|
now,
|
|
},
|
|
runTransaction: async (operation) => operation(tx as never),
|
|
upload: async () => {
|
|
events.push("upload");
|
|
return { key: "files/file_1" };
|
|
},
|
|
commit: async (_commitTx, stored) => {
|
|
events.push(`commit:${stored.key}`);
|
|
return "committed";
|
|
},
|
|
rollbackUpload: vi.fn(),
|
|
})
|
|
).resolves.toBe("committed");
|
|
|
|
expect(events).toEqual(["lock", "reservation", "upload", "lock", "commit:files/file_1", "reservation:completed"]);
|
|
expect(tx.fileUpload.create).toHaveBeenCalledWith({
|
|
data: expect.objectContaining({
|
|
status: "in_progress",
|
|
targetFileId: "file_1",
|
|
totalSizeBytes: 100,
|
|
expiresAt: new Date("9999-12-31T23:59:59.999Z"),
|
|
}),
|
|
select: { id: true, tenantId: true, targetFileId: true, totalSizeBytes: true },
|
|
});
|
|
expect(tx.file.findFirst).toHaveBeenCalledWith({
|
|
where: { id: "file_1", tenantId: "tenant_1", sizeBytes: 100 },
|
|
select: { id: true },
|
|
});
|
|
});
|
|
|
|
it("deletes a failed object before cancelling its paid-capacity reservation", async () => {
|
|
let reservationStatus = "in_progress";
|
|
const events: string[] = [];
|
|
const tx = {
|
|
$executeRaw: vi.fn().mockResolvedValue(1),
|
|
$queryRaw: vi.fn().mockResolvedValue([{ storedBytes: 0n, reservedBytes: 0n }]),
|
|
tenantSubscription: { findUnique: vi.fn().mockResolvedValue(subscription()) },
|
|
file: { findFirst: vi.fn() },
|
|
fileUpload: {
|
|
create: vi.fn().mockResolvedValue({ id: "reservation_1", tenantId: "tenant_1", targetFileId: "file_1", totalSizeBytes: 100 }),
|
|
findFirst: vi.fn().mockImplementation(async () => ({ id: "reservation_1", status: reservationStatus })),
|
|
updateMany: vi.fn().mockImplementation(async ({ data }) => {
|
|
reservationStatus = data.status;
|
|
events.push(`reservation:${data.status}`);
|
|
return { count: 1 };
|
|
}),
|
|
},
|
|
};
|
|
|
|
await expect(
|
|
withTenantStorageWriteReservation({
|
|
reservation: {
|
|
reservationId: "reservation_1",
|
|
tenantId: "tenant_1",
|
|
actorUserId: "user_1",
|
|
targetFileId: "file_1",
|
|
originalFilename: "invoice.pdf",
|
|
mimeType: "application/pdf",
|
|
sizeBytes: 100,
|
|
now,
|
|
},
|
|
runTransaction: async (operation) => operation(tx as never),
|
|
upload: async () => ({ key: "files/file_1" }),
|
|
commit: async () => {
|
|
throw new Error("database write failed");
|
|
},
|
|
rollbackUpload: async () => {
|
|
events.push("object:deleted");
|
|
},
|
|
})
|
|
).rejects.toThrow("database write failed");
|
|
|
|
expect(events).toEqual(["object:deleted", "reservation:cancelled"]);
|
|
expect(reservationStatus).toBe("cancelled");
|
|
});
|
|
|
|
it("rejects a commit that did not persist the exact reserved File row", async () => {
|
|
let reservationStatus = "in_progress";
|
|
const rollbackUpload = vi.fn().mockResolvedValue(undefined);
|
|
const tx = {
|
|
$executeRaw: vi.fn().mockResolvedValue(1),
|
|
$queryRaw: vi.fn().mockResolvedValue([{ storedBytes: 0n, reservedBytes: 0n }]),
|
|
tenantSubscription: { findUnique: vi.fn().mockResolvedValue(subscription()) },
|
|
file: { findFirst: vi.fn().mockResolvedValue(null) },
|
|
fileUpload: {
|
|
create: vi.fn().mockResolvedValue({ id: "reservation_1", tenantId: "tenant_1", targetFileId: "file_1", totalSizeBytes: 100 }),
|
|
findFirst: vi.fn().mockImplementation(async () => ({ id: "reservation_1", status: reservationStatus })),
|
|
updateMany: vi.fn().mockImplementation(async ({ data }) => {
|
|
reservationStatus = data.status;
|
|
return { count: 1 };
|
|
}),
|
|
},
|
|
};
|
|
|
|
await expect(
|
|
withTenantStorageWriteReservation({
|
|
reservation: {
|
|
reservationId: "reservation_1",
|
|
tenantId: "tenant_1",
|
|
actorUserId: "user_1",
|
|
targetFileId: "file_1",
|
|
originalFilename: "invoice.pdf",
|
|
mimeType: "application/pdf",
|
|
sizeBytes: 100,
|
|
now,
|
|
},
|
|
runTransaction: async (operation) => operation(tx as never),
|
|
upload: async () => ({ key: "files/file_1" }),
|
|
commit: async () => "callback-returned-without-file",
|
|
rollbackUpload,
|
|
})
|
|
).rejects.toMatchObject<TenantStorageCapacityError>({ code: "STORAGE_RESERVATION_INVALID" });
|
|
|
|
expect(rollbackUpload).toHaveBeenCalledWith({ key: "files/file_1" });
|
|
expect(reservationStatus).toBe("cancelled");
|
|
});
|
|
|
|
it("keeps an undeletable object charged through a durable in-progress reservation", async () => {
|
|
let reservationStatus = "in_progress";
|
|
const tx = {
|
|
$executeRaw: vi.fn().mockResolvedValue(1),
|
|
$queryRaw: vi.fn().mockResolvedValue([{ storedBytes: 0n, reservedBytes: 0n }]),
|
|
tenantSubscription: { findUnique: vi.fn().mockResolvedValue(subscription()) },
|
|
file: { findFirst: vi.fn() },
|
|
fileUpload: {
|
|
create: vi.fn().mockImplementation(async ({ data }) => ({
|
|
id: data.id,
|
|
tenantId: data.tenantId,
|
|
targetFileId: data.targetFileId,
|
|
totalSizeBytes: data.totalSizeBytes,
|
|
})),
|
|
findFirst: vi.fn().mockImplementation(async () => ({ id: "reservation_1", status: reservationStatus })),
|
|
updateMany: vi.fn().mockImplementation(async ({ data }) => {
|
|
reservationStatus = data.status;
|
|
return { count: 1 };
|
|
}),
|
|
},
|
|
};
|
|
|
|
await expect(
|
|
withTenantStorageWriteReservation({
|
|
reservation: {
|
|
reservationId: "reservation_1",
|
|
tenantId: "tenant_1",
|
|
actorUserId: "user_1",
|
|
targetFileId: "file_1",
|
|
originalFilename: "invoice.pdf",
|
|
mimeType: "application/pdf",
|
|
sizeBytes: 100,
|
|
now,
|
|
},
|
|
runTransaction: async (operation) => operation(tx as never),
|
|
upload: async () => ({ key: "files/file_1" }),
|
|
commit: async () => {
|
|
throw new Error("database write failed");
|
|
},
|
|
rollbackUpload: async () => {
|
|
throw new Error("object delete failed");
|
|
},
|
|
})
|
|
).rejects.toMatchObject({
|
|
message: "Storage write and rollback both failed",
|
|
errors: [expect.objectContaining({ message: "database write failed" }), expect.objectContaining({ message: "object delete failed" })],
|
|
});
|
|
|
|
expect(reservationStatus).toBe("in_progress");
|
|
expect(tx.fileUpload.updateMany).not.toHaveBeenCalled();
|
|
expect(tx.fileUpload.create).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
data: expect.objectContaining({ expiresAt: new Date("9999-12-31T23:59:59.999Z") }),
|
|
})
|
|
);
|
|
});
|
|
});
|