Move more tests into node

Author: simolus3

packages/node/tests/sync.test.ts

@@ -492,6 +492,109 @@ function defineSyncTests(impl: SyncClientImplementation) {
     rows = (await query.next()).value.rows._array;
     expect(rows).toStrictEqual([{ name: 'from server' }]);
   });
+
+  mockSyncServiceTest('should update sync state incrementally', async ({ syncService }) => {
+    const powersync = await syncService.createDatabase();
+    powersync.connect(new TestConnector(), options);
+    await vi.waitFor(() => expect(syncService.connectedListeners).toHaveLength(1));
+
+    const buckets: BucketChecksum[] = [];
+    for (let prio = 0; prio <= 3; prio++) {
+      buckets.push({ bucket: `prio${prio}`, priority: prio, checksum: 10 + prio });
+    }
+    syncService.pushLine({
+      checkpoint: {
+        last_op_id: '4',
+        buckets
+      }
+    });
+
+    let operationId = 1;
+    const addRow = (prio: number) => {
+      syncService.pushLine({
+        data: {
+          bucket: `prio${prio}`,
+          data: [
+            {
+              checksum: prio + 10,
+              data: JSON.stringify({ name: 'row' }),
+              op: 'PUT',
+              op_id: (operationId++).toString(),
+              object_id: `prio${prio}`,
+              object_type: 'lists'
+            }
+          ]
+        }
+      });
+    };
+
+    const syncCompleted = vi.fn();
+    powersync.waitForFirstSync().then(syncCompleted);
+
+    // Emit partial sync complete for each priority but the last.
+    for (var prio = 0; prio < 3; prio++) {
+      const partialSyncCompleted = vi.fn();
+      powersync.waitForFirstSync({ priority: prio }).then(partialSyncCompleted);
+      expect(powersync.currentStatus.statusForPriority(prio).hasSynced).toBe(false);
+      expect(partialSyncCompleted).not.toHaveBeenCalled();
+      expect(syncCompleted).not.toHaveBeenCalled();
+
+      addRow(prio);
+      syncService.pushLine({
+        partial_checkpoint_complete: {
+          last_op_id: operationId.toString(),
+          priority: prio
+        }
+      });
+
+      await powersync.syncStreamImplementation!.waitUntilStatusMatches((status) => {
+        return status.statusForPriority(prio).hasSynced === true;
+      });
+      await new Promise((r) => setTimeout(r));
+      expect(partialSyncCompleted).toHaveBeenCalledOnce();
+
+      expect(await powersync.getAll('select * from lists')).toHaveLength(prio + 1);
+    }
+
+    // Then, complete the sync.
+    addRow(3);
+    syncService.pushLine({ checkpoint_complete: { last_op_id: operationId.toString() } });
+    await vi.waitFor(() => expect(syncCompleted).toHaveBeenCalledOnce(), 500);
+    expect(await powersync.getAll('select * from lists')).toHaveLength(4);
+  });
+
+  mockSyncServiceTest('Should remember sync state', async ({ syncService }) => {
+    const powersync = await syncService.createDatabase();
+    powersync.connect(new TestConnector(), options);
+    await vi.waitFor(() => expect(syncService.connectedListeners).toHaveLength(1));
+
+    const buckets: BucketChecksum[] = [];
+    for (let prio = 0; prio <= 3; prio++) {
+      buckets.push({ bucket: `prio${prio}`, priority: prio, checksum: 0 });
+    }
+    syncService.pushLine({
+      checkpoint: {
+        last_op_id: '0',
+        buckets
+      }
+    });
+    syncService.pushLine({
+      partial_checkpoint_complete: {
+        last_op_id: '0',
+        priority: 0
+      }
+    });
+
+    await powersync.waitForFirstSync({ priority: 0 });
+
+    // Open another database instance.
+    const another = await syncService.createDatabase();
+    await another.init();
+
+    expect(another.currentStatus.priorityStatusEntries).toHaveLength(1);
+    expect(another.currentStatus.statusForPriority(0).hasSynced).toBeTruthy();
+    await another.waitForFirstSync({ priority: 0 });
+  });
 }
 
 function bucket(name: string, count: number, options: { priority: number } = { priority: 3 }): BucketChecksum {

packages/web/tests/stream.test.ts

@@ -303,127 +303,5 @@ function describeStreamingTests(createConnectedDatabase: () => Promise<Connected
         }
       );
     });
