Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/cli/src/commands/tenant/snapshot.test.ts
T

467 lines
17 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { mkdtemp, readFile, rm } from "node:fs/promises";
import { join } from "node:path";
import { tmpdir } from "node:os";
import { mockClient } from "aws-sdk-client-mock";
import { GetObjectCommand, ListObjectsV2Command, S3Client } from "@aws-sdk/client-s3";
import { Readable } from "node:stream";
import { Upload } from "@aws-sdk/lib-storage";
import {
parseOutputTarget,
runTenantSnapshot,
type PrismaRunner,
} from "./snapshot.js";
import { TENANT_SCOPED_MODELS } from "./models.js";
class FakePrisma implements PrismaRunner {
constructor(
private readonly rows: Record<string, Record<string, unknown>[]>,
private readonly globals: Record<string, Record<string, unknown>[]> = {},
) {}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
async *findManyByTenant(
modelName: string,
tenantField: string,
tenantId: string,
pageSize: number,
): AsyncIterable<Record<string, unknown>> {
void tenantField;
void tenantId;
void pageSize;
const list = this.rows[modelName] ?? [];
for (const r of list) {
yield r;
}
}
async findManyByIds(modelName: string, ids: readonly string[]): Promise<Record<string, unknown>[]> {
const list = this.globals[modelName] ?? [];
return list.filter((r) => typeof r.id === "string" && ids.includes(r.id as string));
}
}
class RecordingPrisma extends FakePrisma {
readonly pageSizes: number[] = [];
override async *findManyByTenant(
modelName: string,
tenantField: string,
tenantId: string,
pageSize: number,
): AsyncIterable<Record<string, unknown>> {
this.pageSizes.push(pageSize);
yield* super.findManyByTenant(modelName, tenantField, tenantId, pageSize);
}
}
describe("parseOutputTarget", () => {
it("falls back to default local path when undefined", () => {
expect(parseOutputTarget(undefined, "/tmp/x.tar.gz")).toEqual({
kind: "local",
path: "/tmp/x.tar.gz",
});
});
it("treats unprefixed paths as local files", () => {
expect(parseOutputTarget("/snapshots/a.tar.gz", "/tmp/x")).toEqual({
kind: "local",
path: "/snapshots/a.tar.gz",
});
});
it("parses s3://bucket/key targets", () => {
expect(parseOutputTarget("s3://my-bucket/path/to/snap.tar.gz", "")).toEqual({
kind: "s3",
bucket: "my-bucket",
key: "path/to/snap.tar.gz",
});
});
it("rejects malformed s3:// targets", () => {
expect(() => parseOutputTarget("s3://bucket-only", "")).toThrow(/Invalid --output/u);
expect(() => parseOutputTarget("s3://bucket/", "")).toThrow(/Invalid --output/u);
});
});
describe("runTenantSnapshot", () => {
let workdir: string;
beforeEach(async () => {
workdir = await mkdtemp(join(tmpdir(), "tenant-snapshot-test-"));
});
afterEach(async () => {
await rm(workdir, { recursive: true, force: true });
});
it("writes a manifest with row counts per model and the chosen profile", async () => {
const prisma = new FakePrisma({
TenantUser: [
{ id: "tu1", tenantId: "ten_a", userId: "u1" },
{ id: "tu2", tenantId: "ten_a", userId: "u2" },
],
TenantUserInvitation: [
{ id: "inv1", tenantId: "ten_a", email: "alice@example.com", firstName: "Alice", lastName: "X" },
],
});
const outPath = join(workdir, "snap.tar.gz");
const result = await runTenantSnapshot({
tenantId: "ten_a",
profile: "full-anonymized",
prisma,
output: { kind: "local", path: outPath },
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.snapshotId).toMatch(/^tenant-snapshot-ten_a-/u);
expect(result.manifest.anonymization.profile).toBe("full-anonymized");
expect(result.manifest.anonymization.saltHash).toMatch(/^[a-f0-9]{64}$/u);
expect(result.manifest.sourceTenantId).toBe("ten_a");
const tuEntry = result.manifest.models.find((m) => m.model === "TenantUser");
expect(tuEntry?.rowCount).toBe(2);
const invEntry = result.manifest.models.find((m) => m.model === "TenantUserInvitation");
expect(invEntry?.rowCount).toBe(1);
// every other model should be present with rowCount=0.
expect(result.manifest.models).toHaveLength(TENANT_SCOPED_MODELS.length);
for (const m of result.manifest.models) {
if (m.model !== "TenantUser" && m.model !== "TenantUserInvitation") {
expect(m.rowCount).toBe(0);
}
}
});
it("requires explicit super-admin confirmation for the none anonymization profile", async () => {
await expect(
runTenantSnapshot({
tenantId: "ten_a",
profile: "none",
prisma: new FakePrisma({}),
output: { kind: "local", path: join(workdir, "snap.tar.gz") },
logger: { info: vi.fn(), warn: vi.fn() },
}),
).rejects.toThrow(/super-admin/iu);
});
it("records super-admin confirmation in the audit entry for profile none", async () => {
const outPath = join(workdir, "snap.tar.gz");
const auditPath = join(workdir, "audit.jsonl");
const fixedNow = new Date("2026-05-25T12:00:00.000Z");
const result = await runTenantSnapshot({
tenantId: "ten_a",
profile: "none",
prisma: new FakePrisma({ TenantUser: [{ id: "tu1", tenantId: "ten_a", userId: "u1" }] }),
output: { kind: "local", path: outPath },
superAdminConfirmed: true,
auditFilePath: auditPath,
actorUserId: "user_admin",
now: () => fixedNow,
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.manifest.anonymization.profile).toBe("none");
const audit = JSON.parse((await readFile(auditPath, "utf8")).trim()) as {
event: string;
sourceTenantId: string;
actorUserId: string;
createdAt: string;
outputTarget: string;
superAdminConfirmed: boolean;
};
expect(audit).toMatchObject({
event: "TENANT_SNAPSHOT_CREATED",
sourceTenantId: "ten_a",
actorUserId: "user_admin",
createdAt: "2026-05-25T12:00:00.000Z",
outputTarget: outPath,
superAdminConfirmed: true,
});
});
it("passes the configured page size to every tenant-scoped model query", async () => {
const prisma = new RecordingPrisma({});
await runTenantSnapshot({
tenantId: "ten_a",
profile: "full-anonymized",
prisma,
output: { kind: "local", path: join(workdir, "snap.tar.gz") },
pageSize: 17,
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(prisma.pageSizes).toHaveLength(TENANT_SCOPED_MODELS.length);
expect(new Set(prisma.pageSizes)).toEqual(new Set([17]));
});
it("anonymizes PII inline so the snapshot file contains no raw emails", async () => {
const prisma = new FakePrisma({
TenantUserInvitation: [
{ id: "inv1", tenantId: "ten_a", email: "real-person@example.org", firstName: "Real", lastName: "Person" },
],
});
const outPath = join(workdir, "snap.tar.gz");
const result = await runTenantSnapshot({
tenantId: "ten_a",
profile: "full-anonymized",
prisma,
output: { kind: "local", path: outPath },
logger: { info: vi.fn(), warn: vi.fn() },
});
// Untar locally and read the model file.
const { mkdtemp: mk } = await import("node:fs/promises");
const { extract } = await import("tar");
const untarDir = await mk(join(tmpdir(), "tenant-snap-untar-"));
try {
await extract({ file: outPath, cwd: untarDir });
const modelFile = join(untarDir, result.snapshotId, "postgres", "TenantUserInvitation.jsonl");
const content = await readFile(modelFile, "utf8");
expect(content).not.toContain("real-person@example.org");
expect(content).toMatch(/@anonymized\.test/u);
} finally {
await rm(untarDir, { recursive: true, force: true });
}
});
it("uploads to S3 when --output is s3://bucket/key", async () => {
const prisma = new FakePrisma({});
const s3Mock = mockClient(S3Client as never);
s3Mock.on(ListObjectsV2Command as never).callsFake(() => ({ Contents: [], IsTruncated: false }));
const fakeUpload = vi.fn().mockImplementation(() => ({
done: vi.fn().mockResolvedValue({ ETag: '"deadbeef"' }),
}));
// Monkey-patch the Upload constructor via the global hook in the source.
// We use the lib-storage Upload import inside s3-upload.ts; the helper
// accepts an `uploadCtor` override but runTenantSnapshot does not expose it.
// Instead we stub Upload.prototype.done.
const origDone = Upload.prototype.done;
Upload.prototype.done = vi.fn().mockResolvedValue({ ETag: '"deadbeef"' }) as never;
try {
const result = await runTenantSnapshot({
tenantId: "ten_a",
profile: "minimal-anonymized",
prisma,
output: { kind: "s3", bucket: "snapshots", key: "ten_a/snap.tar.gz" },
s3Client: s3Mock as unknown as S3Client,
storageBucket: "app-storage",
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.uploaded).toEqual({ bucket: "snapshots", key: "ten_a/snap.tar.gz" });
expect(result.manifest.storage).toBeDefined();
expect(result.manifest.storage?.objectCount).toBe(0);
} finally {
Upload.prototype.done = origDone;
void fakeUpload;
}
});
it("rejects storage snapshots without an S3 client or config", async () => {
await expect(
runTenantSnapshot({
tenantId: "ten_a",
profile: "full-anonymized",
prisma: new FakePrisma({}),
output: { kind: "local", path: join(workdir, "snap.tar.gz") },
storageBucket: "app-storage",
logger: { info: vi.fn(), warn: vi.fn() },
}),
).rejects.toThrow(/S3 client or config is required/u);
});
it("includes tenant storage objects when bucket is configured", async () => {
const prisma = new FakePrisma({});
const s3Mock = mockClient(S3Client as never);
s3Mock.on(ListObjectsV2Command as never).callsFake(() => ({
Contents: [
{ Key: "tenants/ten_a/avatars/me.png", Size: 17, ETag: '"abc"' },
{ Key: "tenants/ten_a/uploads/file.txt", Size: 5, ETag: '"def"' },
],
IsTruncated: false,
}));
s3Mock.on(GetObjectCommand as never).callsFake(() => ({
Body: Readable.from([Buffer.from("xx")]),
}));
const outPath = join(workdir, "snap.tar.gz");
const result = await runTenantSnapshot({
tenantId: "ten_a",
profile: "full-anonymized",
prisma,
output: { kind: "local", path: outPath },
s3Client: s3Mock as unknown as S3Client,
storageBucket: "app-storage",
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.manifest.storage?.objectCount).toBe(2);
});
it("paginates tenant storage extraction and ignores objects without keys", async () => {
const prisma = new FakePrisma({});
const s3Mock = mockClient(S3Client as never);
s3Mock.on(ListObjectsV2Command as never).callsFake((input: { ContinuationToken?: string }) => {
if (!input.ContinuationToken) {
return {
Contents: [
{ Size: 999, ETag: '"missing-key"' },
{ Key: "tenants/ten_a/avatars/me.png", Size: 17, ETag: '"abc"' },
],
IsTruncated: true,
NextContinuationToken: "page-2",
};
}
return {
Contents: [{ Key: "tenants/ten_a/uploads/file.txt", Size: 5, ETag: '"def"' }],
IsTruncated: false,
};
});
s3Mock.on(GetObjectCommand as never).callsFake(() => ({
Body: Readable.from([Buffer.from("xx")]),
}));
const result = await runTenantSnapshot({
tenantId: "ten_a",
profile: "full-anonymized",
prisma,
output: { kind: "local", path: join(workdir, "snap.tar.gz") },
s3Client: s3Mock as unknown as S3Client,
storageBucket: "app-storage",
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.manifest.storage?.objectCount).toBe(2);
expect(result.manifest.storage?.sizeBytes).toBe(22);
const listCalls = s3Mock.commandCalls(ListObjectsV2Command as never);
expect(listCalls).toHaveLength(2);
expect(listCalls[1].args[0].input).toMatchObject({ ContinuationToken: "page-2" });
expect(s3Mock.commandCalls(GetObjectCommand as never)).toHaveLength(2);
});
it("emits globals/User.jsonl with referenced + anonymized user rows", async () => {
const prisma = new FakePrisma(
{
TenantUser: [
{ id: "tu1", tenantId: "ten_a", userId: "u1", type: 1, joined: 1, status: 1 },
{ id: "tu2", tenantId: "ten_a", userId: "u2", type: 1, joined: 1, status: 1 },
],
},
{
User: [
{ id: "u1", email: "first@real.com", firstName: "First", lastName: "Real", phone: "+10001" },
{ id: "u2", email: "second@real.com", firstName: "Second", lastName: "Real", phone: "+10002" },
{ id: "u_unused", email: "unused@real.com", firstName: "Unused", lastName: "U" },
],
},
);
const outPath = join(workdir, "snap.tar.gz");
const result = await runTenantSnapshot({
tenantId: "ten_a",
profile: "full-anonymized",
prisma,
output: { kind: "local", path: outPath },
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.manifest.globals).toBeDefined();
const userEntry = result.manifest.globals?.find((g) => g.model === "User");
expect(userEntry?.rowCount).toBe(2);
expect(userEntry?.path).toBe("globals/User.jsonl");
const { extract } = await import("tar");
const untar = await mkdtemp(join(tmpdir(), "snap-globals-untar-"));
try {
await extract({ file: outPath, cwd: untar });
const text = await readFile(join(untar, result.snapshotId, "globals", "User.jsonl"), "utf8");
expect(text).not.toContain("first@real.com");
expect(text).not.toContain("second@real.com");
expect(text).not.toContain("unused@real.com");
const lines = text.trim().split("\n").map((l) => JSON.parse(l));
expect(lines.length).toBe(2);
const ids = new Set(lines.map((l) => l.id));
expect(ids).toEqual(new Set(["u1", "u2"]));
for (const u of lines) {
expect(u.email).toMatch(/@anonymized\.test$/);
// PII columns scrubbed.
expect(u.firstName).not.toMatch(/^(First|Second)$/);
expect(u.phone).toBeNull();
}
} finally {
await rm(untar, { recursive: true, force: true });
}
});
it("skips globals extraction when include-globals=false", async () => {
const prisma = new FakePrisma(
{ TenantUser: [{ id: "tu1", tenantId: "ten_a", userId: "u1", type: 1, joined: 1, status: 1 }] },
{ User: [{ id: "u1", email: "a@b.io", firstName: "A", lastName: "B" }] },
);
const outPath = join(workdir, "snap.tar.gz");
const result = await runTenantSnapshot({
tenantId: "ten_a",
profile: "full-anonymized",
prisma,
output: { kind: "local", path: outPath },
includeGlobals: false,
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.manifest.globals).toBeUndefined();
});
it("warns and skips globals when the runner has no findManyByIds method", async () => {
// A minimal runner without findManyByIds — simulates a legacy adapter.
class LegacyRunner implements PrismaRunner {
async *findManyByTenant(
modelName: string,
tenantField: string,
tenantId: string,
pageSize: number,
): AsyncIterable<Record<string, unknown>> {
void modelName;
void tenantField;
void tenantId;
void pageSize;
yield* [];
}
}
const warn = vi.fn();
const outPath = join(workdir, "snap.tar.gz");
const result = await runTenantSnapshot({
tenantId: "ten_a",
profile: "full-anonymized",
prisma: new LegacyRunner(),
output: { kind: "local", path: outPath },
logger: { info: vi.fn(), warn },
});
expect(result.manifest.globals).toBeUndefined();
expect(warn).toHaveBeenCalledWith(expect.stringContaining("findManyByIds"));
});
it("preserves anonymization-FK consistency across calls (same salt seed inside one run)", async () => {
const prisma = new FakePrisma({
TenantUserInvitation: [
{ id: "1", tenantId: "ten_a", email: "alice@example.com", firstName: "Alice", lastName: "Z" },
{ id: "2", tenantId: "ten_a", email: "alice@example.com", firstName: "Alice", lastName: "Z" },
],
});
const outPath = join(workdir, "snap.tar.gz");
const result = await runTenantSnapshot({
tenantId: "ten_a",
profile: "full-anonymized",
prisma,
output: { kind: "local", path: outPath },
logger: { info: vi.fn(), warn: vi.fn() },
});
const { extract } = await import("tar");
const untarDir = await mkdtemp(join(tmpdir(), "tenant-snap-untar-"));
try {
await extract({ file: outPath, cwd: untarDir });
const file = join(untarDir, result.snapshotId, "postgres", "TenantUserInvitation.jsonl");
const lines = (await readFile(file, "utf8")).trim().split("\n").map((l) => JSON.parse(l));
// Both rows have the same original email → must have the same anonymized email.
expect(lines[0].email).toBe(lines[1].email);
} finally {
await rm(untarDir, { recursive: true, force: true });
}
});
});