cojson 0.9.9 → 0.9.11

package/src/tests/coValueCore.test.ts

@@ -1,11 +1,14 @@
 import { expect, test, vi } from "vitest";
-import { Transaction } from "../coValueCore.js";
+import { CoValueCore, Transaction } from "../coValueCore.js";
 import { MapOpPayload } from "../coValues/coMap.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { stableStringify } from "../jsonStringify.js";
 import { LocalNode } from "../localNode.js";
 import { Role } from "../permissions.js";
-import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import {
+  createTestNode,
+  randomAnonymousAccountAndSessionID,
+} from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -191,3 +194,30 @@ test("New transactions in a group correctly update owned values, including subsc
 
   expect(map.core.getValidSortedTransactions().length).toBe(0);
 });
+
+test("creating a coValue with a group should't trigger automatically a content creation (performance)", () => {
+  const node = createTestNode();
+
+  const group = node.createGroup();
+
+  const getCurrentContentSpy = vi.spyOn(
+    CoValueCore.prototype,
+    "getCurrentContent",
+  );
+  const groupSpy = vi.spyOn(group.core, "getCurrentContent");
+
+  getCurrentContentSpy.mockClear();
+
+  node.createCoValue({
+    type: "comap",
+    ruleset: { type: "ownedByGroup", group: group.id },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  // It's called once for the group and never for the coValue
+  expect(getCurrentContentSpy).toHaveBeenCalledTimes(1);
+  expect(groupSpy).toHaveBeenCalledTimes(1);
+
+  getCurrentContentSpy.mockRestore();
+});

package/src/tests/logger.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test, vi } from "vitest";
+import { LogLevel, Logger } from "../logger";
+
+describe("Logger", () => {
+  describe("Log Level Filtering", () => {
+    test("should respect log level hierarchy", () => {
+      const mockLogSystem = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const logger = new Logger(LogLevel.WARN, mockLogSystem);
+
+      logger.debug("Debug message");
+      logger.info("Info message");
+      logger.warn("Warning message");
+      logger.error("Error message");
+
+      expect(mockLogSystem.debug).not.toHaveBeenCalled();
+      expect(mockLogSystem.info).not.toHaveBeenCalled();
+      expect(mockLogSystem.warn).toHaveBeenCalledWith("Warning message");
+      expect(mockLogSystem.error).toHaveBeenCalledWith("Error message");
+    });
+
+    test("should pass additional arguments to log system", () => {
+      const mockLogSystem = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const logger = new Logger(LogLevel.DEBUG, mockLogSystem);
+      const additionalArgs = [{ foo: "bar" }, 42, "extra"];
+
+      logger.debug("Debug message", ...additionalArgs);
+
+      expect(mockLogSystem.debug).toHaveBeenCalledWith(
+        "Debug message",
+        ...additionalArgs,
+      );
+    });
+  });
+
+  describe("Log System Configuration", () => {
+    test("should allow changing log level at runtime", () => {
+      const mockLogSystem = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const logger = new Logger(LogLevel.ERROR, mockLogSystem);
+
+      logger.warn("Warning 1"); // Should not log
+      expect(mockLogSystem.warn).not.toHaveBeenCalled();
+
+      logger.setLevel(LogLevel.WARN);
+      logger.warn("Warning 2"); // Should log
+      expect(mockLogSystem.warn).toHaveBeenCalledWith("Warning 2");
+    });
+
+    test("should allow changing log system at runtime", () => {
+      const mockLogSystem1 = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const mockLogSystem2 = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const logger = new Logger(LogLevel.INFO, mockLogSystem1);
+
+      logger.info("Message 1");
+      expect(mockLogSystem1.info).toHaveBeenCalledWith("Message 1");
+      expect(mockLogSystem2.info).not.toHaveBeenCalled();
+
+      logger.setLogSystem(mockLogSystem2);
+      logger.info("Message 2");
+      expect(mockLogSystem2.info).toHaveBeenCalledWith("Message 2");
+      expect(mockLogSystem1.info).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("Default Console Log System", () => {
+    test("should use console methods by default", () => {
+      const consoleSpy = {
+        debug: vi.spyOn(console, "debug").mockImplementation(() => {}),
+        info: vi.spyOn(console, "info").mockImplementation(() => {}),
+        warn: vi.spyOn(console, "warn").mockImplementation(() => {}),
+        error: vi.spyOn(console, "error").mockImplementation(() => {}),
+      };
+
+      const logger = new Logger();
+      logger.setLevel(LogLevel.DEBUG);
+      const testMessage = "Test message";
+      const testArgs = [{ data: "test" }, 123];
+
+      logger.debug(testMessage, ...testArgs);
+      logger.info(testMessage, ...testArgs);
+      logger.warn(testMessage, ...testArgs);
+      logger.error(testMessage, ...testArgs);
+
+      expect(consoleSpy.debug).toHaveBeenCalledWith(testMessage, ...testArgs);
+      expect(consoleSpy.info).toHaveBeenCalledWith(testMessage, ...testArgs);
+      expect(consoleSpy.warn).toHaveBeenCalledWith(testMessage, ...testArgs);
+      expect(consoleSpy.error).toHaveBeenCalledWith(testMessage, ...testArgs);
+
+      // Cleanup
+      Object.values(consoleSpy).forEach((spy) => spy.mockRestore());
+    });
+  });
+
+  describe("Log Level NONE", () => {
+    test("should not log anything when level is NONE", () => {
+      const mockLogSystem = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const logger = new Logger(LogLevel.NONE, mockLogSystem);
+
+      logger.debug("Debug message");
+      logger.info("Info message");
+      logger.warn("Warning message");
+      logger.error("Error message");
+
+      expect(mockLogSystem.debug).not.toHaveBeenCalled();
+      expect(mockLogSystem.info).not.toHaveBeenCalled();
+      expect(mockLogSystem.warn).not.toHaveBeenCalled();
+      expect(mockLogSystem.error).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/tests/sync.test.ts

@@ -12,8 +12,10 @@ import { connectedPeers, newQueuePair } from "../streamUtils.js";
 import type { SyncMessage } from "../sync.js";
 import {
   blockMessageTypeOnOutgoingPeer,
+  connectTwoPeers,
   createTestMetricReader,
   createTestNode,
+  loadCoValueOrFail,
   randomAnonymousAccountAndSessionID,
   tearDownTestMetricReader,
   waitFor,
@@ -1645,6 +1647,28 @@ function createTwoConnectedNodes() {
   };
 }
 
+test("a value created on one node can be loaded on anotehr node even if not directly connected", async () => {
+  const userA = createTestNode();
+  const userB = createTestNode();
+  const serverA = createTestNode();
+  const serverB = createTestNode();
+  const core = createTestNode();
+
+  connectTwoPeers(userA, serverA, "client", "server");
+  connectTwoPeers(userB, serverB, "client", "server");
+  connectTwoPeers(serverA, core, "client", "server");
+  connectTwoPeers(serverB, core, "client", "server");
+
+  const group = userA.createGroup();
+  const map = group.createMap();
+  map.set("key1", "value1", "trusting");
+
+  await map.core.waitForSync();
+
+  const mapOnUserB = await loadCoValueOrFail(userB, map.id);
+  expect(mapOnUserB.get("key1")).toBe("value1");
+});
+
 describe("SyncManager - knownStates vs optimisticKnownStates", () => {
   test("knownStates and optimisticKnownStates are the same when the coValue is fully synced", async () => {
     const { client, jazzCloud } = createTwoConnectedNodes();
@@ -1961,6 +1985,25 @@ describe("waitForSyncWithPeer", () => {
   });
 });
 
+test("Should not crash when syncing an unknown coValue type", async () => {
+  const { client, jazzCloud } = createTwoConnectedNodes();
+
+  const coValue = client.createCoValue({
+    type: "ooops" as any,
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  await coValue.waitForSync();
+
+  const coValueOnTheOtherNode = await loadCoValueOrFail(
+    jazzCloud,
+    coValue.getCurrentContent().id,
+  );
+  expect(coValueOnTheOtherNode.id).toBe(coValue.id);
+});
+
 describe("metrics", () => {
   afterEach(() => {
     tearDownTestMetricReader();

package/src/tests/testUtils.ts

@@ -33,6 +33,25 @@ export function createTestNode() {
   return new LocalNode(admin, session, Crypto);
 }
 
+export function connectTwoPeers(
+  a: LocalNode,
+  b: LocalNode,
+  aRole: "client" | "server",
+  bRole: "client" | "server",
+) {
+  const [aAsPeer, bAsPeer] = connectedPeers(
+    "peer:" + a.account.id,
+    "peer:" + b.account.id,
+    {
+      peer1role: aRole,
+      peer2role: bRole,
+    },
+  );
+
+  a.syncManager.addPeer(bAsPeer);
+  b.syncManager.addPeer(aAsPeer);
+}
+
 export async function createTwoConnectedNodes(
   node1Role: Peer["role"],
   node2Role: Peer["role"],