@osdk/client 2.2.0-beta.2 → 2.2.0-beta.20

package/build/browser/observable/internal/Store.test.js

@@ -14,14 +14,21 @@
  * limitations under the License.
  */
 
-import { $ontologyRid, createOffice, Employee, Todo } from "@osdk/client.test.ontology";
-import { apiServer } from "@osdk/shared.test";
+import { editTodo, Employee, FooInterface, Todo } from "@osdk/client.test.ontology";
+import { ActionTypeBuilder, FauxFoundry, ontologies, startNodeApiServer, stubData } from "@osdk/shared.test";
+import chalk from "chalk";
+import invariant from "tiny-invariant";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi, vitest } from "vitest";
+import { ActionValidationError } from "../../actions/ActionValidationError.js";
 import { createClient } from "../../createClient.js";
+import { TestLogger } from "../../logger/TestLogger.js";
 import { createOptimisticId } from "./OptimisticId.js";
-import { Store } from "./Store.js";
-import { applyCustomMatchers, createClientMockHelper, createDefer, expectSingleListCallAndClear, expectSingleObjectCallAndClear, listPayloadContaining, mockListSubCallback, mockSingleSubCallback, objectPayloadContaining, waitForCall } from "./testUtils.js";
+import { runOptimisticJob } from "./OptimisticJob.js";
+import { invalidateList, Store } from "./Store.js";
+import { applyCustomMatchers, createClientMockHelper, createDefer, expectNoMoreCalls, expectSingleListCallAndClear, expectSingleObjectCallAndClear, getObject, mockListSubCallback, mockSingleSubCallback, objectPayloadContaining, updateList, updateObject, waitForCall } from "./testUtils.js";
+const JOHN_DOE_ID = 50030;
 const defer = createDefer();