-
-    it('Should upload after reconnecting', async () => {
-      const { powersync, connect, uploadSpy } = await createConnectedDatabase();
-      expect(powersync.connected).toBe(true);
-
-      await powersync.disconnect();
-
-      // Status should update after uploads are completed
-      await vi.waitFor(
-        () => {
-          // to-have-been-called seems to not work after failing a check
-          expect(powersync.currentStatus.dataFlowStatus.uploading).false;
-        },
-        {
-          timeout: UPLOAD_TIMEOUT_MS
-        }
-      );
-    });
-
-    it('Should update sync state incrementally', async () => {
-      const { powersync, remote } = await createConnectedDatabase();
-      expect(powersync.currentStatus.dataFlowStatus.downloading).toBe(false);
-
-      const buckets: BucketChecksum[] = [];
-      for (let prio = 0; prio <= 3; prio++) {
-        buckets.push({ bucket: `prio${prio}`, priority: prio, checksum: 10 + prio });
-      }
-      remote.enqueueLine({
-        checkpoint: {
-          last_op_id: '4',
-          buckets
-        }
-      });
-
-      let operationId = 1;
-      const addRow = (prio: number) => {
-        remote.enqueueLine({
-          data: {
-            bucket: `prio${prio}`,
-            data: [
-              {
-                checksum: prio + 10,
-                data: JSON.stringify({ name: 'row' }),
-                op: 'PUT',
-                op_id: (operationId++).toString(),
-                object_id: `prio${prio}`,
-                object_type: 'users'
-              }
-            ]
-          }
-        });
-      };
-
-      const syncCompleted = vi.fn();
-      powersync.waitForFirstSync().then(syncCompleted);
-
-      // Emit partial sync complete for each priority but the last.
-      for (var prio = 0; prio < 3; prio++) {
-        const partialSyncCompleted = vi.fn();
-        powersync.waitForFirstSync({ priority: prio }).then(partialSyncCompleted);
-        expect(powersync.currentStatus.statusForPriority(prio).hasSynced).toBe(false);
-        expect(partialSyncCompleted).not.toHaveBeenCalled();
-        expect(syncCompleted).not.toHaveBeenCalled();
-
-        addRow(prio);
-        remote.enqueueLine({
-          partial_checkpoint_complete: {
-            last_op_id: operationId.toString(),
-            priority: prio
-          }
-        });
-
-        await powersync.syncStreamImplementation!.waitUntilStatusMatches((status) => {
-          return status.statusForPriority(prio).hasSynced === true;
-        });
-        await new Promise((r) => setTimeout(r));
-        expect(partialSyncCompleted).toHaveBeenCalledOnce();
-
-        expect(await powersync.getAll('select * from users')).toHaveLength(prio + 1);
-      }
-
-      // Then, complete the sync.
-      addRow(3);
-      remote.enqueueLine({ checkpoint_complete: { last_op_id: operationId.toString() } });
-      await vi.waitFor(() => expect(syncCompleted).toHaveBeenCalledOnce(), 500);
-      expect(await powersync.getAll('select * from users')).toHaveLength(4);
-    });
-
-    it('Should remember sync state', async () => {
-      const { powersync, remote, openAnother } = await createConnectedDatabase();
-      expect(powersync.currentStatus.dataFlowStatus.downloading).toBe(false);
-
-      const buckets: BucketChecksum[] = [];
-      for (let prio = 0; prio <= 3; prio++) {
-        buckets.push({ bucket: `prio${prio}`, priority: prio, checksum: 0 });
-      }
-      remote.enqueueLine({
-        checkpoint: {
-          last_op_id: '0',
-          buckets
-        }
-      });
-      remote.enqueueLine({
-        partial_checkpoint_complete: {
-          last_op_id: '0',
-          priority: 0
-        }
-      });
-
-      await powersync.waitForFirstSync({ priority: 0 });
-
-      // Open another database instance.
-      const another = openAnother();
-      onTestFinished(async () => {
-        await another.close();
-      });
-      await another.init();
-
-      expect(another.currentStatus.priorityStatusEntries).toHaveLength(1);
-      expect(another.currentStatus.statusForPriority(0).hasSynced).toBeTruthy();
-      await another.waitForFirstSync({ priority: 0 });
-    });
   };
 }