added unit test for setting correct paths for array changes (#1426)

* added unit test for setting correct paths for array changes

* added unit test for root value rewriting for testing against regression

Author: ellyxir

packages/runner/test/data-updating.test.ts

@@ -305,6 +305,44 @@ describe("data-updating", () => {
       expect(changes[0].value).toBe(2);
     });
 
+    it("should generate correct paths when setting array length to 0", () => {
+      const testCell = runtime.getCell<{ items: number[] }>(
+        space,
+        "normalizeAndDiff array length to zero",
+        undefined,
+        tx,
+      );
+      // Create array with 100 items
+      const largeArray = Array.from({ length: 100 }, (_, i) => i);
+      testCell.set({ items: largeArray });
+
+      // Now set length to 0 through the length property
+      const lengthLink = testCell.key("items").key("length")
+        .getAsNormalizedFullLink();
+      const changes = normalizeAndDiff(runtime, tx, lengthLink, 0);
+
+      // Should have 101 changes total
+      expect(changes.length).toBe(101);
+
+      // Find the length change
+      const lengthChange = changes.find((c) =>
+        c.location.path[c.location.path.length - 1] === "length"
+      );
+      expect(lengthChange).toBeDefined();
+      expect(lengthChange!.value).toBe(0);
+
+      // Verify all elements are marked undefined with correct paths
+      const elementChanges = changes.filter((c) =>
+        c.location.path[c.location.path.length - 1] !== "length"
+      );
+      expect(elementChanges.length).toBe(100);
+
+      elementChanges.forEach((change, i) => {
+        expect(change.location.path).toEqual(["items", i.toString()]);
+        expect(change.value).toBe(undefined);
+      });
+    });
+
     it("should handle array element changes", () => {
       const testCell = runtime.getCell<{ items: number[] }>(
         space,

packages/runner/test/storage-transaction-shim.test.ts

@@ -560,6 +560,94 @@ describe("URI Utils", () => {
   });
 });
 
+describe("root value rewriting", () => {
+  let storageManager: ReturnType<typeof StorageManager.emulate>;
+  let runtime: Runtime;
+
+  beforeEach(() => {
+    storageManager = StorageManager.emulate({ as: signer });
+    runtime = new Runtime({
+      storageManager,
+      blobbyServerUrl: "http://localhost:8080",
+    });
+  });
+
+  afterEach(async () => {
+    await runtime?.dispose();
+    await storageManager?.close();
+  });
+
+  it("should rewrite root writes with value property", () => {
+    const transaction = runtime.edit();
+
+    // Write to empty path with object containing "value" property
+    const writeResult = transaction.write({
+      space,
+      id: "of:test-root",
+      type: "application/json",
+      path: [],
+    }, { value: { foo: "bar" } });
+
+    expect(writeResult.ok).toBeDefined();
+
+    // Should be able to read the value at path ["value"]
+    const readResult = transaction.readOrThrow({
+      space,
+      id: "of:test-root",
+      type: "application/json",
+      path: ["value"],
+    });
+
+    expect(readResult).toEqual({ foo: "bar" });
+  });
+
+  it("should not rewrite non-empty paths", () => {
+    const transaction = runtime.edit();
+
+    // First create a document
+    transaction.write({
+      space,
+      id: "of:test-nested",
+      type: "application/json",
+      path: ["value"],
+    }, {});
+
+    // Write to non-empty path with object containing "value" property
+    transaction.write({
+      space,
+      id: "of:test-nested",
+      type: "application/json",
+      path: ["value", "nested"],
+    }, { value: "should not be rewritten" });
+
+    // Should store the object as-is
+    const readResult = transaction.readOrThrow({
+      space,
+      id: "of:test-nested",
+      type: "application/json",
+      path: ["value", "nested"],
+    });
+
+    expect(readResult).toEqual({ value: "should not be rewritten" });
+  });
+
+  it("should not rewrite non-objects", () => {
+    const transaction = runtime.edit();
+
+    // Write non-object to empty path
+    const writeResult = transaction.write({
+      space,
+      id: "of:test-string",
+      type: "application/json",
+      path: [],
+    }, "plain string");
+
+    // Should get an error since path is empty and value is not rewritten
+    expect(writeResult.error).toBeDefined();
+    expect(writeResult.error?.name).toBe("NotFoundError");
+  });
+});
+
 describe("data: URI behaviors", () => {
   let runtime: Runtime;
   let storageManager: ReturnType<typeof StorageManager.emulate>;