+const logger = new TestLogger();
 beforeAll(() => {
   vi.setConfig({
     fakeTimers: {
@@ -38,7 +45,56 @@ const ANY_INIT_ENTRY = {
   lastUpdated: 0,
   status: "init"
 };
+
+// eslint-disable-next-line @typescript-eslint/no-deprecated
+function fullTaskName(task) {
+  return task ? `${fullTaskName(task.suite)} > ${task.name}` : "";
+}
+beforeEach(x => {
+  console.log(chalk.bgRed(chalk.white(fullTaskName(x.task))));
+});
+
+// helper method to make debugging tests easier
+function testStage(s) {
+  console.log(chalk.bgYellow(`Test Stage: ${s}`));
+}
 applyCustomMatchers();
+function setupOntology(fauxFoundry) {
+  const fauxOntology = fauxFoundry.getDefaultOntology();
+  ontologies.addEmployeeOntology(fauxOntology);
+  fauxFoundry.getDefaultOntology().registerObjectType(stubData.todoWithLinkTypes);
+  fauxFoundry.getDefaultOntology().registerActionType(stubData.editTodo.actionTypeV2, (b, payload) => {
+    const {
+      id,
+      ...other
+    } = payload.parameters;
+    b.modifyObject(Todo.apiName, id, {
+      ...other
+    });
+  });
+}
+function setupSomeEmployees(fauxFoundry) {
+  const dataStore = fauxFoundry.getDefaultDataStore();
+  dataStore.registerObject(Employee, {
+    employeeId: 1
+  });
+  dataStore.registerObject(Employee, {
+    employeeId: 2
+  });
+  dataStore.registerObject(Employee, {
+    $apiName: "Employee",
+    employeeId: 3
+  });
+  dataStore.registerObject(Employee, {
+    $apiName: "Employee",
+    employeeId: 4
+  });
+  dataStore.registerObject(Employee, {
+    $apiName: "Employee",
+    employeeId: JOHN_DOE_ID,
+    fullName: "John Doe"
+  });
+}
 describe(Store, () => {
   describe("with mock server", () => {
     let client;
@@ -46,44 +102,51 @@ describe(Store, () => {
     let employeesAsServerReturns;
     let mutatedEmployees;
     beforeAll(async () => {
-      apiServer.listen();
-      client = createClient("https://stack.palantir.com", $ontologyRid, async () => "myAccessToken");
+      const testSetup = startNodeApiServer(new FauxFoundry("https://stack.palantir.com/"), createClient, {
+        logger
+      });
+      ({
+        client
+      } = testSetup);
+      setupOntology(testSetup.fauxFoundry);
+      setupSomeEmployees(testSetup.fauxFoundry);
       employeesAsServerReturns = (await client(Employee).fetchPage()).data;
       mutatedEmployees = [employeesAsServerReturns[0], employeesAsServerReturns[1].$clone({
         fullName: "foo"
       }), ...employeesAsServerReturns.slice(2)];
-    });
-    afterAll(() => {
-      apiServer.close();
+      return () => {
+        testSetup.apiServer.close();
+      };
     });
     beforeEach(() => {
       cache = new Store(client);
-    });
-    afterEach(() => {
-      cache = undefined;
+      return () => {
+        cache = undefined;
+      };
     });
     it("basic single object works", async () => {
       const emp = employeesAsServerReturns[0];
+      const cacheKey = cache.getCacheKey("object", "Employee", emp.$primaryKey);
 
       // starts empty
-      expect(cache.getObject(Employee, emp.$primaryKey)).toBeUndefined();
-      const result = cache.updateObject(Employee, emp);
+      expect(cache.getValue(cacheKey)?.value).toBeUndefined();
+      const result = updateObject(cache, emp);
       expect(emp).toBe(result);
 
       // getting the object now matches the result
-      expect(cache.getObject(Employee, emp.$primaryKey)).toEqual(result);
-      const updatedEmpFromCache = cache.updateObject(Employee, emp.$clone({
+      expect(cache.getValue(cacheKey)?.value).toEqual(result);
+      const updatedEmpFromCache = updateObject(cache, emp.$clone({
         fullName: "new name"
       }));
       expect(updatedEmpFromCache).not.toBe(emp);
 
       // getting it again is the updated object
-      expect(cache.getObject(Employee, emp.$primaryKey)).toEqual(updatedEmpFromCache);
+      expect(cache.getValue(cacheKey)?.value).toEqual(updatedEmpFromCache);
     });
     describe("optimistic updates", () => {
       it("rolls back objects", async () => {
         const emp = employeesAsServerReturns[0];
-        cache.updateObject(Employee, emp); // pre-seed the cache with the "real" value
+        updateObject(cache, emp); // pre-seed the cache with the "real" value
 
         const subFn = mockSingleSubCallback();
         defer(cache.observeObject(Employee, emp.$primaryKey, {
@@ -92,7 +155,7 @@ describe(Store, () => {
         expectSingleObjectCallAndClear(subFn, emp, "loaded");
         const optimisticId = createOptimisticId();
         // update with an optimistic write
-        cache.updateObject(Employee, emp.$clone({
+        updateObject(cache, emp.$clone({
           fullName: "new name"
         }), {
           optimisticId
@@ -106,10 +169,12 @@ describe(Store, () => {
         expectSingleObjectCallAndClear(subFn, emp, "loaded");
       });
       it("rolls back to an updated real value", async () => {
-        vi.useFakeTimers();
-
         // pre-seed the cache with the "real" value
-        cache.updateList(Employee, {}, employeesAsServerReturns);
+        updateList(cache, {
+          type: Employee,
+          where: {},
+          orderBy: {}
+        }, employeesAsServerReturns);
         const emp = employeesAsServerReturns[0];
         const empSubFn = mockSingleSubCallback();
         defer(cache.observeObject(Employee, emp.$primaryKey, {
@@ -117,88 +182,90 @@ describe(Store, () => {
         }, empSubFn));
         expectSingleObjectCallAndClear(empSubFn, emp, "loaded");
         const listSubFn = mockListSubCallback();
-        defer(cache.observeList(Employee, {}, {
+        defer(cache.observeList({
+          type: Employee,
           mode: "offline"
         }, listSubFn));
+        await waitForCall(listSubFn, 1);
         expectSingleListCallAndClear(listSubFn, employeesAsServerReturns);
         const optimisticEmployee = emp.$clone({
           fullName: "new name"
         });
         const optimisticId = createOptimisticId();
+        testStage("optimistic update");
+        expect(listSubFn.next).not.toHaveBeenCalled();
 
         // update with an optimistic write
-        cache.updateObject(Employee, optimisticEmployee, {
+        updateObject(cache, optimisticEmployee, {
           optimisticId
         });
+        testStage("after optimistic update");
 
         // expect optimistic write
         expectSingleObjectCallAndClear(empSubFn, optimisticEmployee);
 
         // expect optimistic write to the list
-        expectSingleListCallAndClear(listSubFn, [optimisticEmployee, ...employeesAsServerReturns.slice(1)]);
+        await waitForCall(listSubFn, 1);
+        expectSingleListCallAndClear(listSubFn, [optimisticEmployee, ...employeesAsServerReturns.slice(1)], {
+          isOptimistic: true,
+          status: "loading"
+        });
 
         // write the real update, via the earlier list definition
         const truthUpdatedEmployee = emp.$clone({
           fullName: "real update"
         });
-        cache.updateList(Employee, {}, [truthUpdatedEmployee]);
-
-        // we shouldn't expect an update because the top layer has a value
-        expect(empSubFn).not.toHaveBeenCalled();
-
-        // we do get an update to the list but we still see the optimistic value
-        // for the object
-        expectSingleListCallAndClear(listSubFn, [optimisticEmployee]);
+        testStage("write real update");
+        updateList(cache, {
+          type: Employee,
+          where: {},
+          orderBy: {}
+        }, [truthUpdatedEmployee]);
 
         // remove the optimistic write
         cache.removeLayer(optimisticId);
 
         // see the object observation get updated
-        expectSingleObjectCallAndClear(empSubFn, truthUpdatedEmployee);
+        expectSingleObjectCallAndClear(empSubFn, truthUpdatedEmployee, "loaded");
 
         // see the list get updated
-        expectSingleListCallAndClear(listSubFn, [truthUpdatedEmployee]);
-        vi.useRealTimers();
+        await waitForCall(listSubFn, 1);
+        expectSingleListCallAndClear(listSubFn, [truthUpdatedEmployee], {
+          status: "loaded",
+          isOptimistic: false
+        });
       });
       it("rolls back to an updated real value via list", async () => {
         const emp = employeesAsServerReturns[0];
-        cache.updateObject(Employee, emp); // pre-seed the cache with the "real" value
+        updateObject(cache, emp); // pre-seed the cache with the "real" value
 
         const subFn = mockSingleSubCallback();
         defer(cache.observeObject(Employee, emp.$primaryKey, {
           mode: "offline"
         }, subFn));
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: emp,
-          status: "loaded"
-        }));
-        subFn.mockClear();
+        expectSingleObjectCallAndClear(subFn, emp, "loaded");
         const optimisticEmployee = emp.$clone({
           fullName: "new name"
         });
 
         // update with an optimistic write
         const optimisticId = createOptimisticId();
-        cache.updateObject(Employee, optimisticEmployee, {
+        updateObject(cache, optimisticEmployee, {
           optimisticId
         });
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: optimisticEmployee
-        }));
-        subFn.mockClear();
+        expectSingleObjectCallAndClear(subFn, optimisticEmployee);
         const truthUpdatedEmployee = emp.$clone({
           fullName: "real update"
         });
-        cache.updateObject(Employee, truthUpdatedEmployee);
+        updateObject(cache, truthUpdatedEmployee);
 
         // we shouldn't expect an update because the top layer has a value
-        expect(subFn).not.toHaveBeenCalled();
+        expect(subFn.next).not.toHaveBeenCalled();
 
         // remove the optimistic write
         cache.removeLayer(optimisticId);
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: truthUpdatedEmployee
-        }));
+        expectSingleObjectCallAndClear(subFn, truthUpdatedEmployee);
+        expectNoMoreCalls(subFn);
       });
     });
     describe(".invalidateObject", () => {
@@ -207,29 +274,20 @@ describe(Store, () => {
         const staleEmp = emp.$clone({
           fullName: "stale"
         });
-        cache.updateObject(Employee, staleEmp);
+        updateObject(cache, staleEmp);
         const subFn = mockSingleSubCallback();
         defer(cache.observeObject(Employee, emp.$primaryKey, {
           mode: "offline"
         }, subFn));
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: staleEmp,
-          status: "loaded"
-        }));
-        subFn.mockClear();
+        expectSingleObjectCallAndClear(subFn, staleEmp, "loaded");
 
         // invalidate
         void cache.invalidateObject(Employee, staleEmp.$primaryKey);
-        await vi.waitFor(() => expect(subFn).toHaveBeenCalled());
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: staleEmp,
-          status: "loading"
-        }));
-        subFn.mockClear();
-        await vi.waitFor(() => expect(subFn).toHaveBeenCalled());
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: emp
-        }));
+        await waitForCall(subFn);
+        expectSingleObjectCallAndClear(subFn, staleEmp, "loading");
+        await waitForCall(subFn);
+        expectSingleObjectCallAndClear(subFn, emp, "loaded");
+        expectNoMoreCalls(subFn);
       });
     });
     describe(".invalidateList", () => {
@@ -244,39 +302,43 @@ describe(Store, () => {
         const staleEmp = emp.$clone({
           fullName: "stale"
         });
-        cache.updateList(Employee, {}, [staleEmp]);
+        updateList(cache, {
+          type: Employee,
+          where: {},
+          orderBy: {}
+        }, [staleEmp]);
         const subFn = mockSingleSubCallback();
         defer(cache.observeObject(Employee, emp.$primaryKey, {
           mode: "offline"
         }, subFn));
         expectSingleObjectCallAndClear(subFn, staleEmp);
         const subListFn = mockListSubCallback();
-        defer(cache.observeList(Employee, {}, {
+        defer(cache.observeList({
+          type: Employee,
           mode: "offline"
         }, subListFn));
-        await vi.waitFor(() => expect(subListFn).toHaveBeenCalled());
-        expect(subListFn).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: [staleEmp],
+        await waitForCall(subListFn, 1);
+        expectSingleListCallAndClear(subListFn, [staleEmp], {
           status: "loaded"
-        }));
-        subListFn.mockClear();
-        cache.invalidateList(Employee, {});
-        await vi.waitFor(() => expect(subListFn).toHaveBeenCalled());
-        expect(subListFn).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: [staleEmp],
+        });
+        testStage("invalidate");
+        const invalidateListPromise = invalidateList(cache, {
+          type: Employee
+        });
+        testStage("check invalidate");
+        await waitForCall(subListFn, 1);
+        expectSingleListCallAndClear(subListFn, [staleEmp], {
           status: "loading"
-        }));
-        subListFn.mockClear();
-        await vi.waitFor(() => expect(subListFn).toHaveBeenCalled());
-        expect(subListFn).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: employeesAsServerReturns
-        }));
-        subListFn.mockClear();
-        await vi.waitFor(() => expect(subFn).toHaveBeenCalled());
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          status: "loaded",
-          object: emp
-        }));
+        });
+        await waitForCall(subListFn, 1);
+        expectSingleListCallAndClear(subListFn, employeesAsServerReturns, {
+          status: "loaded"
+        });
+        await waitForCall(subFn, 1);
+        expectSingleObjectCallAndClear(subFn, emp, "loaded");
+
+        // don't leave promises dangling
+        await invalidateListPromise;
       });
     });
     describe(".invalidateObjectType", () => {
@@ -291,92 +353,92 @@ describe(Store, () => {
         const staleEmp = emp.$clone({
           fullName: "stale"
         });
-        cache.updateList(Employee, {}, [staleEmp]);
+        updateList(cache, {
+          type: Employee,
+          where: {},
+          orderBy: {}
+        }, [staleEmp]);
         const subFn = mockSingleSubCallback();
         defer(cache.observeObject(Employee, emp.$primaryKey, {
           mode: "offline"
         }, subFn));
         expectSingleObjectCallAndClear(subFn, staleEmp);
         const subListFn = mockListSubCallback();
-        defer(cache.observeList(Employee, {}, {
+        defer(cache.observeList({
+          type: Employee,
+          where: {},
+          orderBy: {},
           mode: "offline"
         }, subListFn));
-        await vi.waitFor(() => expect(subListFn).toHaveBeenCalled());
-        expect(subListFn).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: [staleEmp],
+        await waitForCall(subListFn, 1);
+        expectSingleListCallAndClear(subListFn, [staleEmp], {
           status: "loaded"
-        }));
-        subListFn.mockClear();
-        cache.invalidateObjectType(Employee);
-        await vi.waitFor(() => expect(subListFn).toHaveBeenCalled());
-        expect(subListFn).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: [staleEmp],
+        });
+        testStage("invalidate");
+        const pInvalidateComplete = cache.invalidateObjectType(Employee, undefined);
+        await waitForCall(subListFn, 1);
+        expectSingleListCallAndClear(subListFn, [staleEmp], {
           status: "loading"
-        }));
-        subListFn.mockClear();
-        await vi.waitFor(() => expect(subListFn).toHaveBeenCalled());
-        expect(subListFn).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: employeesAsServerReturns
-        }));
-        subListFn.mockClear();
-        await vi.waitFor(() => expect(subFn).toHaveBeenCalled());
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          status: "loaded",
-          object: emp
-        }));
+        });
+        await waitForCall(subListFn, 1);
+        expectSingleListCallAndClear(subListFn, employeesAsServerReturns);
+        await waitForCall(subFn, 1);
+        expectSingleObjectCallAndClear(subFn, emp, "loaded");
+
+        // we don't need this value to control the test but we want to make sure we don't have
+        // any unhandled exceptions upon test completion
+        await pInvalidateComplete;
       });
     });
     describe(".observeObject (force)", () => {
       const subFn1 = mockSingleSubCallback();
       const subFn2 = mockSingleSubCallback();
       beforeEach(async () => {
-        subFn1.mockClear();
-        subFn2.mockClear();
+        subFn1.complete.mockClear();
+        subFn1.next.mockClear();
+        subFn1.error.mockClear();
+        subFn2.complete.mockClear();
+        subFn2.next.mockClear();
+        subFn2.error.mockClear();
       });
       const likeEmployee50030 = expect.objectContaining({
-        $primaryKey: 50030,
+        $primaryKey: JOHN_DOE_ID,
         fullName: "John Doe"
       });
       it("fetches and updates twice", async () => {
-        defer(cache.observeObject(Employee, 50030, {
+        defer(cache.observeObject(Employee, JOHN_DOE_ID, {
           mode: "force"
         }, subFn1));
-        expect(subFn1).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
+        expect(subFn1.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
           status: "loading",
           object: undefined,
           isOptimistic: false
         }));
-        subFn1.mockClear();
-        await vi.waitFor(() => expect(subFn1).toHaveBeenCalled());
-        expect(subFn1).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
+        subFn1.next.mockClear();
+        await waitForCall(subFn1);
+        expect(subFn1.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
           object: likeEmployee50030,
           isOptimistic: false
         }));
-        const firstLoad = subFn1.mock.lastCall?.[0];
-        subFn1.mockClear();
-        defer(cache.observeObject(Employee, 50030, {
+        const firstLoad = subFn1.next.mock.lastCall?.[0];
+        subFn1.next.mockClear();
+        defer(cache.observeObject(Employee, JOHN_DOE_ID, {
           mode: "force"
         }, subFn2));
-        expect(subFn1).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          status: "loading"
-        }));
-        subFn1.mockClear();
+        expectSingleObjectCallAndClear(subFn1, likeEmployee50030, "loading");
 
         // should be the earlier results
-        expect(subFn2).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          status: "loading"
-        }));
-        subFn2.mockClear();
+        expectSingleObjectCallAndClear(subFn2, likeEmployee50030, "loading");
 
         // both will be updated
         for (const s of [subFn1, subFn2]) {
           // wait for the result to come in
-          await vi.waitFor(() => expect(s).toHaveBeenCalled());
-          expect(s).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
+          await waitForCall(s, 1);
+          expect(s.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
             ...firstLoad,
             lastUpdated: expect.toBeGreaterThan(firstLoad.lastUpdated)
           }));
