Make device row moves atomic

2026-07-23 18:52:40 +02:00
parent a6837d7242
commit cf356bbedc
7 changed files with 440 additions and 247 deletions
@@ -47,15 +47,49 @@ function createTestDatabase(): DatabaseContext {
  return context;
 }

-function insertDeviceRow(context: DatabaseContext) {
+function insertCircuit(
+  context: DatabaseContext,
+  input: {
+    id: string;
+    equipmentIdentifier: string;
+    sortOrder: number;
+    isReserve?: number;
+  }
+) {
+  const [seedCircuit] = context.db.select().from(circuits).limit(1).all();
+  context.db
+    .insert(circuits)
+    .values({
+      id: input.id,
+      circuitListId: seedCircuit.circuitListId,
+      sectionId: seedCircuit.sectionId,
+      equipmentIdentifier: input.equipmentIdentifier,
+      displayName: input.equipmentIdentifier,
+      sortOrder: input.sortOrder,
+      isReserve: input.isReserve ?? 1,
+    })
+    .run();
+}
+
+function insertDeviceRow(
+  context: DatabaseContext,
+  input: {
+    id?: string;
+    circuitId?: string;
+    sortOrder?: number;
+    displayName?: string;
+  } = {}
+) {
+  const rowId = input.id ?? "row-1";
+  const circuitId = input.circuitId ?? "circuit-1";
  context.db
    .insert(circuitDeviceRows)
    .values({
-      id: "row-1",
-      circuitId: "circuit-1",
-      sortOrder: 10,
+      id: rowId,
+      circuitId,
+      sortOrder: input.sortOrder ?? 10,
      name: "Leuchte",
-      displayName: "Leuchte",
+      displayName: input.displayName ?? "Leuchte",
      quantity: 1,
      powerPerUnit: 0.1,
      simultaneityFactor: 1,
@@ -64,7 +98,7 @@ function insertDeviceRow(context: DatabaseContext) {
  context.db
    .update(circuits)
    .set({ isReserve: 0 })
-    .where(eq(circuits.id, "circuit-1"))
+    .where(eq(circuits.id, circuitId))
    .run();
 }

@@ -283,4 +317,213 @@ describe("circuit device-row transaction repository", () => {
      context.close();
    }
  });
+
+  it("moves rows to an existing circuit and updates both reserve states together", () => {
+    const context = createTestDatabase();
+    try {
+      insertCircuit(context, {
+        id: "circuit-2",
+        equipmentIdentifier: "-1F2",
+        sortOrder: 20,
+      });
+      insertCircuit(context, {
+        id: "circuit-3",
+        equipmentIdentifier: "-1F3",
+        sortOrder: 30,
+      });
+      insertDeviceRow(context);
+      insertDeviceRow(context, {
+        id: "row-2",
+        circuitId: "circuit-2",
+        sortOrder: 10,
+        displayName: "Zweite Quellzeile",
+      });
+      insertDeviceRow(context, {
+        id: "target-row",
+        circuitId: "circuit-3",
+        sortOrder: 10,
+        displayName: "Bestehende Zielzeile",
+      });
+      const repository = new CircuitDeviceRowTransactionRepository(context.db);
+
+      const result = repository.moveRows({
+        rows: [
+          { id: "row-1", expectedCircuitId: "circuit-1" },
+          { id: "row-2", expectedCircuitId: "circuit-2" },
+        ],
+        targetCircuitId: "circuit-3",
+      });
+
+      const movedRows = context.db
+        .select()
+        .from(circuitDeviceRows)
+        .all()
+        .filter((row) => row.id === "row-1" || row.id === "row-2")
+        .sort((left, right) => left.sortOrder - right.sortOrder);
+      const persistedCircuits = context.db.select().from(circuits).all();
+      const targetCircuit = persistedCircuits.find(
+        (circuit) => circuit.id === "circuit-3"
+      );
+
+      assert.deepEqual(result, {
+        movedRowIds: ["row-1", "row-2"],
+        targetCircuitId: "circuit-3",
+        createdCircuitId: undefined,
+      });
+      assert.deepEqual(
+        movedRows.map((row) => [row.id, row.circuitId, row.sortOrder]),
+        [
+          ["row-1", "circuit-3", 20],
+          ["row-2", "circuit-3", 30],
+        ]
+      );
+      assert.equal(
+        persistedCircuits.find((circuit) => circuit.id === "circuit-1")?.isReserve,
+        1
+      );
+      assert.equal(
+        persistedCircuits.find((circuit) => circuit.id === "circuit-2")?.isReserve,
+        1
+      );
+      assert.equal(targetCircuit?.isReserve, 0);
+    } finally {
+      context.close();
+    }
+  });
+
+  it("rolls back an existing-target move when a reserve update fails", () => {
+    const context = createTestDatabase();
+    try {
+      insertCircuit(context, {
+        id: "circuit-2",
+        equipmentIdentifier: "-1F2",
+        sortOrder: 20,
+      });
+      insertDeviceRow(context);
+      context.sqlite.exec(`
+        CREATE TRIGGER fail_source_reserve_update
+        BEFORE UPDATE OF is_reserve ON circuits
+        WHEN NEW.id = 'circuit-1' AND NEW.is_reserve = 1
+        BEGIN
+          SELECT RAISE(ABORT, 'forced source reserve failure');
+        END;
+      `);
+      const repository = new CircuitDeviceRowTransactionRepository(context.db);
+
+      assert.throws(
+        () =>
+          repository.moveRows({
+            rows: [{ id: "row-1", expectedCircuitId: "circuit-1" }],
+            targetCircuitId: "circuit-2",
+          }),
+        /forced source reserve failure/
+      );
+
+      const [row] = context.db.select().from(circuitDeviceRows).all();
+      const persistedCircuits = context.db.select().from(circuits).all();
+      assert.equal(row.circuitId, "circuit-1");
+      assert.equal(
+        persistedCircuits.find((circuit) => circuit.id === "circuit-1")?.isReserve,
+        0
+      );
+      assert.equal(
+        persistedCircuits.find((circuit) => circuit.id === "circuit-2")?.isReserve,
+        1
+      );
+    } finally {
+      context.close();
+    }
+  });
+
+  it("creates a new target circuit and moves rows into it atomically", () => {
+    const context = createTestDatabase();
+    try {
+      insertDeviceRow(context);
+      const [sourceCircuit] = context.db
+        .select()
+        .from(circuits)
+        .where(eq(circuits.id, "circuit-1"))
+        .all();
+      const repository = new CircuitDeviceRowTransactionRepository(context.db);
+
+      const result = repository.moveRows({
+        rows: [{ id: "row-1", expectedCircuitId: "circuit-1" }],
+        createTargetCircuit: {
+          circuitListId: sourceCircuit.circuitListId,
+          sectionId: sourceCircuit.sectionId,
+          equipmentIdentifier: "-1F2",
+          displayName: "Neues Ziel",
+          sortOrder: 20,
+        },
+      });
+
+      const [movedRow] = context.db
+        .select()
+        .from(circuitDeviceRows)
+        .where(eq(circuitDeviceRows.id, "row-1"))
+        .all();
+      const [createdCircuit] = context.db
+        .select()
+        .from(circuits)
+        .where(eq(circuits.id, result.createdCircuitId!))
+        .all();
+      const [updatedSource] = context.db
+        .select()
+        .from(circuits)
+        .where(eq(circuits.id, "circuit-1"))
+        .all();
+
+      assert.equal(result.targetCircuitId, result.createdCircuitId);
+      assert.equal(createdCircuit.equipmentIdentifier, "-1F2");
+      assert.equal(createdCircuit.isReserve, 0);
+      assert.equal(movedRow.circuitId, createdCircuit.id);
+      assert.equal(updatedSource.isReserve, 1);
+    } finally {
+      context.close();
+    }
+  });
+
+  it("rolls back a newly created target circuit when the move fails", () => {
+    const context = createTestDatabase();
+    try {
+      insertDeviceRow(context);
+      const [sourceCircuit] = context.db
+        .select()
+        .from(circuits)
+        .where(eq(circuits.id, "circuit-1"))
+        .all();
+      context.sqlite.exec(`
+        CREATE TRIGGER fail_new_target_source_reserve
+        BEFORE UPDATE OF is_reserve ON circuits
+        WHEN NEW.id = 'circuit-1' AND NEW.is_reserve = 1
+        BEGIN
+          SELECT RAISE(ABORT, 'forced new-target move failure');
+        END;
+      `);
+      const repository = new CircuitDeviceRowTransactionRepository(context.db);
+
+      assert.throws(
+        () =>
+          repository.moveRows({
+            rows: [{ id: "row-1", expectedCircuitId: "circuit-1" }],
+            createTargetCircuit: {
+              circuitListId: sourceCircuit.circuitListId,
+              sectionId: sourceCircuit.sectionId,
+              equipmentIdentifier: "-1F2",
+              displayName: "Rollback-Ziel",
+              sortOrder: 20,
+            },
+          }),
+        /forced new-target move failure/
+      );
+
+      const [row] = context.db.select().from(circuitDeviceRows).all();
+      const persistedCircuits = context.db.select().from(circuits).all();
+      assert.equal(row.circuitId, "circuit-1");
+      assert.equal(persistedCircuits.length, 1);
+      assert.equal(persistedCircuits[0].isReserve, 0);
+    } finally {
+      context.close();
+    }
+  });
 });
@@ -414,7 +414,9 @@ describe("circuit write service rules", () => {
        async findById() {
          return { id: "r1", circuitId: "c1" } as never;
        },
-        moveRowsTransactional(input: typeof transactionalMove) {
+      } as never,
+      deviceRowTransactionStore: {
+        moveRows(input: typeof transactionalMove) {
          transactionalMove = input;
          return {
            movedRowIds: input!.rows.map((row) => row.id),
@@ -469,7 +471,9 @@ describe("circuit write service rules", () => {
        async findById() {
          return { id: "r1", circuitId: "c1" } as never;
        },
-        moveRowsTransactional(input: { rows: Array<{ id: string }>; createTargetCircuit?: typeof preparedTarget }) {
+      } as never,
+      deviceRowTransactionStore: {
+        moveRows(input: { rows: Array<{ id: string }>; createTargetCircuit?: typeof preparedTarget }) {
          preparedTarget = input.createTargetCircuit;
          return {
            movedRowIds: input.rows.map((row) => row.id),
@@ -525,7 +529,9 @@ describe("circuit write service rules", () => {
        async findById() {
          return { id: "r1", circuitId: "c1" } as never;
        },
-        moveRowsTransactional() {
+      } as never,
+      deviceRowTransactionStore: {
+        moveRows() {
          transactionalMoveCount += 1;
          throw new Error("same-circuit move must not write");
        },
@@ -565,7 +571,9 @@ describe("circuit write service rules", () => {
          }
          return { id: "r2", circuitId: "c2" } as never;
        },
-        moveRowsTransactional(input: typeof transactionalMove) {
+      } as never,
+      deviceRowTransactionStore: {
+        moveRows(input: typeof transactionalMove) {
          transactionalMove = input;
          return {
            movedRowIds: input!.rows.map((row) => row.id),
@@ -617,7 +625,9 @@ describe("circuit write service rules", () => {
        async findById(rowId: string) {
          return { id: rowId, circuitId: rowId === "r1" ? "c1" : "c2" } as never;
        },
-        moveRowsTransactional(input: { rows: Array<{ id: string }>; createTargetCircuit?: typeof preparedTarget }) {
+      } as never,
+      deviceRowTransactionStore: {
+        moveRows(input: { rows: Array<{ id: string }>; createTargetCircuit?: typeof preparedTarget }) {
          transactionCount += 1;
          preparedTarget = input.createTargetCircuit;
          return {
@@ -839,94 +849,6 @@ describe("circuit write service rules", () => {
    }
  });

-  it("bulk device row move uses one synchronous transaction callback", () => {
-    const repository = new CircuitDeviceRowRepository();
-    const originalTransaction = (db as unknown as { transaction: unknown }).transaction;
-
-    let callbackReturnedPromise = false;
-    let selectCall = 0;
-    let rowUpdateCount = 0;
-    const selectedRows = [
-      [
-        { id: "r1", circuitId: "c1" },
-        { id: "r2", circuitId: "c2" },
-      ],
-      [{ id: "c3", circuitListId: "l1" }],
-      [
-        { id: "c1", circuitListId: "l1" },
-        { id: "c2", circuitListId: "l1" },
-      ],
-      [{ id: "existing-target-row", sortOrder: 10 }],
-      [],
-      [],
-    ];
-
-    (db as unknown as { transaction: (cb: (tx: unknown) => unknown) => void }).transaction = (cb) => {
-      const fakeTx = {
-        select() {
-          const rows = selectedRows[selectCall++] ?? [];
-          const query = {
-            from() {
-              return query;
-            },
-            where() {
-              return query;
-            },
-            limit() {
-              return query;
-            },
-            all() {
-              return rows;
-            },
-          };
-          return query;
-        },
-        update() {
-          return {
-            set() {
-              return {
-                where() {
-                  return {
-                    run() {
-                      rowUpdateCount += 1;
-                      return { changes: 1 };
-                    },
-                  };
-                },
-              };
-            },
-          };
-        },
-      };
-      const callbackResult = cb(fakeTx);
-      callbackReturnedPromise = Boolean(
-        callbackResult && typeof (callbackResult as Promise<unknown>).then === "function"
-      );
-      if (callbackReturnedPromise) {
-        throw new Error("Transaction function cannot return a promise");
-      }
-    };
-
-    try {
-      const result = repository.moveRowsTransactional({
-        rows: [
-          { id: "r1", expectedCircuitId: "c1" },
-          { id: "r2", expectedCircuitId: "c2" },
-        ],
-        targetCircuitId: "c3",
-      });
-      assert.equal(callbackReturnedPromise, false);
-      assert.equal(rowUpdateCount, 5);
-      assert.deepEqual(result, {
-        movedRowIds: ["r1", "r2"],
-        targetCircuitId: "c3",
-        createdCircuitId: undefined,
-      });
-    } finally {
-      (db as unknown as { transaction: unknown }).transaction = originalTransaction;
-    }
-  });
-
  it("tracks local edits on linked device rows as overridden fields", async () => {
    let updatePayload: Record<string, unknown> = {};
    const current = {