@osdk/client 2.1.1 → 2.2.0-beta.10

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 { createOffice, Employee, FooInterface, Todo } from "@osdk/client.test.ontology";
+import { wireObjectTypeFullMetadataToSdkObjectMetadata } from "@osdk/generator-converters";
+import { LegacyFauxFoundry, startNodeApiServer, stubData } from "@osdk/shared.test";
+import chalk from "chalk";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi, vitest } from "vitest";
 import { createClient } from "../../createClient.js";
+import { createMinimalClient } from "../../createMinimalClient.js";
+import { createObjectSet } from "../../objectSet/createObjectSet.js";
+import { InterfaceDefinitions } from "../../ontology/OntologyProvider.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, createTestLogger, expectNoMoreCalls, expectSingleListCallAndClear, expectSingleObjectCallAndClear, getObject, mockListSubCallback, mockSingleSubCallback, objectPayloadContaining, updateList, updateObject, waitForCall } from "./testUtils.js";
 const defer = createDefer();
+const logger = createTestLogger({});
 beforeAll(() => {
   vi.setConfig({
     fakeTimers: {
@@ -38,6 +45,19 @@ 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();
 describe(Store, () => {
   describe("with mock server", () => {
@@ -46,44 +66,49 @@ describe(Store, () => {
     let employeesAsServerReturns;
     let mutatedEmployees;
     beforeAll(async () => {
-      apiServer.listen();
-      client = createClient("https://stack.palantir.com", $ontologyRid, async () => "myAccessToken");
+      const testSetup = startNodeApiServer(new LegacyFauxFoundry(), createClient, {
+        logger
+      });
+      ({
+        client
+      } = testSetup);
       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 +117,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 +131,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 +144,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 +236,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 +264,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,47 +315,53 @@ 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,
@@ -341,42 +371,36 @@ describe(Store, () => {
         defer(cache.observeObject(Employee, 50030, {
           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();
+        const firstLoad = subFn1.next.mock.lastCall?.[0];
+        subFn1.next.mockClear();
         defer(cache.observeObject(Employee, 50030, {
           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 +408,185 @@ describe(Store, () => {
       const subFn = mockSingleSubCallback();
       let sub;
       beforeEach(() => {
-        subFn.mockClear();
+        subFn.complete.mockClear();
+        subFn.next.mockClear();
+        subFn.error.mockClear();
         sub = defer(cache.observeObject(Employee, 50030, {
           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];
 
         // 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];
 
         // 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 +599,125 @@ 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 store;
     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 error = new Error("A faux error");
+      mockClient.mockFetchPageOnce().reject(error);
+      const sub = mockListSubCallback();
+      store.observeList({
+        type: Employee,
+        where: {},
+        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 () => {
+        mockClient.mockFetchPageOnce().resolve({
+          data: [{
+            $apiName: "Employee",
+            $objectType: "Employee",
+            $primaryKey: 0
+          }, {
+            $apiName: "Employee",
+            $objectType: "Employee",
+            $primaryKey: 1
+          }],
+          nextPageToken: undefined,
+          totalCount: "2"
+        });
+        vi.mocked(client.fetchMetadata).mockReturnValue(Promise.resolve({
+          primaryKeyApiName: "id"
+        }));
+        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
+            })
+          })
+        });
+        console.log(client.mock.calls);
+      });
     });
     describe("actions", () => {
+      beforeEach(() => {
+        vi.mocked(client.fetchMetadata).mockReturnValue(Promise.resolve({
+          primaryKeyApiName: "id"
+        }));
+      });
       it("properly invalidates objects", async () => {
         // after the below `observeObject`, the cache will need to load from the server
-        mockClient.mockFetchOneOnce().resolve({
-          $apiName: "Todo"
+        // (also the batch loader uses object set to load not fetchOne)
+        mockClient.mockFetchPageOnce().resolve({
+          data: [{
+            $apiName: "Todo",
+            $primaryKey: 0
+          }],
+          nextPageToken: undefined,
+          totalCount: "1"
         });
         const todoSubFn = mockSingleSubCallback();
-        defer(cache.observeObject(Todo, 0, {}, todoSubFn));
+        defer(store.observeObject(Todo, 0, {}, todoSubFn));
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading",
@@ -614,15 +739,18 @@ describe(Store, () => {
         });
 
         // after we apply the action, the object is invalidated and gets re-requested
-
-        mockClient.mockFetchOneOnce().resolve({
-          $apiName: "Todo",
-          text: "hello there kind sir"
+        mockClient.mockFetchPageOnce().resolve({
+          data: [{
+            $primaryKey: 0,
+            $apiName: "Todo",
+            text: "hello there kind sir"
+          }],
+          nextPageToken: undefined,
+          totalCount: "1"
         });
-        const actionPromise = cache.applyAction(createOffice, {
+        await store.applyAction(createOffice, {
           officeId: "whatever"
         });
-        await actionPromise;
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading"
@@ -643,9 +771,13 @@ describe(Store, () => {
         };
 
         // after the below `observeObject`, the cache will need to load from the server
-        mockClient.mockFetchOneOnce().resolve(fauxObject);
+        mockClient.mockFetchPageOnce().resolve({
+          data: [fauxObject],
+          nextPageToken: undefined,
+          totalCount: "1"
+        });
         const todoSubFn = mockSingleSubCallback();
-        defer(cache.observeObject(Todo, 0, {}, todoSubFn));
+        defer(store.observeObject(Todo, 0, {}, todoSubFn));
         await todoSubFn.expectLoadingAndLoaded({
           loading: objectPayloadContaining({
             status: "loading",
@@ -661,26 +793,26 @@ describe(Store, () => {
 
         // at this point we have an observation properly set up
         const applyActionResult = mockClient.mockApplyActionOnce();
-        const actionPromise = cache.applyAction(createOffice, {
+        const actionPromise = store.applyAction(createOffice, {
           officeId: "whatever"
         }, {
           optimisticUpdate: ctx => {
             ctx.updateObject({
               ...fauxObject,
-              someValue: "optimistic"
+              text: "optimistic"
             });
           }
         });
         await waitForCall(todoSubFn, 1);
-        expect(todoSubFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
+        expect(todoSubFn.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
           object: {
             ...fauxObject,
-            someValue: "optimistic"
+            text: "optimistic"
           },
           status: "loading",
           isOptimistic: true
         }));
-        todoSubFn.mockClear();
+        todoSubFn.next.mockClear();
 
         // let the action error out
         applyActionResult.reject("an error thrown");
@@ -688,17 +820,294 @@ describe(Store, () => {
 
         // back to the original object
         await waitForCall(todoSubFn, 1);
-        expect(todoSubFn).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
+        expect(todoSubFn.next).toHaveBeenCalledExactlyOnceWith(objectPayloadContaining({
           object: fauxObject,
           status: "loaded",
           isOptimistic: false
         }));
       });
     });
+    describe("orderBy", async () => {
+      const ontologyProvider = {
+        getObjectDefinition: async () => {
+          return {
+            ...wireObjectTypeFullMetadataToSdkObjectMetadata(stubData.todoWithLinkTypes, true),
+            [InterfaceDefinitions]: {}
+          };
+        },
+        getActionDefinition() {
+          throw new Error("not implemented");
+        },
+        getInterfaceDefinition() {
+          throw new Error("not implemented");
+        },
+        getQueryDefinition() {
+          throw new Error("not implemented");
+        }
+      };
+      const minimalClient = createMinimalClient({
+        ontologyRid: "ri.whatever"
+      }, "https://localhost:8080", () => Promise.resolve("token"), {
+        logger
+      }, fetch, createObjectSet, () => () => ontologyProvider);
+      async function createObject(type, x) {
+        return (await minimalClient.objectFactory2(minimalClient, [{
+          ...x,
+          $apiName: type.apiName,
+          $objectType: type.apiName,
+          $objectSpecifier: `${type.apiName}:${x.$primaryKey}`
+        }], undefined))[0];
+      }
+      let nextPk = 0;
+      const fauxObjectA = await createObject(Todo, {
+        $primaryKey: nextPk,
+        $title: "a",
+        id: nextPk,
+        text: "a"
+      });
+      nextPk++;
+      const fauxObjectB = await createObject(Todo, {
+        $primaryKey: nextPk,
+        $title: "b",
+        id: nextPk,
+        text: "b"
+      });
+      nextPk++;
+      const fauxObjectC = await createObject(Todo, {
+        $primaryKey: nextPk,
+        $title: "c",
+        id: nextPk,
+        text: "c"
+      });
+      const noWhereNoOrderBy = {
+        type: Todo,
+        where: {},
+        orderBy: {}
+      };
+      const noWhereOrderByText = {
+        type: Todo,
+        where: {},
+        orderBy: {
+          text: "asc"
+        }
+      };
+      const subListUnordered = mockListSubCallback();
+      const subListOrdered = mockListSubCallback();
+      beforeEach(() => {
+        vi.mocked(client.fetchMetadata).mockReturnValue(Promise.resolve({
+          primaryKeyApiName: "id"
+        }));
+      });
+      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]);
+
+        // 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]);
+
+        // 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 = await createObject(Todo, {
+          ...fauxObjectA,
+          text: "optimistic"
+        });
+        const pkForOptimistic = nextPk++;
+        const optimisticallyCreatedObjectD = await createObject(Todo, {
+          "$primaryKey": pkForOptimistic,
+          "$title": "d",
+          "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");
+
+        // the optimistic job will call createObject which triggers the `objectFactory2` of the
+        // cache context.
+        mockClient.mockObjectFactory2Once().resolve([optimisticallyCreatedObjectD]);
+
+        // 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 = await createObject(Todo, {
+          "$primaryKey": pkForOptimistic,
+          "$title": "d",
+          "text": "d",
+          id: pkForOptimistic
+        });
+        const optimisticallyMutatedA = await createObject(Todo, {
+          ...fauxObjectA,
+          text: "optimistic"
+        });
+        testStage("Initial Setup");
+
+        // later we will "create" this object
+        const createdObjectD = await createObject(Todo, {
+          "$primaryKey": 9000,
+          "$title": "d prime",
+          "text": "d prime",
+          id: 9000
+        });
+
+        // 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");
+
+        // the optimistic job will call createObject which triggers the `objectFactory2` of the
+        // cache context.
+
+        mockClient.mockObjectFactory2Once().resolve([optimisticallyCreatedObjectD]);
+        const mockedApplyAction = mockClient.mockApplyActionOnce();
+        testStage("Apply Action");
+        const actionPromise = store.applyAction(createOffice, {
+          officeId: "5"
+        }, {
+          optimisticUpdate: b => {
+            b.createObject(Todo, optimisticallyCreatedObjectD.$primaryKey, {
+              id: optimisticallyCreatedObjectD.$primaryKey,
+              text: "d"
+            });
+            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 = await createObject(Todo, {
+          ...fauxObjectA,
+          text: "a prime"
+        });
+
+        // The action will complete and then revalidate in order...
+        mockClient.mockFetchPageOnce().resolve({
+          data: [modifiedObjectA, createdObjectD],
+          nextPageToken: undefined,
+          totalCount: "1"
+        });
+        mockedApplyAction.resolve({
+          addedObjects: [{
+            objectType: "Todo",
+            primaryKey: createdObjectD.id
+          }],
+          modifiedObjects: [{
+            objectType: "Todo",
+            primaryKey: fauxObjectA.$primaryKey
+          }]
+        });
+        await actionPromise;
+        await waitForCall(subListUnordered, 1);
+        console.log("=====", subListUnordered.next.mock.calls[0][0]);
+        expectSingleListCallAndClear(subListUnordered, [fauxObjectB,
+        // fauxObjectC,
+        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 +1118,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 +1143,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 +1152,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 +1164,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}`
         }));
       }