-          s.mockClear();
+          s.next.mockClear();
         }
       });
     });
@@ -384,152 +446,185 @@ describe(Store, () => {
       const subFn = mockSingleSubCallback();
       let sub;
       beforeEach(() => {
-        subFn.mockClear();
-        sub = defer(cache.observeObject(Employee, 50030, {
+        subFn.complete.mockClear();
+        subFn.next.mockClear();
+        subFn.error.mockClear();
+        sub = defer(cache.observeObject(Employee, JOHN_DOE_ID, {
           mode: "offline"
         }, subFn));
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          status: "init",
-          object: undefined
-        }));
-        subFn.mockClear();
+        expectSingleObjectCallAndClear(subFn, undefined, "init");
       });
       it("does basic observation and unsubscribe", async () => {
-        const emp = employeesAsServerReturns[0];
+        const emp = employeesAsServerReturns.find(x => x.$primaryKey === JOHN_DOE_ID);
 
         // force an update
-        cache.updateObject(Employee, emp);
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: emp
-        }));
-        subFn.mockClear();
+        updateObject(cache, emp);
+        expectSingleObjectCallAndClear(subFn, emp);
 
         // force again
-        cache.updateObject(Employee, emp.$clone({
+        updateObject(cache, emp.$clone({
           fullName: "new name"
         }));
-        expect(subFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: expect.objectContaining({
-            fullName: "new name"
-          })
+        expectSingleObjectCallAndClear(subFn, emp.$clone({
+          fullName: "new name"
         }));
-        subFn.mockClear();
         sub.unsubscribe();
 
         // force again but no subscription update
-        cache.updateObject(Employee, emp.$clone({
+        updateObject(cache, emp.$clone({
           fullName: "new name 2"
         }));
-        expect(subFn).not.toHaveBeenCalled();
+        expect(subFn.next).not.toHaveBeenCalled();
       });
       it("observes with list update", async () => {
-        const emp = employeesAsServerReturns[0];
+        const emp = employeesAsServerReturns.find(x => x.$primaryKey === JOHN_DOE_ID);
 
         // force an update
-        cache.updateObject(Employee, emp.$clone({
+        updateObject(cache, emp.$clone({
           fullName: "not the name"
         }));
-        expect(subFn).toHaveBeenCalledTimes(1);
-        cache.updateList(Employee, {}, employeesAsServerReturns);
-        expect(subFn).toHaveBeenCalledTimes(2);
-        expect(subFn.mock.calls[1][0]).toEqual(objectPayloadContaining({
+        expect(subFn.next).toHaveBeenCalledTimes(1);
+        updateList(cache, {
+          type: Employee,
+          where: {},
+          orderBy: {}
+        }, employeesAsServerReturns);
+        expect(subFn.next).toHaveBeenCalledTimes(2);
+        expect(subFn.next.mock.calls[1][0]).toEqual(objectPayloadContaining({
           object: emp
         }));
       });
     });
     describe(".observeList", () => {
       const listSub1 = mockListSubCallback();
+      const ifaceSub = mockListSubCallback();
       beforeEach(() => {
         vi.useFakeTimers({});
-        listSub1.mockReset();
+        vi.mocked(listSub1.next).mockReset();
+        vi.mocked(listSub1.error).mockReset();
+        vi.mocked(listSub1.complete).mockReset();
+        vi.mocked(ifaceSub.next).mockReset();
+        vi.mocked(ifaceSub.error).mockReset();
+        vi.mocked(ifaceSub.complete).mockReset();
       });
       afterEach(() => {
         vi.useRealTimers();
       });
       describe("mode=force", () => {
         it("initial load", async () => {
-          defer(cache.observeList(Employee, {}, {
+          defer(cache.observeList({
+            type: Employee,
+            orderBy: {},
             mode: "force"
           }, listSub1));
+          defer(cache.observeList({
+            type: FooInterface,
+            orderBy: {},
+            mode: "force"
+          }, ifaceSub));
           vitest.runOnlyPendingTimers();
-          await vi.waitFor(() => expect(listSub1).toHaveBeenCalled());
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            status: "loading",
-            resolvedList: []
-          }));
-          listSub1.mockClear();
-          await vi.waitFor(() => expect(listSub1).toHaveBeenCalled());
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: employeesAsServerReturns,
+          await waitForCall(listSub1);
+          await waitForCall(ifaceSub);
+          expectSingleListCallAndClear(listSub1, [], {
+            status: "loading"
+          });
+          expectSingleListCallAndClear(ifaceSub, [], {
+            status: "loading"
+          });
+          await waitForCall(listSub1);
+          expectSingleListCallAndClear(listSub1, employeesAsServerReturns, {
             status: "loaded"
-          }));
+          });
+          await waitForCall(ifaceSub);
+          expectSingleListCallAndClear(ifaceSub, employeesAsServerReturns, {
+            status: "loaded"
+          });
+          expectNoMoreCalls(listSub1);
+          expectNoMoreCalls(ifaceSub);
+          expect(listSub1.next).not.toHaveBeenCalled();
+          expect(listSub1.error).not.toHaveBeenCalled();
+          expect(ifaceSub.next).not.toHaveBeenCalled();
+          expect(ifaceSub.error).not.toHaveBeenCalled();
         });
         it("subsequent load", async () => {
           // Pre-seed with data the server doesn't return
-          cache.updateList(Employee, {}, mutatedEmployees);
-          defer(cache.observeList(Employee, {}, {
+          updateList(cache, {
+            type: Employee,
+            where: {},
+            orderBy: {}
+          }, mutatedEmployees);
+          defer(cache.observeList({
+            type: Employee,
             mode: "force"
           }, listSub1));
-          await vi.waitFor(() => expect(listSub1).toHaveBeenCalled());
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: mutatedEmployees,
+          await waitForCall(listSub1, 1);
+          const firstLoad = listSub1.next.mock.calls[0][0];
+          expectSingleListCallAndClear(listSub1, mutatedEmployees, {
             status: "loading"
-          }));
-          const firstLoad = listSub1.mock.calls[0][0];
-          listSub1.mockClear();
-          await vi.waitFor(() => expect(listSub1).toHaveBeenCalled());
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: employeesAsServerReturns,
+          });
+          await waitForCall(listSub1, 1);
+          expectSingleListCallAndClear(listSub1, employeesAsServerReturns, {
             status: "loaded",
             lastUpdated: expect.toBeGreaterThan(firstLoad.lastUpdated)
-          }));
-          listSub1.mockClear();
+          });
         });
       });
       describe("mode = offline", () => {
         it("updates with list updates", async () => {
-          defer(cache.observeList(Employee, {}, {
+          defer(cache.observeList({
+            type: Employee,
+            where: {},
+            orderBy: {},
             mode: "offline"
           }, listSub1));
-          expect(listSub1).toHaveBeenCalledTimes(0);
-          cache.updateList(Employee, {}, employeesAsServerReturns);
+          expect(listSub1.next).toHaveBeenCalledTimes(0);
+          updateList(cache, {
+            type: Employee,
+            where: {},
+            orderBy: {}
+          }, employeesAsServerReturns);
           vitest.runOnlyPendingTimers();
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: employeesAsServerReturns
-          }));
-          listSub1.mockClear();
+          expectSingleListCallAndClear(listSub1, employeesAsServerReturns);
 
           // list is just now one object
-          cache.updateList(Employee, {}, [employeesAsServerReturns[0]]);
+          updateList(cache, {
+            type: Employee,
+            where: {},
+            orderBy: {}
+          }, [employeesAsServerReturns[0]]);
           vitest.runOnlyPendingTimers();
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: [employeesAsServerReturns[0]]
-          }));
+          expectSingleListCallAndClear(listSub1, [employeesAsServerReturns[0]]);
         });
         it("updates with different list updates", async () => {
-          defer(cache.observeList(Employee, {}, {
+          defer(cache.observeList({
+            type: Employee,
+            where: {},
+            orderBy: {},
             mode: "offline"
           }, listSub1));
-          expect(listSub1).toHaveBeenCalledTimes(0);
-          cache.updateList(Employee, {}, employeesAsServerReturns);
+          expect(listSub1.next).toHaveBeenCalledTimes(0);
+          updateList(cache, {
+            type: Employee,
+            where: {},
+            orderBy: {}
+          }, employeesAsServerReturns);
           vitest.runOnlyPendingTimers();
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: employeesAsServerReturns
-          }));
-          listSub1.mockClear();
+          expectSingleListCallAndClear(listSub1, employeesAsServerReturns);
 
           // new where === different list
-          cache.updateList(Employee, {
-            employeeId: {
-              $gt: 0
-            }
+          updateList(cache, {
+            type: Employee,
+            where: {
+              employeeId: {
+                $gt: 0
+              }
+            },
+            orderBy: {}
           }, mutatedEmployees);
           vitest.runOnlyPendingTimers();
 
           // original list updates still
-          expect(listSub1).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-            resolvedList: mutatedEmployees
-          }));
+          expectSingleListCallAndClear(listSub1, mutatedEmployees);
         });
       });
     });
