jazz-tools 0.7.35-guest-auth.5 → 0.7.35-guest-auth.6

package/src/tests/coStream.test.ts

@@ -443,3 +443,56 @@ describe("BinaryCoStream loading & Subscription", async () => {
         });
     });
 });
+
+describe("BinaryCoStream.loadAsBlob", async () => {
+    async function setup() {
+        const me = await Account.create({
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
+        });
+
+        const stream = BinaryCoStream.create({ owner: me });
+
+        stream.start({ mimeType: "text/plain" });
+
+        return { stream, me };
+    }
+
+    test("resolves only when the stream is ended", async () => {
+        const { stream, me } = await setup();
+        stream.push(new Uint8Array([1]));
+
+        const promise = BinaryCoStream.loadAsBlob(stream.id, me);
+
+        await stream.ensureLoaded([]);
+
+        stream.push(new Uint8Array([2]));
+        stream.end();
+
+        const blob = await promise;
+
+        // The promise resolves only when the stream is ended
+        // so we get a blob with all the chunks
+        expect(blob?.size).toBe(2);
+    });
+
+    test("resolves with an unfinshed blob if allowUnfinished: true", async () => {
+        const { stream, me } = await setup();
+        stream.push(new Uint8Array([1]));
+
+        const promise = BinaryCoStream.loadAsBlob(stream.id, me, {
+            allowUnfinished: true,
+        });
+
+        await stream.ensureLoaded([]);
+
+        stream.push(new Uint8Array([2]));
+        stream.end();
+
+        const blob = await promise;
+
+        // The promise resolves before the stream is ended
+        // so we get a blob only with the first chunk
+        expect(blob?.size).toBe(1);
+    });
+});

package/src/tests/deepLoading.test.ts

@@ -60,6 +60,7 @@ describe("Deep loading with depth arg", async () => {
     });
 
     test("loading a deeply nested object will wait until all required refs are loaded", async () => {
+        const ownership = { owner: me };
         const map = TestMap.create(
             {
                 list: TestList.create(
@@ -70,19 +71,19 @@ describe("Deep loading with depth arg", async () => {
                                     [
                                         InnermostMap.create(
                                             { value: "hello" },
-                                            { owner: me },
+                                            ownership,
                                         ),
                                     ],
-                                    { owner: me },
+                                    ownership,
                                 ),
                             },
-                            { owner: me },
+                            ownership,
                         ),
                     ],
-                    { owner: me },
+                    ownership,
                 ),
             },
-            { owner: me },
+            ownership,
         );
 
         const map1 = await TestMap.load(map.id, meOnSecondPeer, {});
@@ -141,8 +142,7 @@ describe("Deep loading with depth arg", async () => {
             throw new Error("map4 is undefined");
         }
         expect(map4.list[0]?.stream).not.toBe(null);
-        // TODO: why is this actually defined?
-        // expect(map4.list[0]?.stream?.[me.id]).toBe(undefined)
+        expect(map4.list[0]?.stream?.[me.id]).not.toBe(null);
         expect(map4.list[0]?.stream?.byMe?.value).toBe(null);
 
         const map5 = await TestMap.load(map.id, meOnSecondPeer, {