add cleanup between tests

samwillis · samwillis · commit 173e3125def2 · 2025-11-08T20:20:05.000Z
diff --git a/packages/db-collection-e2e/src/index.ts b/packages/db-collection-e2e/src/index.ts
@@ -26,3 +26,4 @@ export { createCollationTestSuite } from "./suites/collation.suite"
 export { createMutationsTestSuite } from "./suites/mutations.suite"
 export { createLiveUpdatesTestSuite } from "./suites/live-updates.suite"
 export { createRegressionTestSuite } from "./suites/regressions.suite"
+export { createAccumulatedDataTestSuite } from "./suites/accumulated-data.suite"
diff --git a/packages/db-collection-e2e/src/suites/accumulated-data.suite.ts b/packages/db-collection-e2e/src/suites/accumulated-data.suite.ts
@@ -0,0 +1,95 @@
+/**
+ * Accumulated Data Test Suite
+ *
+ * Tests that require data to accumulate across test runs.
+ * These tests should be run in a separate describe block WITHOUT cleanup between tests.
+ */
+
+import { describe, expect, it } from "vitest"
+import { createLiveQueryCollection, isNull } from "@tanstack/db"
+import { waitForQueryData } from "../utils/helpers"
+import type { E2ETestConfig } from "../types"
+
+export function createAccumulatedDataTestSuite(
+  getConfig: () => Promise<E2ETestConfig>
+) {
+  describe(`Accumulated Data Suite (No Cleanup Between Tests)`, () => {
+    describe(`Delete Mutations`, () => {
+      it(`should handle delete removing record from query`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        // Load data first with true = true workaround
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection })
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        // Test structure: Delete a record, verify it's removed
+        expect(query.size).toBeGreaterThan(0)
+      })
+    })
+
+    describe(`Soft Delete Pattern`, () => {
+      it(`should filter out soft-deleted records`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q
+            .from({ user: usersCollection })
+            .where(({ user }) => isNull(user.deletedAt))
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        // All results should not be soft-deleted
+        const results = Array.from(query.state.values())
+        expect(results.length).toBeGreaterThan(0)
+        results.forEach((u) => {
+          expect(u.deletedAt).toBeNull()
+        })
+      })
+
+      it(`should include soft-deleted records when not filtered`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection })
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        // Should include both deleted and non-deleted
+        const results = Array.from(query.state.values())
+        const hasNotDeleted = results.some((u) => u.deletedAt === null)
+
+        expect(hasNotDeleted).toBe(true)
+        // May or may not have deleted records depending on seed data
+      })
+    })
+
+    describe(`Live Updates with Accumulated Data`, () => {
+      it(`should update existing records in query results`, async () => {
+        const config = await getConfig()
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection })
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        // Test structure: Update a record in database
+        // Query should receive update reactively
+        expect(query.size).toBeGreaterThan(0)
+      })
+    })
+  })
+}
diff --git a/packages/db-collection-e2e/src/suites/live-updates.suite.ts b/packages/db-collection-e2e/src/suites/live-updates.suite.ts
@@ -63,21 +63,6 @@ export function createLiveUpdatesTestSuite(
         // Should be removed from query results
         expect(query.size).toBeGreaterThanOrEqual(0)
       })
-
-      it(`should update existing records in query results`, async () => {
-        const config = await getConfig()
-        const usersCollection = config.collections.onDemand.users
-
-        const query = createLiveQueryCollection((q) =>
-          q.from({ user: usersCollection })
-        )
-
-        await query.preload()
-
-        // Test structure: Update a record in database
-        // Query should receive update reactively
-        expect(query.size).toBeGreaterThan(0)
-      })
     })
 
     describe(`Subscription Lifecycle`, () => {
diff --git a/packages/db-collection-e2e/src/suites/mutations.suite.ts b/packages/db-collection-e2e/src/suites/mutations.suite.ts
@@ -5,7 +5,7 @@
  */
 
 import { describe, expect, it } from "vitest"
-import { createLiveQueryCollection, eq, gt, isNull } from "@tanstack/db"
+import { createLiveQueryCollection, eq, gt } from "@tanstack/db"
 import type { E2ETestConfig } from "../types"
 
 export function createMutationsTestSuite(
@@ -84,61 +84,6 @@ export function createMutationsTestSuite(
       })
     })
 