@@ -542,57 +637,127 @@ describe(Store, () => {
       });
       it("works in the solo case", async () => {
         const listSub = mockListSubCallback();
-        defer(cache.observeList(Employee, {}, {
+        defer(cache.observeList({
+          type: Employee,
+          where: {},
+          orderBy: {},
           mode: "force",
           pageSize: 1
         }, listSub));
-        expect(listSub).not.toHaveBeenCalled();
-        await vi.waitFor(() => expect(listSub).toHaveBeenCalled());
-        expect(listSub).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
+        expect(listSub.next).not.toHaveBeenCalled();
+        await waitForCall(listSub, 1);
+        expectSingleListCallAndClear(listSub, [], {
           status: "loading"
-        }));
-        listSub.mockClear();
-        await vi.waitFor(() => expect(listSub).toHaveBeenCalled());
-        expect(listSub).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: employeesAsServerReturns.slice(0, 1),
-          status: "loaded"
-        }));
+        });
+        await waitForCall(listSub, 1);
         const {
           fetchMore
-        } = listSub.mock.calls[0][0];
-        listSub.mockClear();
+        } = listSub.next.mock.calls[0][0];
+        expectSingleListCallAndClear(listSub, employeesAsServerReturns.slice(0, 1), {
+          status: "loaded"
+        });
         void fetchMore();
