cojson 0.18.0 → 0.18.2

package/src/tests/branching.test.ts

@@ -0,0 +1,425 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import {
+  createTestNode,
+  setupTestNode,
+  loadCoValueOrFail,
+} from "./testUtils.js";
+import { expectMap } from "../coValue.js";
+
+let jazzCloud: ReturnType<typeof setupTestNode>;
+
+beforeEach(async () => {
+  jazzCloud = setupTestNode({ isSyncServer: true });
+});
+
+describe("Branching Logic", () => {
+  describe("Branch Operations with Transactions", () => {
+    test("should maintain separate transaction histories between original and branch", async () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add initial transactions to original map
+      originalMap.set("originalKey1", "value1", "trusting");
+      originalMap.set("originalKey2", "value2", "trusting");
+
+      const branch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      // Add new transactions to branch
+      branch.set("branchKey1", "branchValue1", "trusting");
+      branch.set("branchKey2", "branchValue2", "trusting");
+
+      // Verify original map doesn't have branch transactions
+      expect(originalMap.get("branchKey1")).toBe(undefined);
+      expect(originalMap.get("branchKey2")).toBe(undefined);
+
+      // Verify branch has both original and new transactions
+      expect(branch.get("branchKey2")).toBe("branchValue2");
+      expect(branch.get("branchKey1")).toBe("branchValue1");
+      expect(branch.get("originalKey1")).toBe("value1");
+      expect(branch.get("originalKey2")).toBe("value2");
+    });
+  });
+
+  describe("Branch Merging", () => {
+    test("should merge branch transactions back to source map", () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add initial transactions to original map
+      originalMap.set("key1", "value1", "trusting");
+      originalMap.set("key2", "value2", "trusting");
+
+      // Create branch from original map
+      const branch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      // Add new transaction to branch
+      branch.set("key1", "branchValue1", "trusting");
+
+      // Merge branch back to source
+      const result = expectMap(branch.core.mergeBranch().getCurrentContent());
+
+      // Verify source now contains branch transactions
+      expect(result.get("key1")).toBe("branchValue1");
+      expect(result.get("key2")).toBe("value2");
+    });
+
+    test("should not create duplicate merge commits when merging already merged branch", () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add initial transactions to original map
+      originalMap.set("key1", "value1", "trusting");
+      originalMap.set("key2", "value2", "trusting");
+
+      // Create branch from original map
+      const branch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      // Add new transaction to branch
+      branch.set("key1", "branchValue1", "trusting");
+
+      // Merge branch twice - second merge should not create new commit
+      expectMap(branch.core.mergeBranch().getCurrentContent());
+      const result = expectMap(branch.core.mergeBranch().getCurrentContent());
+
+      // Verify only one merge commit was created
+      expect(result.core.mergeCommits.length).toBe(1);
+
+      // Verify source contains branch transactions
+      expect(result.get("key1")).toBe("branchValue1");
+      expect(result.get("key2")).toBe("value2");
+    });
+
+    test("should not create merge commit when merging empty branch", () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add initial transactions to original map
+      originalMap.set("key1", "value1", "trusting");
+      originalMap.set("key2", "value2", "trusting");
+
+      // Create branch from original map (no changes made)
+      const branch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      // Merge empty branch
+      const result = expectMap(branch.core.mergeBranch().getCurrentContent());
+
+      // Verify no merge commit was created
+      expect(result.core.mergeCommits.length).toBe(0);
+    });
+
+    test("should merge only new changes from branch after previous merge", () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add initial transactions to original map
+      originalMap.set("key1", "value1", "trusting");
+      originalMap.set("key2", "value2", "trusting");
+
+      const branch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      // Add first change to branch
+      branch.set("key1", "branchValue1", "trusting");
+
+      // Merge first change
+      branch.core.mergeBranch();
+
+      // Verify first change was merged
+      expect(originalMap.get("key1")).toBe("branchValue1");
+      expect(originalMap.get("key2")).toBe("value2");
+
+      // Add second change to branch
+      branch.set("key2", "branchValue2", "trusting");
+
+      // Merge second change
+      branch.core.mergeBranch();
+
+      // Verify two merge commits exist
+      expect(originalMap.core.mergeCommits.length).toBe(2);
+
+      // Verify both changes are now in original map
+      expect(originalMap.get("key1")).toBe("branchValue1");
+      expect(originalMap.get("key2")).toBe("branchValue2");
+    });
+  });
+
+  describe("Branch Loading and Checkout", () => {
+    test("should create new branch when checking out non-existent branch", async () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = jazzCloud.node.createGroup();
+      group.addMember("everyone", "writer");
+
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add initial data to original map
+      originalMap.set("key1", "value1");
+      originalMap.set("key2", "value2");
+
+      // Checkout non-existent branch - should create new one
+      const branch = await client.node.checkoutBranch(
+        originalMap.id,
+        branchName,
+      );
+
+      expect(branch).not.toBe("unavailable");
+
+      if (branch !== "unavailable") {
+        // Verify branch inherits original data
+        expect(branch.get("key1")).toBe("value1");
+        expect(branch.get("key2")).toBe("value2");
+
+        // Add new data to branch
+        branch.set("branchKey", "branchValue");
+
+        await branch.core.waitForSync();
+
+        // Verify original map doesn't have branch data
+        expect(originalMap.get("branchKey")).toBe(undefined);
+        expect(branch.get("branchKey")).toBe("branchValue");
+      }
+    });
+
+    test("should load existing branch when checking out created branch", async () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = jazzCloud.node.createGroup();
+      group.addMember("everyone", "writer");
+
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add initial data to original map
+      originalMap.set("key1", "value1");
+      originalMap.set("key2", "value2");
+
+      // Create branch with some data
+      const originalBranch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      originalBranch.set("branchKey", "branchValue");
+
+      // Checkout existing branch - should return created branch
+      const branch = await client.node.checkoutBranch(
+        originalMap.id,
+        branchName,
+      );
+
+      expect(branch).not.toBe("unavailable");
+
+      if (branch !== "unavailable") {
+        // Verify branch contains both original and new data
+        expect(branch.get("key1")).toBe("value1");
+        expect(branch.get("key2")).toBe("value2");
+        expect(branch.get("branchKey")).toBe("branchValue");
+      }
+    });
+
+    test("should successfully load existing branch via node.load", async () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = jazzCloud.node.createGroup();
+      group.addMember("everyone", "writer");
+
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add initial data to original map
+      originalMap.set("key1", "value1");
+      originalMap.set("key2", "value2");
+
+      // Create branch with some data
+      const originalBranch = expectMap(
+        originalMap.core.createBranch(branchName, group.id).getCurrentContent(),
+      );
+
+      originalBranch.set("branchKey", "branchValue");
+
+      // Load existing branch via node.load
+      const branch = await client.node.load(originalBranch.id);
+
+      expect(branch).not.toBe("unavailable");
+
+      if (branch !== "unavailable") {
+        // Verify branch contains all expected data
+        expect(branch.get("key1")).toBe("value1");
+        expect(branch.get("key2")).toBe("value2");
+        expect(branch.get("branchKey")).toBe("branchValue");
+      }
+    });
+
+    test("should create branch with different group owner when specified", async () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = jazzCloud.node.createGroup();
+      group.addMember("everyone", "writer");
+
+      const originalMap = group.createMap();
+      const branchName = "feature-branch";
+
+      // Add initial data to original map
+      originalMap.set("key1", "value1");
+      originalMap.set("key2", "value2");
+
+      // Create different group to own the branch
+      const branchGroup = client.node.createGroup();
+
+      // Checkout branch with different group as owner
+      const branch = await client.node.checkoutBranch(
+        originalMap.id,
+        branchName,
+        branchGroup.id,
+      );
+
+      expect(branch).not.toBe("unavailable");
+
+      if (branch !== "unavailable") {
+        // Verify branch inherits original data
+        expect(branch.get("key1")).toBe("value1");
+        expect(branch.get("key2")).toBe("value2");
+
+        // Add new data to branch
+        branch.set("branchKey", "branchValue");
+
+        await branch.core.waitForSync();
+
+        // Verify original map doesn't have branch data
+        expect(originalMap.get("branchKey")).toBe(undefined);
+        expect(branch.get("branchKey")).toBe("branchValue");
+      }
+
+      // Verify that the sync server can't read the branch content
+      const branchOnTheServer = await jazzCloud.node.checkoutBranch(
+        originalMap.id,
+        branchName,
+        branchGroup.id,
+      );
+
+      expect(branchOnTheServer).not.toBe("unavailable");
+
+      if (branchOnTheServer !== "unavailable") {
+        expect(branchOnTheServer.get("branchKey")).toBe(undefined);
+        expect(branchOnTheServer.get("key1")).toBe(undefined);
+        expect(branchOnTheServer.get("key2")).toBe(undefined);
+      }
+    });
+
+    test("should return unavailable when trying to checkout branch from group", async () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = jazzCloud.node.createGroup();
+      group.addMember("everyone", "writer");
+
+      // Try to checkout branch from group (groups don't support branching)
+      const branch = await client.node.checkoutBranch(
+        group.id,
+        "feature-branch",
+      );
+
+      // Should return unavailable since groups don't support branching
+      expect(branch).toBe("unavailable");
+    });
+
+    test("should return unavailable when source value is unreachable", async () => {
+      // Create client without sync server connection
+      const client = setupTestNode();
+
+      const group = jazzCloud.node.createGroup();
+      group.addMember("everyone", "writer");
+
+      // Create map on sync server (unreachable from client)
+      const originalMap = group.createMap();
+      originalMap.set("key1", "value1");
+
+      // Try to checkout branch on unreachable map
+      const branch = await client.node.checkoutBranch(
+        originalMap.id,
+        "feature-branch",
+      );
+
+      // Should return unavailable since checkout failed
+      expect(branch).toBe("unavailable");
+    });
+  });
+
+  describe("Branch Conflict Resolution", () => {
+    test("should successfully handle concurrent branch creation on different nodes", async () => {
+      const bob = setupTestNode();
+      const { peer: bobPeer } = bob.connectToSyncServer();
+      const alice = setupTestNode({
+        connected: true,
+      });
+
+      const client = setupTestNode();
+      const group = jazzCloud.node.createGroup();
+      group.addMember("everyone", "writer");
+
+      // Create map without any branches
+      const originalMap = group.createMap();
+
+      const originalMapOnBob = await loadCoValueOrFail(
+        bob.node,
+        originalMap.id,
+      );
+
+      // Disconnect bob from sync server to create isolation
+      bobPeer.outgoing.close();
+
+      // Create branches on different nodes
+      const aliceBranch = await alice.node.checkoutBranch(
+        originalMap.id,
+        "feature-branch",
+      );
+      const bobBranch = expectMap(
+        originalMapOnBob.core
+          .createBranch("feature-branch", group.id)
+          .getCurrentContent(),
+      );
+
+      if (aliceBranch === "unavailable") {
+        throw new Error("Alice branch is unavailable");
+      }
+
+      // Add different data to each branch
+      bobBranch.set("bob", true);
+      aliceBranch.set("alice", true);
+
+      // Reconnect bob to sync server
+      bob.connectToSyncServer();
+
+      // Wait for sync to complete
+      await bobBranch.core.waitForSync();
+      await aliceBranch.core.waitForSync();
+
+      // Verify both branches now contain data from the other
+      expect(bobBranch.get("alice")).toBe(true);
+      expect(aliceBranch.get("bob")).toBe(true);
+    });
+  });
+});

package/src/tests/coValueCore.test.ts

@@ -277,9 +277,8 @@ test("creates a transaction with trusting meta information", async () => {
     meta: true,
   });
 
-  const validTransactions = determineValidTransactions(map.core);
-
-  expect(validTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+  expect(map.core.verifiedTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+  expect(map.core.verifiedTransactions[0]?.meta).toEqual({ meta: true });
 });
 
 test("creates a transaction with private meta information", async () => {