move the badly named accumulated data tests

Author: samwillis

packages/db-collection-e2e/src/index.ts

@@ -26,4 +26,3 @@ 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"

packages/db-collection-e2e/src/suites/accumulated-data.suite.ts

@@ -271,5 +271,52 @@ export function createLiveUpdatesTestSuite(
         await Promise.all([query1.cleanup(), query2.cleanup()])
       })
     })
+
+    describe(`Update Existing Records`, () => {
+      it(`should update existing records in query results`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection })
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+
+        // Get a user and update it
+        const users = Array.from(query.state.values())
+        const userToUpdate = users[0]
+
+        if (userToUpdate) {
+          const originalAge = userToUpdate.age
+
+          // Update the user's age
+          await config.mutations.updateUser(userToUpdate.id, {
+            age: originalAge + 10,
+          })
+
+          // Wait for update to sync
+          await waitFor(
+            () => {
+              const updated = query.get(userToUpdate.id)
+              return updated?.age === originalAge + 10
+            },
+            { timeout: 5000, message: `Update did not sync to query` }
+          )
+
+          // Verify the update
+          const updatedUser = query.get(userToUpdate.id)
+          expect(updatedUser?.age).toBe(originalAge + 10)
+        }
+
+        await query.cleanup()
+      })
+    })
   })
 }

packages/db-collection-e2e/src/suites/live-updates.suite.ts

@@ -6,7 +6,7 @@
 
 import { randomUUID } from "node:crypto"
 import { describe, expect, it } from "vitest"
-import { createLiveQueryCollection, eq, gt } from "@tanstack/db"
+import { createLiveQueryCollection, eq, gt, isNull } from "@tanstack/db"
 import { waitFor, waitForQueryData } from "../utils/helpers"
 import type { E2ETestConfig } from "../types"
 
@@ -113,9 +113,8 @@ export function createMutationsTestSuite(
       it(`should handle update that makes record match predicate`, async () => {
         const config = await getConfig()
 
-        // Skip test if mutations not available (Query collection)
         if (!config.mutations) {
-          return
+          throw new Error(`Mutations not configured - test cannot run`)
         }
 
         const usersCollection = config.collections.onDemand.users
@@ -154,9 +153,8 @@ export function createMutationsTestSuite(
       it(`should handle update that makes record unmatch predicate`, async () => {
         const config = await getConfig()
 
-        // Skip test if mutations not available (Query collection)
         if (!config.mutations) {
-          return
+          throw new Error(`Mutations not configured - test cannot run`)
         }
 
         const usersCollection = config.collections.onDemand.users
@@ -193,6 +191,90 @@ export function createMutationsTestSuite(
       })
     })
 
+    describe(`Delete Mutations`, () => {
+      it(`should handle delete removing record from query`, async () => {
+        const config = await getConfig()
+
+        if (!config.mutations) {
+          throw new Error(`Mutations not configured - test cannot run`)
+        }
+
+        const usersCollection = config.collections.onDemand.users
+
+        const query = createLiveQueryCollection((q) =>
+          q.from({ user: usersCollection })
+        )
+
+        await query.preload()
+        await waitForQueryData(query, { minSize: 1 })
+        const initialSize = query.size
+        expect(initialSize).toBeGreaterThan(0)
+
+        // Get a user and delete it
+        const users = Array.from(query.state.values())
+        const userToDelete = users[0]
+
+        if (userToDelete) {
+          await config.mutations.deleteUser(userToDelete.id)
+
+          // Wait for delete to sync
+          await waitFor(() => query.size < initialSize, {
+            timeout: 5000,
+            message: `Delete did not sync to query`,
+          })
+
+          expect(query.size).toBe(initialSize - 1)
+        }
+
+        await query.cleanup()
+      })
+    })
+
+    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()
+        })
+
+        await query.cleanup()
+      })
+
+      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)
+
+        await query.cleanup()
+      })
+    })
+
     describe(`Mutation with Queries`, () => {
       it(`should maintain query state during data changes`, async () => {
         const config = await getConfig()

packages/db-collection-e2e/src/suites/mutations.suite.ts

@@ -9,7 +9,6 @@ import { createCollection } from "@tanstack/db"
 import { electricCollectionOptions } from "../src/electric"
 import { makePgClient } from "../../db-collection-e2e/support/global-setup"
 import {
-  createAccumulatedDataTestSuite,
   createCollationTestSuite,
   createDeduplicationTestSuite,
   createJoinsTestSuite,
@@ -380,99 +379,3 @@ 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
-// SKIP: These tests have timing issues with Electric shape invalidation (409 must-refetch)
-// TODO: Investigate and fix shape state handling
-describe.skip(`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,
-        },
-      },
-      // No mutations for accumulated data suite
-      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)
-})