@aerogel/plugin-local-first 0.0.0 → 0.1.0

package/src/jobs/Sync.test.ts

@@ -18,8 +18,11 @@ import {
 } from '@aerogel/plugin-local-first/testing/cloud';
 import Movie from '@aerogel/plugin-local-first/testing/stubs/Movie';
 import MoviesContainer from '@aerogel/plugin-local-first/testing/stubs/MoviesContainer';
+import Post from '@aerogel/plugin-local-first/testing/stubs/Post';
 import SolidMock from '@aerogel/plugin-local-first/testing/mocks/Solid.mock';
 import Workspace from '@aerogel/plugin-local-first/testing/stubs/Workspace';
+import Person from '@aerogel/plugin-local-first/testing/stubs/Person';
+import DocumentsCache from '@aerogel/plugin-local-first/services/DocumentsCache';
 
 describe('Sync', () => {
 
@@ -28,10 +31,8 @@ describe('Sync', () => {
     it('Syncs containers', async () => {
         // Arrange - Mint urls
         const parentContainerUrl = SolidMock.requireUser().storageUrls[0];
-        // fakeContainerUrl({ baseUrl: parentContainerUrl });
-        const remoteContainerUrl = parentContainerUrl + 'remote/';
-        // fakeContainerUrl({ baseUrl: parentContainerUrl });
-        const localContainerUrl = parentContainerUrl + 'local/';
+        const remoteContainerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
+        const localContainerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
 
         // Arrange - Prepare models
         await MoviesContainer.at(parentContainerUrl).create({
@@ -92,11 +93,13 @@ describe('Sync', () => {
         expect(containers).toHaveLength(2);
         expect(arrayFind(containers, 'name', 'Local Movies')).toBeInstanceOf(MoviesContainer);
         expect(arrayFind(containers, 'name', 'Remote Movies')).toBeInstanceOf(MoviesContainer);
+
+        expect(Cloud.localModelUpdates).toEqual({});
     });
 
     it('Syncs container documents', async () => {
         // Arrange - Mint urls
-        const parentContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'movies/';
         const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
         const localDocumentUrl = fakeDocumentUrl({ containerUrl });
         const remoteDocumentUrl = fakeDocumentUrl({ containerUrl });
@@ -148,6 +151,113 @@ describe('Sync', () => {
         expect(movies).toHaveLength(2);
         expect(arrayFind(movies, 'name', 'The Tale of Princess Kaguya')).toBeInstanceOf(Movie);
         expect(arrayFind(movies, 'name', 'Spirited Away')).toBeInstanceOf(Movie);
+
+        expect(Cloud.localModelUpdates).toEqual({});
+    });
+
+    it('Pushes container documents', async () => {
+        // Arrange - Mint urls
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'movies/';
+        const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
+        const localDocumentUrl = fakeDocumentUrl({ containerUrl });
+
+        // Arrange - Prepare models
+        const container = await MoviesContainer.at(parentContainerUrl).create({
+            url: containerUrl,
+            name: 'Remote Movies',
+        });
+
+        await container.relatedMovies.create({ url: `${localDocumentUrl}#it`, name: 'The Tale of Princess Kaguya' });
+
+        // Arrange - Prepare responses
+        const typeIndexUrl = SolidMock.requireUser().privateTypeIndexUrl ?? '';
+
+        FakeServer.respond(typeIndexUrl, typeIndexResponse({ [containerUrl]: '<https://schema.org/Movie>' }));
+        FakeServer.respond(
+            containerUrl,
+            containerResponse({
+                name: 'Remote Movies',
+                documentUrls: [],
+                createdAt: container.createdAt,
+                updatedAt: container.updatedAt,
+            }),
+        );
+        FakeServer.respondOnce(localDocumentUrl, FakeResponse.notFound()); // Check before create
+        FakeServer.respondOnce(localDocumentUrl, FakeResponse.created()); // Create
+
+        // Arrange - Prepare service
+        await Cloud.launch();
+        await Cloud.register(MoviesContainer);
+        await Events.emit('application-ready');
+
+        // Act
+        const updates: number[] = [];
+
+        await Cloud.sync({ onUpdated: (progress) => updates.push(progress) });
+
+        // Assert
+        expect(updates).toEqual([0, 0.9, 1]);
+        expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests(containerUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests(localDocumentUrl)).toHaveLength(2);
+        expect(FakeServer.getRequests()).toHaveLength(4);
+
+        const movies = await Movie.from(containerUrl).all();
+        expect(movies).toHaveLength(1);
+        expect(arrayFind(movies, 'name', 'The Tale of Princess Kaguya')).toBeInstanceOf(Movie);
+
+        expect(Cloud.localModelUpdates).toEqual({});
+    });
+
+    it('Pulls container documents', async () => {
+        // Arrange - Mint urls
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'movies/';
+        const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
+        const remoteDocumentUrl = fakeDocumentUrl({ containerUrl });
+
+        // Arrange - Prepare models
+        const container = await MoviesContainer.at(parentContainerUrl).create({
+            url: containerUrl,
+            name: 'Remote Movies',
+        });
+
+        // Arrange - Prepare responses
+        const typeIndexUrl = SolidMock.requireUser().privateTypeIndexUrl ?? '';
+
+        FakeServer.respond(typeIndexUrl, typeIndexResponse({ [containerUrl]: '<https://schema.org/Movie>' }));
+        FakeServer.respond(
+            containerUrl,
+            containerResponse({
+                name: 'Remote Movies',
+                documentUrls: [remoteDocumentUrl],
+                createdAt: container.createdAt,
+                updatedAt: container.updatedAt,
+            }),
+        );
+        FakeServer.respond(remoteDocumentUrl, movieResponse('Spirited Away'));
+
+        // Arrange - Prepare service
+        await Cloud.launch();
+        await Cloud.register(MoviesContainer);
+        await Events.emit('application-ready');
+
+        // Act
+        const updates: number[] = [];
+
+        await Cloud.sync({ onUpdated: (progress) => updates.push(progress) });
+
+        // Assert
+        expect(updates).toEqual([0, 0.9, 1]);
+        expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests(containerUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests(remoteDocumentUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests()).toHaveLength(3);
+
+        const movies = await Movie.from(containerUrl).all();
+        expect(movies).toHaveLength(1);
+        expect(arrayFind(movies, 'name', 'Spirited Away')).toBeInstanceOf(Movie);
+
+        expect(Cloud.localModelUpdates).toEqual({});
     });
 
     it('Syncs documents', async () => {
@@ -195,11 +305,13 @@ describe('Sync', () => {
         expect(movies).toHaveLength(2);
         expect(arrayFind(movies, 'name', 'The Tale of Princess Kaguya')).toBeInstanceOf(Movie);
         expect(arrayFind(movies, 'name', 'Spirited Away')).toBeInstanceOf(Movie);
+
+        expect(Cloud.localModelUpdates).toEqual({});
     });
 
     it('Syncs individual container updates', async () => {
         // Arrange - Mint urls
-        const parentContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'movies/';
         const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
         const movieDocumentUrl = fakeDocumentUrl({ containerUrl });
 
@@ -311,6 +423,8 @@ describe('Sync', () => {
                     crdt:value "Great Movies" .
             } .
         `);
+
+        expect(Cloud.localModelUpdates).toEqual({});
     });
 
     it('Syncs individual container documents', async () => {
@@ -347,11 +461,13 @@ describe('Sync', () => {
 
         expect(FakeServer.getRequests(documentUrl)).toHaveLength(4);
         expect(FakeServer.getRequests()).toHaveLength(4);
+
+        expect(Cloud.localModelUpdates).toEqual({});
     });
 
     it('Creates containers with documents', async () => {
         // Arrange - Mint urls
-        const parentContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'movies/';
         const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
         const documentUrl = fakeDocumentUrl({ containerUrl });
 
@@ -401,11 +517,13 @@ describe('Sync', () => {
         expect(FakeServer.getRequests(`${containerUrl}.meta`)).toHaveLength(1);
         expect(FakeServer.getRequests(documentUrl)).toHaveLength(2);
         expect(FakeServer.getRequests()).toHaveLength(10);
+
+        expect(Cloud.localModelUpdates).toEqual({});
     });
 
     it('Skips pulling fresh documents', async () => {
         // Arrange - Mint urls
-        const parentContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'tasks/';
         const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
         const childContainerUrl = fakeContainerUrl({ baseUrl: containerUrl });
         const freshDocumentUrl = fakeDocumentUrl({ containerUrl });
@@ -447,16 +565,18 @@ describe('Sync', () => {
         // Arrange - Prepare responses
         const now = Date.now();
         const typeIndexUrl = SolidMock.requireUser().privateTypeIndexUrl ?? '';
-        const typeIndexTurtle = `
+
+        FakeServer.respond(
+            typeIndexUrl,
+            `
             <${typeIndexUrl}> a <http://www.w3.org/ns/solid/terms#TypeIndex> .
 
             <#tasks>
                 a <http://www.w3.org/ns/solid/terms#TypeRegistration> ;
                 <http://www.w3.org/ns/solid/terms#forClass> <https://schema.org/Action> ;
                 <http://www.w3.org/ns/solid/terms#instanceContainer> <${containerUrl}> .
-        `;
-
-        FakeServer.respondOnce(typeIndexUrl, FakeResponse.success(typeIndexTurtle)); // Initial fetch
+        `,
+        );
         FakeServer.respondOnce(
             containerUrl,
             containerResponse({
@@ -559,19 +679,19 @@ describe('Sync', () => {
         await Cloud.sync();
 
         // Assert
-        expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(2);
         expect(FakeServer.getRequests(containerUrl)).toHaveLength(2);
         expect(FakeServer.getRequests(childContainerUrl)).toHaveLength(2);
         expect(FakeServer.getRequests(freshDocumentUrl)).toHaveLength(1);
         expect(FakeServer.getRequests(staleDocumentUrl)).toHaveLength(2);
         expect(FakeServer.getRequests(freshChildDocumentUrl)).toHaveLength(1);
         expect(FakeServer.getRequests(staleChildDocumentUrl)).toHaveLength(2);
-        expect(FakeServer.getRequests()).toHaveLength(11);
+        expect(FakeServer.getRequests()).toHaveLength(12);
     });
 
     it('Ignores missing children', async () => {
         // Arrange - Mint urls
-        const parentContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'tasks/';
         const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
         const existingChildDocumentUrl = fakeContainerUrl({ baseUrl: containerUrl });
         const notFoundChildDocumentUrl = fakeDocumentUrl({ containerUrl });
@@ -629,7 +749,7 @@ describe('Sync', () => {
 
     it('Ignores malformed documents', async () => {
         // Arrange - Mint urls
-        const parentContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'movies/';
         const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
         const firstDocumentUrl = fakeDocumentUrl({ containerUrl: containerUrl });
         const secondDocumentUrl = fakeDocumentUrl({ containerUrl: containerUrl });
@@ -692,7 +812,7 @@ describe('Sync', () => {
 
     it('Ignores malformed documents in individual syncs', async () => {
         // Arrange - Mint urls
-        const parentContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'movies/';
         const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
         const documentUrl = fakeDocumentUrl({ containerUrl: containerUrl });
 
@@ -725,9 +845,155 @@ describe('Sync', () => {
         expect(Cloud.localModelUpdates).toEqual({ [movie.url]: 1 });
     });
 
+    it('Syncs nested fresh containers', async () => {
+        // Arrange - Mint urls
+        const rootContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = fakeContainerUrl({ baseUrl: rootContainerUrl });
+        const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
+        const documentUrl = fakeDocumentUrl({ containerUrl });
+
+        // Arrange - Prepare models
+        const parentContainer = await Workspace.at(rootContainerUrl).create({
+            url: parentContainerUrl,
+            name: 'Tasks',
+        });
+        const container = await parentContainer.relatedLists.create({
+            url: containerUrl,
+            name: 'More Tasks',
+        });
+        const task = await container.relatedTasks.create({ url: `${documentUrl}#it`, name: 'Sync' });
+
+        // Arrange - Prepare responses
+        const typeIndexUrl = SolidMock.requireUser().privateTypeIndexUrl ?? '';
+        const now = Date.now();
+
+        FakeServer.respond(typeIndexUrl, typeIndexResponse({ [parentContainerUrl]: '<https://schema.org/Action>' }));
+        FakeServer.respond(parentContainerUrl, containerResponse({ name: 'Tasks', documentUrls: [containerUrl] }));
+        FakeServer.respond(
+            containerUrl,
+            containerResponse({
+                name: 'More Tasks',
+                documentUrls: [documentUrl],
+                append: `
+                <${documentUrl}>
+                    a <http://www.w3.org/ns/iana/media-types/text/turtle#Resource> ;
+                    <http://purl.org/dc/terms/modified>
+                        "${new Date(now).toISOString()}"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
+            `,
+            }),
+        );
+        FakeServer.respond(documentUrl, await task.toTurtle());
+        FakeServer.respond(`${parentContainerUrl}.meta`);
+        FakeServer.respond(`${containerUrl}.meta`);
+
+        // Arrange - Prepare service
+        await DocumentsCache.remember(documentUrl, now);
+        await Cloud.launch();
+        await Cloud.register(Workspace);
+        await Events.emit('application-ready');
+
+        // Act
+        await Cloud.sync();
+
+        // Assert
+        expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests(parentContainerUrl)).toHaveLength(2);
+        expect(FakeServer.getRequests(containerUrl)).toHaveLength(2);
+        expect(FakeServer.getRequests(`${parentContainerUrl}.meta`)).toHaveLength(1);
+        expect(FakeServer.getRequests(`${containerUrl}.meta`)).toHaveLength(1);
+        expect(FakeServer.getRequests()).toHaveLength(7);
+
+        expect(Cloud.localModelUpdates).toEqual({});
+    });
+
+    it('Ignores nested container registrations', async () => {
+        // Arrange - Mint urls
+        const rootContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = fakeContainerUrl({ baseUrl: rootContainerUrl });
+        const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
+        const parentDocumentUrl = fakeDocumentUrl({ containerUrl: parentContainerUrl });
+        const documentUrl = fakeDocumentUrl({ containerUrl });
+
+        // Arrange - Prepare responses
+        const typeIndexUrl = SolidMock.requireUser().privateTypeIndexUrl ?? '';
+
+        FakeServer.respond(
+            typeIndexUrl,
+            typeIndexResponse({
+                [parentContainerUrl]: '<https://schema.org/Movie>',
+                [containerUrl]: '<https://schema.org/Movie>',
+            }),
+        );
+        FakeServer.respond(parentContainerUrl, containerResponse({ documentUrls: [containerUrl, parentDocumentUrl] }));
+        FakeServer.respond(containerUrl, containerResponse({ documentUrls: [documentUrl] }));
+        FakeServer.respond(parentDocumentUrl, movieResponse());
+
+        // Arrange - Prepare service
+        await Cloud.launch();
+        await Cloud.register(MoviesContainer);
+        await Events.emit('application-ready');
+
+        // Act
+        await Cloud.sync();
+
+        // Assert
+        expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests(parentContainerUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests(containerUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests(parentDocumentUrl)).toHaveLength(1);
+        expect(FakeServer.getRequests()).toHaveLength(4);
+    });
+
+    it('Works with circular relationships', async () => {
+        // Arrange
+        const typeIndexUrl = SolidMock.requireUser().privateTypeIndexUrl ?? '';
+        const containerUrl = fakeContainerUrl();
+        const documentUrl = fakeDocumentUrl({ containerUrl });
+        const typeIndexTurtle = `
+            <${typeIndexUrl}> a <http://www.w3.org/ns/solid/terms#TypeIndex> .
+
+            <#posts>
+                a <http://www.w3.org/ns/solid/terms#TypeRegistration> ;
+                <http://www.w3.org/ns/solid/terms#forClass> <https://schema.org/Article> ;
+                <http://www.w3.org/ns/solid/terms#instanceContainer> <${containerUrl}> .
+        `;
+
+        FakeServer.respondOnce(typeIndexUrl, FakeResponse.success(typeIndexTurtle));
+        FakeServer.respondOnce(containerUrl, containerResponse({ documentUrls: [documentUrl] }));
+        FakeServer.respondOnce(
+            documentUrl,
+            `
+                <#it>
+                    a <https://schema.org/Article> ;
+                    <https://schema.org/name> "Title" ;
+                    <https://schema.org/author> <#author> .
+
+                <#author>
+                    a <https://schema.org/Person> ;
+                    <https://schema.org/name> "Author" .
+            `,
+        );
+
+        Cloud.ready = true;
+
+        await Cloud.launch();
+        await Cloud.register(Post);
+        await Events.emit('application-ready');
+
+        // Act
+        await Cloud.sync();
+
+        // Assert
+        const [post] = await Post.all();
+
+        expect(post).toBeInstanceOf(Post);
+        expect(post?.author).toBeInstanceOf(Person);
+        expect(post?.author?.posts?.[0]).toBe(post);
+    });
+
     testRegisterVariants('Leaves tombstones behind', async (registerModels) => {
         // Arrange - Mint urls
-        const parentContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'movies/';
         const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
         const documentUrl = fakeDocumentUrl({ containerUrl });
 
@@ -783,14 +1049,16 @@ describe('Sync', () => {
                     crdt:deletedAt  "[[.*]]"^^xsd:dateTime .
             } .
         `);
+
+        expect(Cloud.localModelUpdates).toEqual({});
     });
 
     testRegisterVariants('Deletes tombstone models', async (registerModels, variant) => {
         const usingContainers = variant === 'container registration';
 
         // Arrange - Mint urls
-        const parentContainerUrl = Solid.requireUser().storageUrls[0];
-        const containerUrl = parentContainerUrl + 'delete/'; //fakeContainerUrl({ baseUrl: parentContainerUrl });
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'movies/';
+        const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
         const documentUrl = fakeDocumentUrl({ containerUrl });
 
         // Arrange - Prepare models
@@ -816,12 +1084,17 @@ describe('Sync', () => {
                 FakeResponse.success('<> a <http://www.w3.org/ns/ldp#Container> .'),
             );
             FakeServer.respondOnce(`${containerUrl}.meta`, FakeResponse.success()); // Update meta
-            FakeServer.respondOnce(typeIndexUrl, typeIndexResponse()); // Check before update
-            FakeServer.respondOnce(typeIndexUrl, FakeResponse.success()); // Update
         } else {
             FakeServer.respondOnce(documentUrl, FakeResponse.notFound()); // Tombstone check
         }
 
+        FakeServer.respondOnce(typeIndexUrl, typeIndexResponse()); // Check before update
+        FakeServer.respondOnce(typeIndexUrl, FakeResponse.success()); // Update
+        FakeServer.respondOnce(
+            typeIndexUrl,
+            typeIndexResponse({ [containerUrl]: '<https://schema.org/Movie>' }), // Second sync
+        );
+
         FakeServer.respondOnce(documentUrl, FakeResponse.notFound()); // Existence check
         FakeServer.respondOnce(documentUrl, FakeResponse.success()); // Create
 
@@ -854,9 +1127,6 @@ describe('Sync', () => {
 
         // Assert
         const freshMovie = await Movie.at(containerUrl).find(movie.url);
-        const cloud = Cloud;
-
-        cloud;
 
         expect(freshMovie).toBeNull();
 
@@ -868,23 +1138,26 @@ describe('Sync', () => {
             expect(freshContainer.movies).toHaveLength(0);
             expect(freshContainer.resourceUrls).toHaveLength(1);
 
-            expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(3);
+            expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(4);
             expect(FakeServer.getRequests(containerUrl)).toHaveLength(5);
             expect(FakeServer.getRequests(documentUrl)).toHaveLength(3);
             expect(FakeServer.getRequests(`${containerUrl}.meta`)).toHaveLength(1);
-            expect(FakeServer.getRequests()).toHaveLength(12);
+            expect(FakeServer.getRequests()).toHaveLength(13);
         } else {
-            expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(1);
-            expect(FakeServer.getRequests(documentUrl)).toHaveLength(4);
-            expect(FakeServer.getRequests()).toHaveLength(5);
+            expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(4);
+            expect(FakeServer.getRequests(containerUrl)).toHaveLength(1);
+            expect(FakeServer.getRequests(documentUrl)).toHaveLength(5);
+            expect(FakeServer.getRequests()).toHaveLength(10);
         }
+
+        expect(Cloud.localModelUpdates).toEqual({});
     });
 
     testRegisterVariants('Deletes updated tombstone models', async (registerModels, variant) => {
         const usingContainers = variant === 'container registration';
 
         // Arrange - Mint urls
-        const parentContainerUrl = Solid.requireUser().storageUrls[0];
+        const parentContainerUrl = Solid.requireUser().storageUrls[0] + 'movies/';
         const containerUrl = fakeContainerUrl({ baseUrl: parentContainerUrl });
         const documentUrl = fakeDocumentUrl({ containerUrl });
 
@@ -911,12 +1184,13 @@ describe('Sync', () => {
                 FakeResponse.success('<> a <http://www.w3.org/ns/ldp#Container> .'),
             );
             FakeServer.respondOnce(`${containerUrl}.meta`, FakeResponse.success()); // Update meta
-            FakeServer.respondOnce(typeIndexUrl, typeIndexResponse()); // Check before update
-            FakeServer.respondOnce(typeIndexUrl, FakeResponse.success()); // Update
         } else {
             FakeServer.respondOnce(documentUrl, FakeResponse.notFound()); // Tombstone check
         }
 
+        FakeServer.respondOnce(typeIndexUrl, typeIndexResponse()); // Check before update
+        FakeServer.respondOnce(typeIndexUrl, FakeResponse.success()); // Update
+
         FakeServer.respondOnce(documentUrl, FakeResponse.notFound()); // Existence check
         FakeServer.respondOnce(documentUrl, FakeResponse.success()); // Create
 
@@ -958,10 +1232,12 @@ describe('Sync', () => {
             expect(FakeServer.getRequests(`${containerUrl}.meta`)).toHaveLength(1);
             expect(FakeServer.getRequests()).toHaveLength(12);
         } else {
-            expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(1);
+            expect(FakeServer.getRequests(typeIndexUrl)).toHaveLength(3);
             expect(FakeServer.getRequests(documentUrl)).toHaveLength(5);
-            expect(FakeServer.getRequests()).toHaveLength(6);
+            expect(FakeServer.getRequests()).toHaveLength(8);
         }
+
+        expect(Cloud.localModelUpdates).toEqual({});
     });
 
     testRegisterVariants('Tracks model updates', async (registerModels) => {
@@ -971,6 +1247,8 @@ describe('Sync', () => {
 
         await registerModels();
 
+        Cloud.ready = true;
+
         // Act
         await movie.update({ releaseDate: new Date('2023-07-14') });
         await container.relatedMovies.create({ name: 'The Tale of Princess Kaguya' });