forked from jappel/leistungsbilanz-ts
773 lines
25 KiB
TypeScript
773 lines
25 KiB
TypeScript
import crypto from "node:crypto";
|
|
import path from "node:path";
|
|
import assert from "node:assert/strict";
|
|
import { describe, it } from "node:test";
|
|
import { eq } from "drizzle-orm";
|
|
import { migrate } from "drizzle-orm/better-sqlite3/migrator";
|
|
import {
|
|
createDatabaseContext,
|
|
type DatabaseContext,
|
|
} from "../src/db/database-context.js";
|
|
import { DistributionBoardFixtureRepository } from "./support/distribution-board-fixture.js";
|
|
import { ProjectSnapshotRepository } from "../src/db/repositories/project-snapshot.repository.js";
|
|
import { ProjectTransferRepository } from "../src/db/repositories/project-transfer.repository.js";
|
|
import { ProjectStateRestoreCommandRepository } from "../src/db/repositories/project-state-restore-command.repository.js";
|
|
import { readProjectStateSnapshot } from "../src/db/repositories/project-state-snapshot.persistence.js";
|
|
import {
|
|
deleteEstimateBalance,
|
|
insertEstimateBalance,
|
|
readEstimateBalances,
|
|
} from "../src/db/repositories/estimate-balance.persistence.js";
|
|
import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
|
|
import { circuitLists } from "../src/db/schema/circuit-lists.js";
|
|
import { circuitProtectionDevices } from "../src/db/schema/circuit-protection-devices.js";
|
|
import { circuitSections } from "../src/db/schema/circuit-sections.js";
|
|
import { circuits } from "../src/db/schema/circuits.js";
|
|
import { distributionBoardComponentProtectionDevices } from "../src/db/schema/distribution-board-component-protection-devices.js";
|
|
import { distributionBoardComponents } from "../src/db/schema/distribution-board-components.js";
|
|
import { distributionBoards } from "../src/db/schema/distribution-boards.js";
|
|
import { buildings } from "../src/db/schema/buildings.js";
|
|
import { floors } from "../src/db/schema/floors.js";
|
|
import { projectDevices } from "../src/db/schema/project-devices.js";
|
|
import { projectSnapshots } from "../src/db/schema/project-snapshots.js";
|
|
import { projects } from "../src/db/schema/projects.js";
|
|
import { rooms } from "../src/db/schema/rooms.js";
|
|
import { deserializeProjectStateSnapshot } from "../src/domain/models/project-state-snapshot.model.js";
|
|
import { projectStateSnapshotSchemaVersion } from "../src/domain/models/project-state-snapshot.model.js";
|
|
import { createProjectStateRestoreCommand } from "../src/domain/models/project-state-restore-command.model.js";
|
|
import { ProjectRevisionConflictError } from "../src/domain/errors/project-revision-conflict.error.js";
|
|
import { ProjectSnapshotNameConflictError } from "../src/domain/errors/project-snapshot-name-conflict.error.js";
|
|
import { parseEstimateBalanceSnapshot } from "../src/estimate-balance/domain/estimate-balance-command.model.js";
|
|
|
|
function estimateBalance(projectId: string, suffix = "") {
|
|
return parseEstimateBalanceSnapshot({
|
|
id: `estimate${suffix}`,
|
|
projectId,
|
|
name: `Vorplanung${suffix}`,
|
|
workStage: "LPH 2",
|
|
dateIso: "2026-09-27",
|
|
reserveAvPercent: 10,
|
|
reserveSvPercent: 5,
|
|
sortOrder: 0,
|
|
groups: [
|
|
{
|
|
id: `estimate-group${suffix}`,
|
|
costGroup: "440",
|
|
title: "Starkstromanlagen",
|
|
editor: "Planung",
|
|
sortOrder: 0,
|
|
rows: [
|
|
{
|
|
id: `estimate-row${suffix}`,
|
|
sortOrder: 0,
|
|
supply: "ELT",
|
|
name: "Beleuchtung",
|
|
quantity: 100,
|
|
unit: "area",
|
|
connection: "fixed",
|
|
powerPerUnitW: 12,
|
|
simultaneityFactor: 0.8,
|
|
cosPhi: 0.95,
|
|
safetySupply: false,
|
|
remark: null,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
});
|
|
}
|
|
|
|
function createTestDatabase(): DatabaseContext {
|
|
const context = createDatabaseContext(":memory:");
|
|
migrate(context.db, {
|
|
migrationsFolder: path.resolve("src", "db", "migrations"),
|
|
});
|
|
context.db
|
|
.insert(projects)
|
|
.values({
|
|
id: "project-1",
|
|
name: "Snapshot-Projekt",
|
|
singlePhaseVoltageV: 230,
|
|
threePhaseVoltageV: 400,
|
|
})
|
|
.run();
|
|
const board = new DistributionBoardFixtureRepository(
|
|
context.db
|
|
).createWithCircuitListAndDefaultSections("project-1", "UV-01");
|
|
const list = context.db
|
|
.select()
|
|
.from(circuitLists)
|
|
.where(eq(circuitLists.distributionBoardId, board.id))
|
|
.get();
|
|
assert.ok(list);
|
|
const section = context.db
|
|
.select()
|
|
.from(circuitSections)
|
|
.where(eq(circuitSections.circuitListId, list.id))
|
|
.get();
|
|
assert.ok(section);
|
|
context.db
|
|
.insert(buildings)
|
|
.values({
|
|
id: "building-1",
|
|
projectId: "project-1",
|
|
name: "Haus A",
|
|
sortOrder: 0,
|
|
})
|
|
.run();
|
|
context.db
|
|
.insert(floors)
|
|
.values({
|
|
id: "floor-1",
|
|
projectId: "project-1",
|
|
name: "EG",
|
|
sortOrder: 10,
|
|
buildingId: "building-1",
|
|
})
|
|
.run();
|
|
context.db
|
|
.update(distributionBoards)
|
|
.set({
|
|
floorId: "floor-1",
|
|
supplyType: "SV",
|
|
simultaneityFactor: 0.65,
|
|
})
|
|
.where(eq(distributionBoards.id, board.id))
|
|
.run();
|
|
context.db
|
|
.insert(rooms)
|
|
.values({
|
|
id: "room-1",
|
|
projectId: "project-1",
|
|
floorId: "floor-1",
|
|
roomNumber: "001",
|
|
roomName: "Technik",
|
|
areaM2: 31.75,
|
|
})
|
|
.run();
|
|
context.db
|
|
.insert(projectDevices)
|
|
.values({
|
|
id: "device-1",
|
|
projectId: "project-1",
|
|
name: "Pumpe",
|
|
displayName: "Pumpe",
|
|
phaseType: "three_phase",
|
|
quantity: 1,
|
|
powerPerUnit: 2.5,
|
|
simultaneityFactor: 0.8,
|
|
cosPhi: 0.9,
|
|
voltageV: 400,
|
|
})
|
|
.run();
|
|
context.db
|
|
.insert(circuits)
|
|
.values({
|
|
id: "circuit-1",
|
|
circuitListId: list.id,
|
|
sectionId: section.id,
|
|
equipmentIdentifier: "-1F1",
|
|
displayName: "Technik",
|
|
sortOrder: 10,
|
|
voltage: 230,
|
|
isReserve: 0,
|
|
})
|
|
.run();
|
|
context.db
|
|
.insert(circuitDeviceRows)
|
|
.values({
|
|
id: "row-1",
|
|
circuitId: "circuit-1",
|
|
linkedProjectDeviceId: "device-1",
|
|
roomId: "room-1",
|
|
sortOrder: 10,
|
|
name: "Pumpe",
|
|
displayName: "Pumpe lokal",
|
|
phaseType: "three_phase",
|
|
quantity: 1,
|
|
powerPerUnit: 2.5,
|
|
simultaneityFactor: 0.8,
|
|
cosPhi: 0.9,
|
|
})
|
|
.run();
|
|
context.db
|
|
.insert(circuitProtectionDevices)
|
|
.values({
|
|
circuitId: "circuit-1",
|
|
type: "LS",
|
|
ratedCurrentA: 10,
|
|
fuseUtilizationCategory: null,
|
|
tripCharacteristic: "B",
|
|
rcdType: null,
|
|
ratedResidualCurrentMa: null,
|
|
})
|
|
.run();
|
|
context.db
|
|
.insert(distributionBoardComponents)
|
|
.values({
|
|
id: "component-1",
|
|
circuitListId: list.id,
|
|
sectionId: section.id,
|
|
equipmentIdentifier: "-1Q1.0",
|
|
name: "Gruppen-FI",
|
|
role: "group_residual_current_protection",
|
|
placement: "group",
|
|
sortOrder: 10,
|
|
})
|
|
.run();
|
|
context.db
|
|
.insert(distributionBoardComponentProtectionDevices)
|
|
.values({
|
|
componentId: "component-1",
|
|
type: "FI",
|
|
ratedCurrentA: 40,
|
|
fuseUtilizationCategory: null,
|
|
tripCharacteristic: null,
|
|
rcdType: "A",
|
|
ratedResidualCurrentMa: 30,
|
|
})
|
|
.run();
|
|
return context;
|
|
}
|
|
|
|
describe("project snapshot repository", () => {
|
|
it("captures, hashes and lists a complete named logical snapshot", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
const repository = new ProjectSnapshotRepository(context.db);
|
|
const created = repository.createNamed({
|
|
projectId: "project-1",
|
|
expectedRevision: 0,
|
|
name: " Vor Ausschreibung ",
|
|
description: " Sicherer Stand ",
|
|
actorId: "planner-1",
|
|
});
|
|
assert.ok(created);
|
|
assert.equal(created.sourceRevision, 0);
|
|
assert.equal(created.schemaVersion, projectStateSnapshotSchemaVersion);
|
|
assert.equal(created.name, "Vor Ausschreibung");
|
|
assert.equal(created.description, "Sicherer Stand");
|
|
assert.equal(created.createdByActorId, "planner-1");
|
|
assert.match(created.payloadSha256, /^[a-f0-9]{64}$/);
|
|
assert.equal(
|
|
context.db
|
|
.select({ currentRevision: projects.currentRevision })
|
|
.from(projects)
|
|
.where(eq(projects.id, "project-1"))
|
|
.get()?.currentRevision,
|
|
0
|
|
);
|
|
|
|
const persisted = context.db
|
|
.select()
|
|
.from(projectSnapshots)
|
|
.where(eq(projectSnapshots.id, created.id))
|
|
.get();
|
|
assert.ok(persisted);
|
|
assert.equal(
|
|
crypto
|
|
.createHash("sha256")
|
|
.update(persisted.payloadJson)
|
|
.digest("hex"),
|
|
persisted.payloadSha256
|
|
);
|
|
const state = deserializeProjectStateSnapshot(
|
|
persisted.payloadJson
|
|
);
|
|
assert.equal(state.project.id, "project-1");
|
|
assert.equal(state.distributionBoards.length, 1);
|
|
assert.equal(state.distributionBoards[0].floorId, "floor-1");
|
|
assert.equal(state.distributionBoards[0].supplyType, "SV");
|
|
assert.equal(
|
|
state.distributionBoards[0].simultaneityFactor,
|
|
0.65
|
|
);
|
|
assert.equal(state.circuitLists.length, 1);
|
|
assert.equal(
|
|
state.circuitSections.length,
|
|
context.db.select().from(circuitSections).all().length
|
|
);
|
|
assert.equal(state.circuits.length, 1);
|
|
assert.equal(state.circuitProtectionDevices.length, 1);
|
|
assert.equal(
|
|
state.distributionBoardComponents.length,
|
|
context.db
|
|
.select()
|
|
.from(distributionBoardComponents)
|
|
.all().length
|
|
);
|
|
assert.equal(
|
|
state.distributionBoardComponentProtectionDevices.length,
|
|
1
|
|
);
|
|
assert.equal(state.circuits[0].deviceRows.length, 1);
|
|
assert.equal(
|
|
state.circuits[0].deviceRows[0].linkedProjectDeviceId,
|
|
"device-1"
|
|
);
|
|
assert.equal(state.projectDevices.length, 1);
|
|
assert.equal(state.buildings.length, 1);
|
|
assert.equal(state.floors.length, 1);
|
|
assert.equal(state.floors[0].buildingId, "building-1");
|
|
assert.equal(state.rooms.length, 1);
|
|
assert.deepEqual(repository.listByProject("project-1"), [
|
|
created,
|
|
]);
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
|
|
it("rejects stale revisions and duplicate names without partial rows", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
const repository = new ProjectSnapshotRepository(context.db);
|
|
assert.throws(
|
|
() =>
|
|
repository.createNamed({
|
|
projectId: "project-1",
|
|
expectedRevision: 1,
|
|
name: "Stale",
|
|
}),
|
|
ProjectRevisionConflictError
|
|
);
|
|
const created = repository.createNamed({
|
|
projectId: "project-1",
|
|
expectedRevision: 0,
|
|
name: "Freigabe",
|
|
});
|
|
assert.ok(created);
|
|
assert.throws(
|
|
() =>
|
|
repository.createNamed({
|
|
projectId: "project-1",
|
|
expectedRevision: 0,
|
|
name: " Freigabe ",
|
|
}),
|
|
ProjectSnapshotNameConflictError
|
|
);
|
|
assert.equal(
|
|
context.db.select().from(projectSnapshots).all().length,
|
|
1
|
|
);
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
|
|
it("distinguishes unknown projects from empty snapshot lists", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
const repository = new ProjectSnapshotRepository(context.db);
|
|
assert.deepEqual(repository.listByProject("project-1"), []);
|
|
assert.equal(repository.listByProject("missing"), null);
|
|
assert.equal(
|
|
repository.createNamed({
|
|
projectId: "missing",
|
|
expectedRevision: 0,
|
|
name: "Unbekannt",
|
|
}),
|
|
null
|
|
);
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
|
|
it("verifies stored payload integrity before preparing a restore", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
const repository = new ProjectSnapshotRepository(context.db);
|
|
const snapshot = repository.createNamed({
|
|
projectId: "project-1",
|
|
expectedRevision: 0,
|
|
name: "Freigabe",
|
|
});
|
|
assert.ok(snapshot);
|
|
const prepared = repository.prepareRestore(
|
|
"project-1",
|
|
snapshot.id
|
|
);
|
|
assert.ok(prepared);
|
|
assert.equal(
|
|
prepared.command.payload.targetState.project.id,
|
|
"project-1"
|
|
);
|
|
const currentPayload = JSON.parse(
|
|
context.db
|
|
.select({ payloadJson: projectSnapshots.payloadJson })
|
|
.from(projectSnapshots)
|
|
.where(eq(projectSnapshots.id, snapshot.id))
|
|
.get()!.payloadJson
|
|
) as Record<string, unknown> & {
|
|
project: Record<string, unknown>;
|
|
};
|
|
currentPayload.schemaVersion = 99;
|
|
const unsupportedPayloadJson = JSON.stringify(currentPayload);
|
|
context.db
|
|
.update(projectSnapshots)
|
|
.set({
|
|
schemaVersion: 99,
|
|
payloadJson: unsupportedPayloadJson,
|
|
payloadSha256: crypto
|
|
.createHash("sha256")
|
|
.update(unsupportedPayloadJson)
|
|
.digest("hex"),
|
|
})
|
|
.where(eq(projectSnapshots.id, snapshot.id))
|
|
.run();
|
|
assert.throws(
|
|
() => repository.prepareRestore("project-1", snapshot.id),
|
|
/schema version is not supported/
|
|
);
|
|
context.db
|
|
.update(projectSnapshots)
|
|
.set({ payloadJson: `${JSON.stringify({})}\n` })
|
|
.where(eq(projectSnapshots.id, snapshot.id))
|
|
.run();
|
|
assert.throws(
|
|
() => repository.prepareRestore("project-1", snapshot.id),
|
|
/checksum verification failed/
|
|
);
|
|
assert.equal(
|
|
repository.prepareRestore("project-1", "missing"),
|
|
null
|
|
);
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
|
|
it("restores snapshots stored with an older supported schema version", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
const repository = new ProjectSnapshotRepository(context.db);
|
|
const snapshot = repository.createNamed({
|
|
projectId: "project-1",
|
|
expectedRevision: 0,
|
|
name: "Vor dem Update",
|
|
});
|
|
assert.ok(snapshot);
|
|
// Rewrite the stored payload into the previous (version 5) shape, as it
|
|
// exists for snapshots created before the current version.
|
|
const payload = JSON.parse(
|
|
context.db
|
|
.select({ payloadJson: projectSnapshots.payloadJson })
|
|
.from(projectSnapshots)
|
|
.where(eq(projectSnapshots.id, snapshot.id))
|
|
.get()!.payloadJson
|
|
) as {
|
|
schemaVersion: number;
|
|
project: Record<string, unknown>;
|
|
distributionBoards: Array<Record<string, unknown>>;
|
|
buildings?: unknown;
|
|
floors: Array<Record<string, unknown>>;
|
|
rooms: Array<Record<string, unknown>>;
|
|
};
|
|
payload.schemaVersion = 5;
|
|
delete payload.buildings;
|
|
for (const floor of payload.floors) {
|
|
delete floor.buildingId;
|
|
}
|
|
for (const room of payload.rooms) {
|
|
delete room.areaM2;
|
|
}
|
|
for (const field of ["siteAddress", "workStage", "projectLead", "projectEditor"]) {
|
|
delete payload.project[field];
|
|
}
|
|
for (const board of payload.distributionBoards) {
|
|
for (const field of [
|
|
"boardNumber",
|
|
"location",
|
|
"fedFrom",
|
|
"remark",
|
|
"feedingDistributionBoardId",
|
|
"feedingCircuitId",
|
|
]) {
|
|
delete board[field];
|
|
}
|
|
}
|
|
const payloadJson = JSON.stringify(payload);
|
|
context.db
|
|
.update(projectSnapshots)
|
|
.set({
|
|
schemaVersion: 5,
|
|
payloadJson,
|
|
payloadSha256: crypto
|
|
.createHash("sha256")
|
|
.update(payloadJson)
|
|
.digest("hex"),
|
|
})
|
|
.where(eq(projectSnapshots.id, snapshot.id))
|
|
.run();
|
|
|
|
const prepared = repository.prepareRestore("project-1", snapshot.id);
|
|
assert.ok(prepared);
|
|
const targetState = prepared.command.payload.targetState;
|
|
assert.equal(targetState.schemaVersion, projectStateSnapshotSchemaVersion);
|
|
assert.ok(targetState.distributionBoards.length > 0);
|
|
assert.ok(
|
|
targetState.distributionBoards.every(
|
|
(board) => board.boardNumber === null && board.fedFrom === null
|
|
)
|
|
);
|
|
// Version 5 predates buildings: the upgraded state has none.
|
|
assert.deepEqual(targetState.buildings, []);
|
|
assert.ok(targetState.floors.every((floor) => floor.buildingId === null));
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("portable project transfer", () => {
|
|
it("keeps estimate balances outside normal snapshot restore", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
insertEstimateBalance(context.db, estimateBalance("project-1"));
|
|
const current = readProjectStateSnapshot(context.db, "project-1");
|
|
assert.ok(current);
|
|
new ProjectStateRestoreCommandRepository(context.db).execute({
|
|
projectId: "project-1",
|
|
expectedRevision: 0,
|
|
source: "restore",
|
|
command: createProjectStateRestoreCommand(current.payloadSha256, {
|
|
...current.state,
|
|
project: { ...current.state.project, name: "Restored project" },
|
|
}),
|
|
});
|
|
assert.deepEqual(
|
|
readEstimateBalances(context.db, "project-1").map((entry) => entry.id),
|
|
["estimate"]
|
|
);
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
|
|
it("exports and atomically duplicates a complete project with new ids", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
context.db.update(projects).set({ siteAddress: "Musterstraße 1", workStage: "LPH 5", projectLead: "Planung", projectEditor: "Test" }).where(eq(projects.id, "project-1")).run();
|
|
context.db.update(distributionBoards).set({ boardNumber: "UV-01", location: "Technik", fedFrom: "HAK", remark: "Prüfstand" }).where(eq(distributionBoards.projectId, "project-1")).run();
|
|
insertEstimateBalance(context.db, estimateBalance("project-1"));
|
|
const repository = new ProjectTransferRepository(context.db);
|
|
const transfer = repository.exportProject("project-1");
|
|
assert.ok(transfer);
|
|
assert.equal(transfer.formatVersion, 2);
|
|
assert.equal(transfer.estimateBalances.length, 1);
|
|
const duplicate = repository.importDuplicate(transfer);
|
|
assert.notEqual(duplicate.projectId, "project-1");
|
|
assert.equal(duplicate.name, "Snapshot-Projekt (Kopie)");
|
|
|
|
const source = readProjectStateSnapshot(context.db, "project-1");
|
|
const copied = readProjectStateSnapshot(
|
|
context.db,
|
|
duplicate.projectId
|
|
);
|
|
assert.ok(source);
|
|
assert.ok(copied);
|
|
assert.equal(copied.currentRevision, 0);
|
|
assert.equal(copied.state.project.siteAddress, source.state.project.siteAddress);
|
|
assert.equal(copied.state.project.workStage, "LPH 5");
|
|
assert.equal(copied.state.project.projectLead, "Planung");
|
|
assert.equal(copied.state.project.projectEditor, "Test");
|
|
for (const field of ["boardNumber", "location", "fedFrom", "remark"] as const) {
|
|
assert.equal(copied.state.distributionBoards[0][field], source.state.distributionBoards[0][field]);
|
|
}
|
|
assert.equal(copied.state.circuits.length, source.state.circuits.length);
|
|
assert.notEqual(
|
|
copied.state.circuits[0].id,
|
|
source.state.circuits[0].id
|
|
);
|
|
assert.equal(copied.state.distributionBoardComponents.length, 3);
|
|
assert.equal(
|
|
copied.state.circuitProtectionDevices[0].circuitId,
|
|
copied.state.circuits[0].id
|
|
);
|
|
assert.equal(
|
|
copied.state.distributionBoardComponents.some(
|
|
(component) =>
|
|
component.id ===
|
|
copied.state
|
|
.distributionBoardComponentProtectionDevices[0]
|
|
.componentId
|
|
),
|
|
true
|
|
);
|
|
assert.notEqual(
|
|
copied.state.distributionBoardComponentProtectionDevices[0]
|
|
.componentId,
|
|
source.state.distributionBoardComponentProtectionDevices[0]
|
|
.componentId
|
|
);
|
|
assert.equal(
|
|
copied.state.circuits[0].deviceRows[0].linkedProjectDeviceId,
|
|
copied.state.projectDevices[0].id
|
|
);
|
|
assert.equal(
|
|
copied.state.circuits[0].deviceRows[0].roomId,
|
|
copied.state.rooms[0].id
|
|
);
|
|
assert.equal(copied.state.rooms[0].areaM2, 31.75);
|
|
assert.equal(
|
|
copied.state.distributionBoards[0].floorId,
|
|
copied.state.floors[0].id
|
|
);
|
|
assert.notEqual(copied.state.buildings[0].id, "building-1");
|
|
assert.equal(
|
|
copied.state.floors[0].buildingId,
|
|
copied.state.buildings[0].id
|
|
);
|
|
assert.equal(
|
|
copied.state.distributionBoards[0].supplyType,
|
|
"SV"
|
|
);
|
|
assert.equal(
|
|
copied.state.distributionBoards[0].simultaneityFactor,
|
|
0.65
|
|
);
|
|
const copiedBalances = readEstimateBalances(context.db, duplicate.projectId);
|
|
assert.equal(copiedBalances.length, 1);
|
|
assert.notEqual(copiedBalances[0].id, transfer.estimateBalances[0].id);
|
|
assert.notEqual(
|
|
copiedBalances[0].groups[0].id,
|
|
transfer.estimateBalances[0].groups[0].id
|
|
);
|
|
assert.notEqual(
|
|
copiedBalances[0].groups[0].rows[0].id,
|
|
transfer.estimateBalances[0].groups[0].rows[0].id
|
|
);
|
|
assert.equal(copiedBalances[0].groups[0].rows[0].name, "Beleuchtung");
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
|
|
it("prepares same-project replacement and rejects damaged payloads", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
const repository = new ProjectTransferRepository(context.db);
|
|
const transfer = repository.exportProject("project-1");
|
|
assert.ok(transfer);
|
|
const prepared = repository.prepareReplace("project-1", transfer);
|
|
assert.ok(prepared);
|
|
assert.equal(
|
|
prepared.command.payload.targetState.project.id,
|
|
"project-1"
|
|
);
|
|
assert.throws(
|
|
() =>
|
|
repository.importDuplicate({
|
|
...transfer,
|
|
payloadSha256: "0".repeat(64),
|
|
}),
|
|
/checksum verification failed/
|
|
);
|
|
assert.throws(
|
|
() =>
|
|
repository.importDuplicate({
|
|
...transfer,
|
|
estimateBalances: [estimateBalance("project-1", "-tampered")],
|
|
}),
|
|
/checksum verification failed/
|
|
);
|
|
assert.equal(
|
|
context.db.select().from(projects).all().length,
|
|
1
|
|
);
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
|
|
it("imports legacy transfer version 1 with no estimate balances", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
const snapshot = readProjectStateSnapshot(context.db, "project-1");
|
|
assert.ok(snapshot);
|
|
const legacyTransfer = {
|
|
format: "leistungsbilanz.project",
|
|
formatVersion: 1,
|
|
exportedAtIso: "2026-09-27T12:00:00.000Z",
|
|
payloadSha256: snapshot.payloadSha256,
|
|
projectState: snapshot.state,
|
|
};
|
|
const duplicate = new ProjectTransferRepository(context.db).importDuplicate(
|
|
legacyTransfer
|
|
);
|
|
assert.deepEqual(
|
|
readEstimateBalances(context.db, duplicate.projectId),
|
|
[]
|
|
);
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
|
|
it("replaces exported estimate balances atomically and restores them on undo", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
insertEstimateBalance(context.db, estimateBalance("project-1"));
|
|
const transferRepository = new ProjectTransferRepository(context.db);
|
|
const transfer = transferRepository.exportProject("project-1");
|
|
assert.ok(transfer);
|
|
|
|
deleteEstimateBalance(context.db, "project-1", "estimate");
|
|
insertEstimateBalance(context.db, estimateBalance("project-1", "-changed"));
|
|
const prepared = transferRepository.prepareReplace("project-1", transfer);
|
|
assert.ok(prepared);
|
|
const restored = new ProjectStateRestoreCommandRepository(context.db).execute({
|
|
projectId: "project-1",
|
|
expectedRevision: 0,
|
|
source: "restore",
|
|
command: prepared.command,
|
|
});
|
|
assert.deepEqual(
|
|
readEstimateBalances(context.db, "project-1").map((entry) => entry.id),
|
|
["estimate"]
|
|
);
|
|
|
|
new ProjectStateRestoreCommandRepository(context.db).execute({
|
|
projectId: "project-1",
|
|
expectedRevision: 1,
|
|
source: "undo",
|
|
historyTargetChangeSetId: restored.revision.changeSetId,
|
|
command: restored.inverse,
|
|
});
|
|
assert.deepEqual(
|
|
readEstimateBalances(context.db, "project-1").map((entry) => entry.id),
|
|
["estimate-changed"]
|
|
);
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
|
|
it("rolls back a duplicate when a late project-state insert fails", () => {
|
|
const context = createTestDatabase();
|
|
try {
|
|
insertEstimateBalance(context.db, estimateBalance("project-1"));
|
|
const repository = new ProjectTransferRepository(context.db);
|
|
const transfer = repository.exportProject("project-1");
|
|
assert.ok(transfer);
|
|
context.sqlite.exec(`
|
|
CREATE TRIGGER fail_imported_estimate_row
|
|
BEFORE INSERT ON estimate_rows
|
|
BEGIN
|
|
SELECT RAISE(ABORT, 'forced project transfer failure');
|
|
END;
|
|
`);
|
|
assert.throws(
|
|
() => repository.importDuplicate(transfer),
|
|
/forced project transfer failure/
|
|
);
|
|
assert.equal(
|
|
context.db.select().from(projects).all().length,
|
|
1
|
|
);
|
|
} finally {
|
|
context.close();
|
|
}
|
|
});
|
|
});
|