cojson 0.18.36 → 0.18.38

package/src/tests/coValueCore.isStreaming.test.ts

@@ -2,6 +2,7 @@ import { assert, beforeEach, describe, expect, test } from "vitest";
 import {
   SyncMessagesLog,
   TEST_NODE_CONFIG,
+  fillCoMapWithLargeData,
   loadCoValueOrFail,
   setupTestAccount,
   setupTestNode,
@@ -49,19 +50,7 @@ describe("isStreaming", () => {
     await group.core.waitForSync();
     client.disconnect();
 
-    const map = group.createMap();
-
-    // Generate a large amount of data that requires multiple chunks
-    const dataSize = 1 * 1024 * 100;
-    const chunkSize = 1024; // 1KB chunks
-    const chunks = dataSize / chunkSize;
-
-    const value = Buffer.alloc(chunkSize, `value$`).toString("base64");
-
-    for (let i = 0; i < chunks; i++) {
-      const key = `key${i}`;
-      map.set(key, value, "trusting");
-    }
+    const map = fillCoMapWithLargeData(group.createMap());
 
     const newSession = client.spawnNewSession();
 
@@ -101,16 +90,7 @@ describe("isStreaming", () => {
     client.disconnect();
 
     // Generate a large amount of data that requires multiple chunks
-    const dataSize = 1 * 1024 * 100;
-    const chunkSize = 1024; // 1KB chunks
-    const chunks = dataSize / chunkSize;
-
-    const value = Buffer.alloc(chunkSize, `value$`).toString("base64");
-
-    for (let i = 0; i < chunks; i++) {
-      const key = `key${i}`;
-      map.set(key, value, "trusting");
-    }
+    fillCoMapWithLargeData(map);
 
     const newSession = client.spawnNewSession();
 
@@ -134,41 +114,81 @@ describe("isStreaming", () => {
     expect(mapInNewSession.core.isStreaming()).toBe(false);
   });
 
-  test("streaming a large value between two clients should be streaming until all chunks are sent", async () => {
-    const client = setupTestNode();
-    client.connectToSyncServer({
-      ourName: "initialClient",
-    });
-    const streamingClient = client.spawnNewSession();
-    streamingClient.connectToSyncServer({
-      ourName: "streamingClient",
-    });
+  // TODO: We can't handle client-to-client streaming until we
+  // handle the streaming state reset on disconnection
+  // Otherwise the other client might wait for a content that will never be sent
+  test.fails(
+    "streaming a large value between two clients should be streaming until all chunks are sent",
+    async () => {
+      const client = setupTestNode();
+      client.connectToSyncServer({
+        ourName: "initialClient",
+      });
+      const streamingClient = client.spawnNewSession();
+      streamingClient.connectToSyncServer({
+        ourName: "streamingClient",
+      });
+
+      const group = client.node.createGroup();
+
+      await group.core.waitForSync();
+      client.disconnect();
+
+      const map = fillCoMapWithLargeData(group.createMap());
+
+      const loadingClient = client.spawnNewSession();
+      loadingClient.connectToSyncServer({
+        ourName: "loadingClient",
+      });
+
+      await loadCoValueOrFail(loadingClient.node, group.id);
+
+      const content = map.core.verified.newContentSince(undefined);
+      assert(content);
+      const lastChunk = content.pop();
+      assert(lastChunk);
+
+      for (const chunk of content) {
+        streamingClient.node.syncManager.handleNewContent(chunk, "import");
+      }
+
+      await streamingClient.node.syncManager.waitForAllCoValuesSync();
+
+      const mapInLoadingClient = await loadCoValueOrFail(
+        loadingClient.node,
+        map.id,
+      );
 
-    const group = client.node.createGroup();
+      expect(mapInLoadingClient.core.isStreaming()).toBe(true);
 
-    await group.core.waitForSync();
-    client.disconnect();
+      streamingClient.node.syncManager.handleNewContent(lastChunk, "import");
 
-    const map = group.createMap();
+      await waitFor(() => {
+        expect(mapInLoadingClient.core.knownState()).toEqual(
+          map.core.knownState(),
+        );
+      });
 
-    // Generate a large amount of data that requires multiple chunks
-    const dataSize = 1 * 1024 * 100;
-    const chunkSize = 1024; // 1KB chunks
-    const chunks = dataSize / chunkSize;
+      expect(mapInLoadingClient.core.isStreaming()).toBe(false);
+    },
+  );
 
-    const value = Buffer.alloc(chunkSize, `value$`).toString("base64");
+  test("should be false when getting streaming content that is already in the known state", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
 
-    for (let i = 0; i < chunks; i++) {
-      const key = `key${i}`;
-      map.set(key, value, "trusting");
-    }
+    const group = client.node.createGroup();
 
-    const loadingClient = client.spawnNewSession();
-    loadingClient.connectToSyncServer({
-      ourName: "loadingClient",
-    });
+    await group.core.waitForSync();
+
+    const map = fillCoMapWithLargeData(group.createMap());
 
-    await loadCoValueOrFail(loadingClient.node, group.id);
+    await map.core.waitForSync();
+    const newSession = client.spawnNewSession();
+
+    const mapInNewSession1 = await loadCoValueOrFail(newSession.node, map.id);
+    await mapInNewSession1.core.waitForFullStreaming();
 
     const content = map.core.verified.newContentSince(undefined);
     assert(content);
@@ -176,57 +196,28 @@ describe("isStreaming", () => {
     assert(lastChunk);
 
     for (const chunk of content) {
-      streamingClient.node.syncManager.handleNewContent(chunk, "import");
+      newSession.node.syncManager.handleNewContent(chunk, "import");
     }
 
-    await streamingClient.node.syncManager.waitForAllCoValuesSync();
-
-    const mapInLoadingClient = await loadCoValueOrFail(
-      loadingClient.node,
-      map.id,
-    );
-
-    expect(mapInLoadingClient.core.isStreaming()).toBe(true);
-
-    streamingClient.node.syncManager.handleNewContent(lastChunk, "import");
-
-    await waitFor(() => {
-      expect(mapInLoadingClient.core.knownState()).toEqual(
-        map.core.knownState(),
-      );
-    });
+    const mapInNewSession = await loadCoValueOrFail(newSession.node, map.id);
 
-    expect(mapInLoadingClient.core.isStreaming()).toBe(false);
+    expect(mapInNewSession.core.isStreaming()).toBe(false);
   });
 
-  test("should be false when getting streaming content that is already in the known state", async () => {
-    const client = setupTestNode({
-      connected: true,
-    });
+  test("streaming state from clients should be ignored", async () => {
+    const client = setupTestNode();
 
     const group = client.node.createGroup();
 
     await group.core.waitForSync();
 
-    const map = group.createMap();
-
-    // Generate a large amount of data that requires multiple chunks
-    const dataSize = 1 * 1024 * 100;
-    const chunkSize = 1024; // 1KB chunks
-    const chunks = dataSize / chunkSize;
-
-    const value = Buffer.alloc(chunkSize, `value$`).toString("base64");
-
-    for (let i = 0; i < chunks; i++) {
-      const key = `key${i}`;
-      map.set(key, value, "trusting");
-    }
+    const map = fillCoMapWithLargeData(group.createMap());
 
     await map.core.waitForSync();
     const newSession = client.spawnNewSession();
-
-    const mapInNewSession1 = await loadCoValueOrFail(newSession.node, map.id);
-    await mapInNewSession1.core.waitForFullStreaming();
+    newSession.connectToSyncServer({
+      ourName: "streamingClient",
+    });
 
     const content = map.core.verified.newContentSince(undefined);
     assert(content);
@@ -237,9 +228,11 @@ describe("isStreaming", () => {
       newSession.node.syncManager.handleNewContent(chunk, "import");
     }
 
-    const mapInNewSession = await loadCoValueOrFail(newSession.node, map.id);
-
-    expect(mapInNewSession.core.isStreaming()).toBe(false);
+    const mapOnServer = jazzCloud.node.getCoValue(map.id);
+    expect(mapOnServer.isStreaming()).toBe(false);
+    expect(mapOnServer.knownState()).toEqual(
+      mapOnServer.knownStateWithStreaming(),
+    );
   });
 
   test("should be false when getting streaming content that's not really streaming", async () => {