-        await vi.waitFor(() => expect(listSub).toHaveBeenCalledTimes(1));
-        expect(listSub).toHaveBeenCalledExactlyOnceWith(listPayloadContaining({
-          resolvedList: employeesAsServerReturns.slice(0, 1),
+        await waitForCall(listSub, 1);
+        expectSingleListCallAndClear(listSub, employeesAsServerReturns.slice(0, 1), {
           status: "loading"
-        }));
-        listSub.mockClear();
-        await vi.waitFor(() => expect(listSub).toHaveBeenCalledTimes(1));
-        expect(listSub).toHaveBeenCalledWith(listPayloadContaining({
-          resolvedList: employeesAsServerReturns.slice(0, 2),
+        });
+        await waitForCall(listSub, 1);
+        expectSingleListCallAndClear(listSub, employeesAsServerReturns.slice(0, 2), {
           status: "loaded"
-        }));
+        });
       });
     });
   });
   describe("with mock client", () => {
     let client;
-    let mockClient;
-    let cache;
+    let apiServer;
+    let fauxFoundry;
+    let store;
+    beforeAll(async () => {
+      const testSetup = startNodeApiServer(new FauxFoundry("https://stack.palantir.com/", undefined, {
+        logger
+      }), createClient, {
+        logger
+      });
+      ({
+        client,
+        apiServer,
+        fauxFoundry
+      } = testSetup);
+      setupOntology(testSetup.fauxFoundry);
+      return () => {
+        testSetup.apiServer.close();
+      };
+    });
+    beforeEach(() => {
+      apiServer.resetHandlers();
+    });
     beforeEach(async () => {
-      mockClient = createClientMockHelper();
-      client = mockClient.client;
-      cache = new Store(client);
+      store = new Store(client);
+    });
+    it("properly fires error handler for a list", async () => {
+      const sub = mockListSubCallback();
+      store.observeList({
+        type: Employee,
+        where: {
+          aBadPropertyThatDoesNotExist: "aBadValue"
+        },
+        orderBy: {}
+      }, sub);
+      await waitForCall(sub.error, 1);
+      expect(sub.error).toHaveBeenCalled();
+      expect(sub.next).not.toHaveBeenCalled();
+    });
+    describe("batching", () => {
+      it("groups requests for single objects", async () => {
+        fauxFoundry.getDefaultDataStore().registerObject(Employee, {
+          $apiName: "Employee",
+          employeeId: 0
+        });
+        fauxFoundry.getDefaultDataStore().registerObject(Employee, {
+          $apiName: "Employee",
+          employeeId: 1
+        });
+        const a = mockSingleSubCallback();
+        const b = mockSingleSubCallback();
+        defer(store.observeObject(Employee, 0, {}, a));
+        defer(store.observeObject(Employee, 1, {}, b));
+        await a.expectLoadingAndLoaded({
+          loading: objectPayloadContaining({
+            status: "loading",
+            object: undefined
+          }),
+          loaded: objectPayloadContaining({
+            object: expect.objectContaining({
+              $primaryKey: 0
+            })
+          })
+        });
+        await b.expectLoadingAndLoaded({
+          loading: objectPayloadContaining({
+            status: "loading",
+            object: undefined
+          }),
+          loaded: objectPayloadContaining({
+            object: expect.objectContaining({
+              $primaryKey: 1
+            })
+          })
+        });
+      });
     });
     describe("actions", () => {
+      beforeEach(() => {
+        fauxFoundry.getDefaultDataStore().clear();
+      });
       it("properly invalidates objects", async () => {
-        // after the below `observeObject`, the cache will need to load from the server
-        mockClient.mockFetchOneOnce().resolve({
-          $apiName: "Todo"
+        fauxFoundry.getDefaultDataStore().registerObject(Todo, {
+          $apiName: "Todo",
+          id: 0,
+          text: "og title"
         });
         const todoSubFn = mockSingleSubCallback();
-        defer(cache.observeObject(Todo, 0, {}, todoSubFn));
+        defer(store.observeObject(Todo, 0, {}, todoSubFn));
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading",
@@ -606,23 +771,10 @@ describe(Store, () => {
         });
 
         // at this point we have an observation properly set up
-        mockClient.mockApplyActionOnce().resolve({
-          addedObjects: [{
-            objectType: "Todo",
-            primaryKey: 0
-          }]
-        });
-
-        // after we apply the action, the object is invalidated and gets re-requested
-
-        mockClient.mockFetchOneOnce().resolve({
-          $apiName: "Todo",
+        await store.applyAction(editTodo, {
+          id: 0,
           text: "hello there kind sir"
         });
-        const actionPromise = cache.applyAction(createOffice, {
-          officeId: "whatever"
-        });
-        await actionPromise;
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading"
@@ -635,17 +787,19 @@ describe(Store, () => {
         });
       });
       it("rolls back optimistic updates on error", async () => {
-        const fauxObject = {
-          $apiName: "Todo",
-          $objectType: "Todo",
-          $primaryKey: 0,
-          $title: "does not matter"
-        };
+        const fauxObject = expect.objectContaining({
+          id: 0,
+          text: "does not matter"
+        });
 
-        // after the below `observeObject`, the cache will need to load from the server
-        mockClient.mockFetchOneOnce().resolve(fauxObject);
+        // set the object in the "backend"
+        fauxFoundry.getDefaultDataStore().registerObject(Todo, {
+          $apiName: "Todo",
+          id: 0,
+          text: "does not matter"
+        });
         const todoSubFn = mockSingleSubCallback();
-        defer(cache.observeObject(Todo, 0, {}, todoSubFn));
+        defer(store.observeObject(Todo, 0, {}, todoSubFn));
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading",
@@ -658,47 +812,259 @@ describe(Store, () => {
             isOptimistic: false
           })
         });
+        const object = store.getValue(store.getCacheKey("object", "Todo", 0))?.value;
+        !object ? process.env.NODE_ENV !== "production" ? invariant(false) : invariant(false) : void 0;
 
         // at this point we have an observation properly set up
-        const applyActionResult = mockClient.mockApplyActionOnce();
-        const actionPromise = cache.applyAction(createOffice, {
-          officeId: "whatever"
+        await expect(store.applyAction(editTodo, {
+          id: "not an id that exists"
         }, {
           optimisticUpdate: ctx => {
-            ctx.updateObject({
-              ...fauxObject,
-              someValue: "optimistic"
-            });
+            ctx.updateObject(object.$clone({
+              text: "optimistic"
+            }));
           }
+        })).rejects.toThrow(ActionValidationError);
+        await waitForCall(todoSubFn, 2);
+        await todoSubFn.expectLoadingAndLoaded({
+          loading: objectPayloadContaining({
+            status: "loading",
+            object: expect.objectContaining({
+              id: 0,
+              text: "optimistic"
+            }),
+            isOptimistic: true
+          }),
+          loaded: objectPayloadContaining({
+            object: fauxObject,
+            status: "loaded",
+            isOptimistic: false
+          })
         });
-        await waitForCall(todoSubFn, 1);
-        expect(todoSubFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: {
-            ...fauxObject,
-            someValue: "optimistic"
-          },
-          status: "loading",
-          isOptimistic: true
+      });
+    });
+    describe("orderBy", async () => {
+      let nextPk = 0;
+      let fauxObjectA;
+      let fauxObjectB;
+      let fauxObjectC;
+      beforeAll(async () => {
+        fauxFoundry.getDefaultDataStore().clear();
+        [fauxObjectA, fauxObjectB, fauxObjectC] = await Promise.all(["a", "b", "c"].map(text => {
+          const id = nextPk++;
+          fauxFoundry.getDefaultDataStore().registerObject(Todo, {
+            $apiName: "Todo",
+            id,
+            text
+          });
+          return client(Todo).fetchOne(id);
         }));
-        todoSubFn.mockClear();
+      });
+      const noWhereNoOrderBy = {
+        type: Todo,
+        where: {},
+        orderBy: {}
+      };
+      const noWhereOrderByText = {
+        type: Todo,
+        where: {},
+        orderBy: {
+          text: "asc"
+        }
+      };
+      const subListUnordered = mockListSubCallback();
+      const subListOrdered = mockListSubCallback();
+      beforeEach(() => {
+        defer(store.observeList({
+          ...noWhereNoOrderBy,
+          mode: "offline"
+        }, subListUnordered));
+        expect(subListUnordered.next).toHaveBeenCalledTimes(0);
+        defer(store.observeList({
+          ...noWhereOrderByText,
+          mode: "offline"
+        }, subListOrdered));
+        expect(subListOrdered.next).toHaveBeenCalledTimes(0);
+      });
+      it("invalidates the correct lists", async () => {
+        // for whatever reason, the first list is loaded as [B, A]
+        updateList(store, noWhereNoOrderBy, [fauxObjectB, fauxObjectA]);
+        await waitForCall(subListUnordered, 1);
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectB, fauxObjectA]);
 
-        // let the action error out
-        applyActionResult.reject("an error thrown");
-        await expect(actionPromise).rejects.toThrow("an error thrown");
+        // The other list definitely matches on the where clause and we can insert
+        // orderBy properly. So this is [A, B]
+        await waitForCall(subListOrdered, 1);
+        expectSingleListCallAndClear(subListOrdered, [fauxObjectA, fauxObjectB]);
 
-        // back to the original object
-        await waitForCall(todoSubFn, 1);
-        expect(todoSubFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
-          object: fauxObject,
-          status: "loaded",
+        // For whatever reason, object B is no longer in the first set (use your imagination)
+        // but we have added a C before A. So the first list is [C, A]
+        updateList(store, {
+          type: Todo,
+          where: {},
+          orderBy: {}
+        }, [fauxObjectC, fauxObjectA]);
+        await waitForCall(subListUnordered, 1);
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectC, fauxObjectA]);
+
+        // Nothing told the system that B was deleted so we can presume it still exists
+        // and therefore the second list is now [A, B, C]
+        await waitForCall(subListOrdered, 1);
+        expectSingleListCallAndClear(subListOrdered, [fauxObjectA, fauxObjectB, fauxObjectC]);
+      });
+      it("produces proper results with optimistic updates and successful action", async () => {
+        const optimisticallyMutatedA = fauxObjectA.$clone({
+          text: "optimistic"
+        });
+        const pkForOptimistic = nextPk++;
+        const optimisticallyCreatedObjectD = expect.objectContaining({
+          "text": "d",
+          id: pkForOptimistic
+        });
+
+        // for whatever reason, the first list is loaded as [B, A]
+        updateList(store, noWhereNoOrderBy, [fauxObjectB, fauxObjectA]);
+        await waitForCall(subListUnordered, 1);
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectB, fauxObjectA]);
+
+        // The other list definitely matches on the where clause and we can insert
+        // orderBy properly. So this is [A, B]
+        await waitForCall(subListOrdered, 1);
+        expectSingleListCallAndClear(subListOrdered, [fauxObjectA, fauxObjectB]);
+        testStage("Start");
+
+        // Perform something optimistic.
+        const removeOptimisticResult = runOptimisticJob(store, b => {
+          b.createObject(Todo, pkForOptimistic, {
+            id: pkForOptimistic,
+            text: "d"
+          });
+          b.updateObject(optimisticallyMutatedA);
+        });
+
+        // The first list is now [B, A, optimistic]
+        await waitForCall(subListUnordered, 1);
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectB, optimisticallyMutatedA,
+        // same position, new values
+        optimisticallyCreatedObjectD], {
+          isOptimistic: true
+        });
+
+        // the second list is now [A, B, optimistic]
+        await waitForCall(subListOrdered, 1);
+        expectSingleListCallAndClear(subListOrdered, [fauxObjectB, optimisticallyCreatedObjectD, optimisticallyMutatedA], {
+          isOptimistic: true
+        });
+
+        // Roll back the optimistic update
+        await removeOptimisticResult();
+
+        // The first list is now [B, A]
+        await waitForCall(subListUnordered, 1);
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectB, fauxObjectA], {
           isOptimistic: false
-        }));
+        });
+
+        // the second list is now [A, B]
+        await waitForCall(subListOrdered, 1);
+        expectSingleListCallAndClear(subListOrdered, [fauxObjectA, fauxObjectB], {
+          isOptimistic: false
+        });
+      });
+      // I think these are named backwards
+      it("produces proper results with optimistic updates and rollback", async () => {
+        const pkForOptimistic = nextPk++;
+        const optimisticallyCreatedObjectD = expect.objectContaining({
+          "$primaryKey": pkForOptimistic,
+          "$title": undefined,
+          // FIXME once this is calculated by optimistic then this needs to be the right value
+          "text": "d optimistic",
+          id: pkForOptimistic
+        });
+        const optimisticallyMutatedA = fauxObjectA.$clone({
+          text: "optimistic"
+        });
+        testStage("Initial Setup");
+
+        // for whatever reason, the first list is loaded as [B, A]
+        updateList(store, noWhereNoOrderBy, [fauxObjectB, fauxObjectA]);
+        await waitForCall(subListUnordered, 1);
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectB, fauxObjectA]);
+
+        // The other list definitely matches on the where clause and we can insert
+        // orderBy properly. So this is [A, B]
+        expectSingleListCallAndClear(subListOrdered, [fauxObjectA, fauxObjectB]);
+        testStage("Optimistic Creation");
+
+        // create the weirdest action ever. It always creates a Todo with
+        // a new primary key and the text "d" and updates A
+        const {
+          actionDefinition: crazyAction,
+          actionTypeV2: crazyActionTypeV2
+        } = new ActionTypeBuilder("asdf").addParameter("foo", "string").build();
+        fauxFoundry.getDefaultOntology().registerActionType(crazyActionTypeV2, batch => {
+          const idForD = nextPk++;
+          batch.addObject(Todo.apiName, idForD, {
+            id: idForD,
+            text: "d"
+          });
+          batch.modifyObject(fauxObjectA.$apiName, fauxObjectA.$primaryKey, {
+            text: "a prime",
+            $title: "a prime" // FIXME we shouldn't have to set this, it can be calculated
+          });
+        });
+
+        // the optimistic job will call createObject which triggers the `objectFactory2` of the
+        // cache context.
+
+        // Perform something optimistic.
+        const pActionResult = store.applyAction(crazyAction, {}, {
+          optimisticUpdate: b => {
+            b.createObject(Todo, pkForOptimistic, {
+              id: pkForOptimistic,
+              text: "d optimistic"
+            });
+            b.updateObject(optimisticallyMutatedA);
+          }
+        });
+        testStage("Optimistic Updates");
+
+        // The first list is now [B, A, optimistic]
+        await waitForCall(subListUnordered, 1);
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectB, optimisticallyMutatedA,
+        // same position, new values
+        optimisticallyCreatedObjectD], {
+          isOptimistic: true
+        });
+
+        // the second list is now [B, optimistic, optimistic a]
+        await waitForCall(subListOrdered, 1);
+        expectSingleListCallAndClear(subListOrdered, [fauxObjectB, optimisticallyCreatedObjectD, optimisticallyMutatedA], {
+          isOptimistic: true
+        });
+        testStage("Resolve Action");
+        const modifiedObjectA = fauxObjectA.$clone({
+          text: "a prime"
+        });
+        const pkForD = (await pActionResult).addedObjects?.[0].primaryKey;
+        !(typeof pkForD === "number") ? process.env.NODE_ENV !== "production" ? invariant(false) : invariant(false) : void 0;
+        // load this without the cache for comparisons
+        const createdObjectD = await client(Todo).fetchOne(pkForD);
+        await waitForCall(subListUnordered, 1);
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectB, modifiedObjectA, createdObjectD], {
+          isOptimistic: false
+        });
+        await waitForCall(subListOrdered, 1);
+        expectSingleListCallAndClear(subListOrdered, [modifiedObjectA, fauxObjectB, createdObjectD], {
+          isOptimistic: false
+        });
       });
     });
   });
   describe("layers", () => {
     it("properly remove", () => {
-      const store = new Store({});
+      const clientHelper = createClientMockHelper();
+      const store = new Store(clientHelper.client);
       const baseObjects = [1, 2].map(i => ({
         $primaryKey: i,
         $objectType: "Employee",
@@ -709,12 +1075,12 @@ describe(Store, () => {
 
       // set the truth
       for (const obj of baseObjects) {
-        store.updateObject("Employee", obj);
+        updateObject(store, obj);
       }
 
       // expect the truth
       for (const obj of baseObjects) {
-        expect(store.getObject("Employee", obj.$primaryKey)).toEqual(expect.objectContaining({
+        expect(getObject(store, "Employee", obj.$primaryKey)).toEqual(expect.objectContaining({
           $title: `truth ${obj.$primaryKey}`
         }));
       }
@@ -734,7 +1100,7 @@ describe(Store, () => {
 
       // expect the optimistic values
       for (let i = 0; i < 2; i++) {
-        expect(store.getObject("Employee", baseObjects[i].$primaryKey)).toEqual(expect.objectContaining({
+        expect(getObject(store, "Employee", baseObjects[i].$primaryKey)).toEqual(expect.objectContaining({
           $title: `optimistic ${baseObjects[i].$primaryKey}`
         }));
       }
@@ -743,10 +1109,10 @@ describe(Store, () => {
       store.removeLayer(layerIds[0]);
 
       // should have truth object 1 and optimistic object 2
-      expect(store.getObject("Employee", 1)).toEqual(expect.objectContaining({
+      expect(getObject(store, "Employee", 1)).toEqual(expect.objectContaining({
         $title: "truth 1"
       }));
-      expect(store.getObject("Employee", 2)).toEqual(expect.objectContaining({
+      expect(getObject(store, "Employee", 2)).toEqual(expect.objectContaining({
         $title: "optimistic 2"
       }));
 
@@ -755,7 +1121,7 @@ describe(Store, () => {
 
       // should have truth objects
       for (const obj of baseObjects) {
-        expect(store.getObject("Employee", obj.$primaryKey)).toEqual(expect.objectContaining({
+        expect(getObject(store, "Employee", obj.$primaryKey)).toEqual(expect.objectContaining({
           $title: `truth ${obj.$primaryKey}`
         }));
       }