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

537 lines
20 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { mkdtemp, rm } from "node:fs/promises";
import { join } from "node:path";
import { tmpdir } from "node:os";
import { Readable } from "node:stream";
import { mockClient } from "aws-sdk-client-mock";
import { GetObjectCommand, ListObjectsV2Command, S3Client } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
import { runTenantSnapshot, type PrismaRunner } from "./snapshot.js";
import {
isGlobalsRestoreMode,
runTenantRestore,
type PrismaRestoreRunner,
} from "./restore.js";
class FakeSourcePrisma 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 *findManyByWhere(
modelName: string,
where: Readonly<Record<string, unknown>>,
pageSize: number,
): AsyncIterable<Record<string, unknown>> {
void where;
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));
}
async findManyByForeignKeys(
modelName: string,
foreignKey: string,
ids: readonly string[],
): Promise<Record<string, unknown>[]> {
const list = this.globals[modelName] ?? [];
return list.filter(
(row) => typeof row[foreignKey] === "string" && ids.includes(row[foreignKey] as string),
);
}
}
class FakeTargetPrisma implements PrismaRestoreRunner {
readonly writes: Record<string, Record<string, unknown>[]> = {};
readonly writeOrder: string[] = [];
/** Rows that already exist on the target — used by upsertManyById to simulate prior state. */
readonly preExisting: Record<string, Set<string>> = {};
async createMany(modelName: string, rows: Record<string, unknown>[]): Promise<{ written: number }> {
if (rows.length > 0) this.writeOrder.push(modelName);
this.writes[modelName] = (this.writes[modelName] ?? []).concat(rows);
return { written: rows.length };
}
async upsertManyById(
modelName: string,
rows: Record<string, unknown>[],
): Promise<{ created: number; updated: number }> {
const existing = this.preExisting[modelName] ?? new Set<string>();
let created = 0;
let updated = 0;
for (const row of rows) {
const id = row.id as string;
if (existing.has(id)) {
updated += 1;
continue;
}
this.writes[modelName] = (this.writes[modelName] ?? []).concat(row);
created += 1;
}
return { created, updated };
}
}
/** Variant without upsertManyById — exercises the legacy-runner fallback. */
class LegacyTargetPrisma implements PrismaRestoreRunner {
readonly writes: Record<string, Record<string, unknown>[]> = {};
async createMany(modelName: string, rows: Record<string, unknown>[]): Promise<{ written: number }> {
this.writes[modelName] = (this.writes[modelName] ?? []).concat(rows);
return { written: rows.length };
}
}
class PartialWriteTargetPrisma extends FakeTargetPrisma {
constructor(private readonly partialModel: string) {
super();
}
override async createMany(modelName: string, rows: Record<string, unknown>[]): Promise<{ written: number }> {
this.writes[modelName] = (this.writes[modelName] ?? []).concat(rows);
return { written: modelName === this.partialModel ? Math.max(0, rows.length - 1) : rows.length };
}
}
describe("runTenantRestore", () => {
let workdir: string;
beforeEach(async () => {
workdir = await mkdtemp(join(tmpdir(), "tenant-restore-test-"));
});
afterEach(async () => {
await rm(workdir, { recursive: true, force: true });
});
it("recognizes supported globals restore modes", () => {
expect(isGlobalsRestoreMode("upsert")).toBe(true);
expect(isGlobalsRestoreMode("skip")).toBe(true);
expect(isGlobalsRestoreMode("error")).toBe(true);
expect(isGlobalsRestoreMode("merge")).toBe(false);
expect(isGlobalsRestoreMode("")).toBe(false);
});
it("round-trips a snapshot through restore with FK-remapped tenantId", async () => {
// 1. Snapshot from FakeSourcePrisma.
const sourcePrisma = new FakeSourcePrisma({
TenantUser: [
{ id: "tu1", tenantId: "tenant_a", userId: "u1", type: 1, joined: 1, status: 1 },
{ id: "tu2", tenantId: "tenant_a", userId: "u2", type: 1, joined: 1, status: 1 },
],
TenantUserInvitation: [
{ id: "inv1", tenantId: "tenant_a", email: "x@y.io", firstName: "X", lastName: "Y" },
],
});
const snapshotPath = join(workdir, "snap.tar.gz");
await runTenantSnapshot({
tenantId: "tenant_a",
profile: "full-anonymized",
prisma: sourcePrisma,
output: { kind: "local", path: snapshotPath },
logger: { info: vi.fn(), warn: vi.fn() },
});
// 2. Restore into FakeTargetPrisma.
const target = new FakeTargetPrisma();
const result = await runTenantRestore({
tenantId: "tenant_a_clone",
source: snapshotPath,
prisma: target,
yes: true,
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.manifest.sourceTenantId).toBe("tenant_a");
const tuEntry = result.perModel.find((m) => m.model === "TenantUser");
expect(tuEntry).toEqual({ model: "TenantUser", written: 2, expected: 2 });
// All rows should have the new tenantId.
expect(target.writes.TenantUser).toHaveLength(2);
for (const row of target.writes.TenantUser) {
expect(row.tenantId).toBe("tenant_a_clone");
}
// Anonymization preserved on the way in.
expect(target.writes.TenantUserInvitation?.[0]?.email).toMatch(/@anonymized\.test$/u);
}, 15_000);
it("restores FK-derived children without adding tenantId and in parent-first order", async () => {
const sourcePrisma = new FakeSourcePrisma({
TenantInboundAddress: [{ id: "inbound_1", tenantId: "tenant_a", address: "in@local.test" }],
Email: [{ id: "email_1", tenantInboundAddressId: "inbound_1", messageId: "message_1" }],
KnowledgeBase: [{ id: "kb_1", tenantId: "tenant_a" }],
KnowledgeBaseCategory: [{ id: "category_1", knowledgeBaseId: "kb_1" }],
Workflow: [{ id: "workflow_1", tenantId: "tenant_a" }],
WorkflowBlock: [{ id: "block_1", workflowId: "workflow_1" }],
WorkflowExecution: [
{ id: "execution_1", tenantId: "tenant_a", workflowId: "workflow_1", waitingBlockId: "block_1" },
],
Portal: [{ id: "portal_1", tenantId: "tenant_a" }],
PortalPage: [{ id: "page_1", portalId: "portal_1" }],
});
const snapshotPath = join(workdir, "derived.tar.gz");
await runTenantSnapshot({
tenantId: "tenant_a",
profile: "none",
superAdminConfirmed: true,
prisma: sourcePrisma,
output: { kind: "local", path: snapshotPath },
includeGlobals: false,
logger: { info: vi.fn(), warn: vi.fn() },
});
const target = new FakeTargetPrisma();
await runTenantRestore({
tenantId: "tenant_clone",
source: snapshotPath,
prisma: target,
yes: true,
logger: { info: vi.fn(), warn: vi.fn() },
});
for (const model of ["Email", "KnowledgeBaseCategory", "WorkflowBlock", "PortalPage"]) {
expect(target.writes[model]?.[0]).not.toHaveProperty("tenantId");
}
expect(target.writes.TenantInboundAddress?.[0]?.tenantId).toBe("tenant_clone");
expect(target.writeOrder.indexOf("TenantInboundAddress")).toBeLessThan(target.writeOrder.indexOf("Email"));
expect(target.writeOrder.indexOf("KnowledgeBase")).toBeLessThan(target.writeOrder.indexOf("KnowledgeBaseCategory"));
expect(target.writeOrder.indexOf("WorkflowBlock")).toBeLessThan(target.writeOrder.indexOf("WorkflowExecution"));
expect(target.writeOrder.indexOf("Portal")).toBeLessThan(target.writeOrder.indexOf("PortalPage"));
});
it("aborts when the operator answers 'no' to the confirmation prompt", async () => {
const sourcePrisma = new FakeSourcePrisma({
TenantUser: [{ id: "tu1", tenantId: "tenant_a", userId: "u1", type: 1, joined: 1, status: 1 }],
});
const snapshotPath = join(workdir, "snap.tar.gz");
await runTenantSnapshot({
tenantId: "tenant_a",
profile: "full-anonymized",
prisma: sourcePrisma,
output: { kind: "local", path: snapshotPath },
logger: { info: vi.fn(), warn: vi.fn() },
});
const target = new FakeTargetPrisma();
const { Readable } = await import("node:stream");
const { Writable } = await import("node:stream");
const stdin = Readable.from(["n\n"]);
const stdout = new Writable({ write: (_c, _e, cb) => cb() });
await expect(
runTenantRestore({
tenantId: "tenant_a_clone",
source: snapshotPath,
prisma: target,
yes: false,
stdin: stdin as NodeJS.ReadableStream,
stdout,
logger: { info: vi.fn(), warn: vi.fn() },
}),
).rejects.toThrow(/Aborted/u);
});
it("refuses to run in production without --allow-production-restore", async () => {
const prev = process.env.NODE_ENV;
process.env.NODE_ENV = "production";
try {
await expect(
runTenantRestore({
tenantId: "tenant_a_clone",
source: "/nonexistent.tar.gz",
prisma: new FakeTargetPrisma(),
yes: true,
logger: { info: vi.fn(), warn: vi.fn() },
}),
).rejects.toThrow(/production/u);
} finally {
process.env.NODE_ENV = prev;
}
});
it("rejects malformed s3 sources before attempting a restore", async () => {
await expect(
runTenantRestore({
tenantId: "tenant_a_clone",
source: "s3://bucket-only",
prisma: new FakeTargetPrisma(),
yes: true,
logger: { info: vi.fn(), warn: vi.fn() },
}),
).rejects.toThrow(/Invalid --source/u);
});
it("restores storage objects under the target tenant prefix", async () => {
const sourcePrisma = new FakeSourcePrisma({
TenantUser: [{ id: "tu1", tenantId: "tenant_a", userId: "u1", type: 1, joined: 1, status: 1 }],
});
const sourceS3 = mockClient(S3Client as never);
sourceS3.on(ListObjectsV2Command as never).callsFake(() => ({
Contents: [{ Key: "tenants/tenant_a/uploads/file.txt", Size: 11, ETag: '"etag"' }],
IsTruncated: false,
}));
sourceS3.on(GetObjectCommand as never).callsFake(() => ({
Body: Readable.from([Buffer.from("hello world")]),
}));
const snapshotPath = join(workdir, "snap-with-storage.tar.gz");
await runTenantSnapshot({
tenantId: "tenant_a",
profile: "full-anonymized",
prisma: sourcePrisma,
output: { kind: "local", path: snapshotPath },
s3Client: sourceS3 as unknown as S3Client,
storageBucket: "app-storage",
logger: { info: vi.fn(), warn: vi.fn() },
});
const uploadedKeys: string[] = [];
const origDone = Upload.prototype.done;
Upload.prototype.done = vi.fn(function (this: Upload) {
const params = this["params"] as { Key?: string };
if (params.Key) uploadedKeys.push(params.Key);
return Promise.resolve({ ETag: '"uploaded"' });
}) as never;
try {
const result = await runTenantRestore({
tenantId: "tenant_b",
source: snapshotPath,
prisma: new FakeTargetPrisma(),
storageBucket: "target-storage",
s3Client: new S3Client({ region: "us-east-1" }),
yes: true,
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.storageObjectsUploaded).toBe(1);
expect(uploadedKeys).toEqual(["tenants/tenant_b/uploads/file.txt"]);
} finally {
Upload.prototype.done = origDone;
}
});
it("warns when tenant-scoped model writes do not match manifest counts", async () => {
const sourcePrisma = new FakeSourcePrisma({
TenantUser: [
{ id: "tu1", tenantId: "tenant_a", userId: "u1", type: 1, joined: 1, status: 1 },
{ id: "tu2", tenantId: "tenant_a", userId: "u2", type: 1, joined: 1, status: 1 },
],
});
const snapshotPath = join(workdir, "snap.tar.gz");
await runTenantSnapshot({
tenantId: "tenant_a",
profile: "full-anonymized",
prisma: sourcePrisma,
output: { kind: "local", path: snapshotPath },
includeGlobals: false,
logger: { info: vi.fn(), warn: vi.fn() },
});
const warn = vi.fn();
const result = await runTenantRestore({
tenantId: "tenant_a_clone",
source: snapshotPath,
prisma: new PartialWriteTargetPrisma("TenantUser"),
yes: true,
logger: { info: vi.fn(), warn },
});
expect(result.perModel.find((m) => m.model === "TenantUser")).toEqual({
model: "TenantUser",
written: 1,
expected: 2,
});
expect(warn).toHaveBeenCalledWith(expect.stringContaining("Model TenantUser: wrote 1 rows"));
expect(warn).toHaveBeenCalledWith(expect.stringContaining("Row-count mismatch"));
});
describe("globals replay", () => {
async function snapshotWithUsers(snapshotPath: string): Promise<void> {
const sourcePrisma = new FakeSourcePrisma(
{
TenantUser: [
{ id: "tu1", tenantId: "tenant_a", userId: "u1", type: 1, joined: 1, status: 1 },
{ id: "tu2", tenantId: "tenant_a", userId: "u2", type: 1, joined: 1, status: 1 },
],
},
{
User: [
{ id: "u1", email: "first@real.com", firstName: "First", lastName: "Real" },
{ id: "u2", email: "second@real.com", firstName: "Second", lastName: "Real" },
],
},
);
await runTenantSnapshot({
tenantId: "tenant_a",
profile: "full-anonymized",
prisma: sourcePrisma,
output: { kind: "local", path: snapshotPath },
logger: { info: vi.fn(), warn: vi.fn() },
});
}
it("replays globals BEFORE tenant-scoped models (default upsert mode)", async () => {
const snapshotPath = join(workdir, "snap.tar.gz");
await snapshotWithUsers(snapshotPath);
const target = new FakeTargetPrisma();
const result = await runTenantRestore({
tenantId: "tenant_a_clone",
source: snapshotPath,
prisma: target,
yes: true,
logger: { info: vi.fn(), warn: vi.fn() },
});
const userGlobal = result.globals.find((g) => g.model === "User");
expect(userGlobal).toEqual({ model: "User", expected: 2, created: 2, existed: 0 });
// Users landed in target.
expect(target.writes.User).toHaveLength(2);
// And TenantUser rows landed under the new tenantId.
expect(target.writes.TenantUser).toHaveLength(2);
for (const row of target.writes.TenantUser) {
expect(row.tenantId).toBe("tenant_a_clone");
}
});
it("upsert mode reports existed=N when globals already exist on target", async () => {
const snapshotPath = join(workdir, "snap.tar.gz");
await snapshotWithUsers(snapshotPath);
const target = new FakeTargetPrisma();
target.preExisting.User = new Set(["u1"]); // one of two users already present
const result = await runTenantRestore({
tenantId: "tenant_a_clone",
source: snapshotPath,
prisma: target,
yes: true,
globalsMode: "upsert",
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.globals.find((g) => g.model === "User")).toEqual({
model: "User",
expected: 2,
created: 1,
existed: 1,
});
// Only the new user landed; the existing u1 was left in place.
expect(target.writes.User).toHaveLength(1);
expect((target.writes.User[0] as { id: string }).id).toBe("u2");
});
it("error mode aborts when a global already exists on target", async () => {
const snapshotPath = join(workdir, "snap.tar.gz");
await snapshotWithUsers(snapshotPath);
const target = new FakeTargetPrisma();
target.preExisting.User = new Set(["u1"]);
await expect(
runTenantRestore({
tenantId: "tenant_a_clone",
source: snapshotPath,
prisma: target,
yes: true,
globalsMode: "error",
logger: { info: vi.fn(), warn: vi.fn() },
}),
).rejects.toThrow(/--globals=error/u);
});
it("skip mode falls back to createMany semantics for legacy runners", async () => {
const snapshotPath = join(workdir, "snap.tar.gz");
await snapshotWithUsers(snapshotPath);
const target = new LegacyTargetPrisma();
const result = await runTenantRestore({
tenantId: "tenant_a_clone",
source: snapshotPath,
prisma: target,
yes: true,
globalsMode: "skip",
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.globals.find((g) => g.model === "User")?.created).toBe(2);
expect(target.writes.User).toHaveLength(2);
});
it("default upsert mode warns and falls back for legacy runners", async () => {
const snapshotPath = join(workdir, "snap.tar.gz");
await snapshotWithUsers(snapshotPath);
const target = new LegacyTargetPrisma();
const warn = vi.fn();
const result = await runTenantRestore({
tenantId: "tenant_a_clone",
source: snapshotPath,
prisma: target,
yes: true,
logger: { info: vi.fn(), warn },
});
expect(result.globals.find((g) => g.model === "User")).toEqual({
model: "User",
expected: 2,
created: 2,
existed: 0,
});
expect(warn).toHaveBeenCalledWith(expect.stringContaining("does not implement upsertManyById"));
});
it("skip mode reports existing globals from partial createMany writes", async () => {
const snapshotPath = join(workdir, "snap.tar.gz");
await snapshotWithUsers(snapshotPath);
const result = await runTenantRestore({
tenantId: "tenant_a_clone",
source: snapshotPath,
prisma: new PartialWriteTargetPrisma("User"),
yes: true,
globalsMode: "skip",
logger: { info: vi.fn(), warn: vi.fn() },
});
expect(result.globals.find((g) => g.model === "User")).toEqual({
model: "User",
expected: 2,
created: 1,
existed: 1,
});
});
it("legacy snapshot (no globals slice) is tolerated with a warn line", async () => {
// Build a snapshot using a runner without findManyByIds — manifest will
// have no `globals` array (matches pre-feature snapshots).
const legacySource: PrismaRunner = {
async *findManyByTenant() {
// empty
},
async *findManyByWhere() {
// empty
},
};
const snapshotPath = join(workdir, "legacy.tar.gz");
await runTenantSnapshot({
tenantId: "tenant_a",
profile: "full-anonymized",
prisma: legacySource,
output: { kind: "local", path: snapshotPath },
logger: { info: vi.fn(), warn: vi.fn() },
});
const warn = vi.fn();
const result = await runTenantRestore({
tenantId: "tenant_a_clone",
source: snapshotPath,
prisma: new FakeTargetPrisma(),
yes: true,
logger: { info: vi.fn(), warn },
});
expect(result.globals).toEqual([]);
expect(warn).toHaveBeenCalledWith(expect.stringContaining("no globals slice"));
});
});
});