-    describe(`Delete Mutations`, () => {
-      it(`should handle delete removing record from query`, async () => {
-        const config = await getConfig()
-        const usersCollection = config.collections.onDemand.users
-
-        const query = createLiveQueryCollection((q) =>
-          q.from({ user: usersCollection })
-        )
-
-        await query.preload()
-
-        // Test structure: Delete a record, verify it's removed
-        expect(query.size).toBeGreaterThan(0)
-      })
-    })
-
-    describe(`Soft Delete Pattern`, () => {
-      it(`should filter out soft-deleted records`, async () => {
-        const config = await getConfig()
-        const usersCollection = config.collections.onDemand.users
-
-        const query = createLiveQueryCollection((q) =>
-          q
-            .from({ user: usersCollection })
-            .where(({ user }) => isNull(user.deletedAt))
-        )
-
-        await query.preload()
-
-        const results = Array.from(query.state.values())
-        expect(results.length).toBeGreaterThan(0)
-        results.forEach((u) => {
-          expect(u.deletedAt).toBeNull()
-        })
-      })
-
-      it(`should include soft-deleted records when not filtered`, async () => {
-        const config = await getConfig()
-        const usersCollection = config.collections.onDemand.users
-
-        const query = createLiveQueryCollection((q) =>
-          q.from({ user: usersCollection })
-        )
-
-        await query.preload()
-
-        // Should include both deleted and non-deleted
-        const results = Array.from(query.state.values())
-        const hasNotDeleted = results.some((u) => u.deletedAt === null)
-
-        expect(hasNotDeleted).toBe(true)
-        // May or may not have deleted records depending on seed data
-      })
-    })
-
     describe(`Mutation with Queries`, () => {
       it(`should maintain query state during data changes`, async () => {
         const config = await getConfig()
diff --git a/packages/db-collection-e2e/src/suites/predicates.suite.ts b/packages/db-collection-e2e/src/suites/predicates.suite.ts
@@ -30,9 +30,7 @@ export function createPredicatesTestSuite(
     describe(`Equality Operators`, () => {
       it(`should filter with eq() on string field`, async () => {
         const config = await getConfig()
-        // Use fresh collection for each test to validate loading + cleanup
-        const fresh = await config.createFreshCollections!()
-        const usersCollection = fresh.users
+        const usersCollection = config.collections.onDemand.users
 
         const query = createLiveQueryCollection((q) =>
           q
@@ -495,11 +493,10 @@ export function createPredicatesTestSuite(
     })
 
     describe(`Edge Cases`, () => {
-      it(`should handle query with no where clause on on-demand collection - Electric Bug`, async () => {
-        // KNOWN BUG: Electric doesn't load data when requestSnapshot({}) is called with no parameters
-        // When loadSubset({}) is called (no where, no limit), Electric should load all data
-        // but currently returns nothing. This test will FAIL until Electric fixes this.
-        // Documented in NO_WHERE_CLAUSE_BUG.md
+      it(`should handle query with no where clause on on-demand collection`, async () => {
+        // NOTE: Electric has a bug where empty subset requests don't load data
+        // We work around this by injecting "true = true" when there's no where clause
+        // This is always true so doesn't filter data, just tricks Electric into loading
 
         const config = await getConfig()
         const usersCollection = config.collections.onDemand.users
diff --git a/packages/db-collection-e2e/src/suites/regressions.suite.ts b/packages/db-collection-e2e/src/suites/regressions.suite.ts
@@ -92,9 +92,15 @@ export function createRegressionTestSuite(
         const config = await getConfig()
         const usersCollection = config.collections.onDemand.users
 
-        // Direct loadSubset call
+        // Direct loadSubset call with orderBy (required by DB when using limit)
         const result = await usersCollection._sync.loadSubset({
           limit: 10,
+          orderBy: [
+            {
+              expression: { type: `ref`, path: [`id`] } as any,
+              compareOptions: { direction: `asc`, nulls: `first` },
+            },
+          ],
         })
 
         // Should return Promise or true
diff --git a/packages/db-collection-e2e/src/types.ts b/packages/db-collection-e2e/src/types.ts
@@ -62,15 +62,6 @@ export interface E2ETestConfig {
     }
   }
 
-  // Factory functions to create fresh collections for tests that need isolation
-  createFreshCollections?: () => Promise<{
-    onDemand: {
-      users: Collection<User>
-      posts: Collection<Post>
-      comments: Collection<Comment>
-    }
-  }>
-
   // Lifecycle hooks
   setup: () => Promise<void>
   teardown: () => Promise<void>
diff --git a/packages/electric-db-collection/e2e/electric.e2e.test.ts b/packages/electric-db-collection/e2e/electric.e2e.test.ts
@@ -9,6 +9,7 @@ import { createCollection } from "@tanstack/db"
 import { electricCollectionOptions } from "../src/electric"
 import { makePgClient } from "../../db-collection-e2e/support/global-setup"
 import {
+  createAccumulatedDataTestSuite,
   createCollationTestSuite,
   createDeduplicationTestSuite,
   createJoinsTestSuite,
@@ -314,3 +315,96 @@ describe(`Electric Collection E2E Tests`, () => {
   createLiveUpdatesTestSuite(getConfig)
   createRegressionTestSuite(getConfig)
 })
+
+// Separate describe block for tests that expect accumulated data
+// These tests do NOT cleanup between tests to preserve data accumulation
+describe(`Electric Collection E2E Tests - Accumulated Data`, () => {
+  let config: E2ETestConfig
+  let dbClient: Client
+  let usersTable: string
+
+  beforeAll(async () => {
+    const baseUrl = inject(`baseUrl`)
+    const testSchema = inject(`testSchema`)
+    const seedData = generateSeedData()
+
+    const testId = Date.now().toString(16)
+    usersTable = `"users_accum_${testId}"`
+
+    dbClient = makePgClient({ options: `-csearch_path=${testSchema}` })
+    await dbClient.connect()
+    await dbClient.query(`SET search_path TO ${testSchema}`)
+
+    // Create and populate tables
+    await dbClient.query(`CREATE TABLE ${usersTable} (
+      id UUID PRIMARY KEY, name TEXT NOT NULL, email TEXT, age INTEGER NOT NULL,
+      "isActive" BOOLEAN NOT NULL DEFAULT true, "createdAt" TIMESTAMP NOT NULL DEFAULT NOW(),
+      metadata JSONB, "deletedAt" TIMESTAMP
+    )`)
+
+    for (const user of seedData.users) {
+      await dbClient.query(
+        `INSERT INTO ${usersTable} (id, name, email, age, "isActive", "createdAt", metadata, "deletedAt")
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+        [
+          user.id,
+          user.name,
+          user.email,
+          user.age,
+          user.isActive,
+          user.createdAt,
+          user.metadata ? JSON.stringify(user.metadata) : null,
+          user.deletedAt,
+        ]
+      )
+    }
+
+    // Create on-demand collection (NO cleanup between tests)
+    const onDemandUsers = createCollection(
+      electricCollectionOptions({
+        id: `electric-accum-users-${testId}`,
+        shapeOptions: {
+          url: `${baseUrl}/v1/shape`,
+          params: { table: `${testSchema}.${usersTable}` },
+        },
+        syncMode: `on-demand`,
+        getKey: (item: any) => item.id,
+        startSync: true,
+      })
+    )
+
+    await onDemandUsers.preload()
+
+    config = {
+      collections: {
+        eager: {
+          users: onDemandUsers as any,
+          posts: null as any,
+          comments: null as any,
+        },
+        onDemand: {
+          users: onDemandUsers as any,
+          posts: null as any,
+          comments: null as any,
+        },
+      },
+      setup: async () => {},
+      teardown: async () => {
+        await onDemandUsers.cleanup()
+        await dbClient.query(`DROP TABLE IF EXISTS ${usersTable}`)
+        await dbClient.end()
+      },
+    }
+  }, 60000)
+
+  afterAll(async () => {
+    await config.teardown()
+  })
+
+  function getConfig() {
+    return Promise.resolve(config)
+  }
+
+  // Run accumulated data tests (no cleanup between these tests)
+  createAccumulatedDataTestSuite(getConfig)
+})
diff --git a/packages/electric-db-collection/src/sql-compiler.ts b/packages/electric-db-collection/src/sql-compiler.ts
