Update partial OBJECT_SYNC test to provoke the server to send an actual partial sync instead of injecting fake messages

Resolves AIT-538

Author: VeskeR

test/realtime/liveobjects.test.js

@@ -896,80 +896,63 @@ define(['ably', 'shared_helper', 'chai', 'liveobjects', 'liveobjects_helper'], f
         {
           description: 'partial OBJECT_SYNC merges map entries across multiple messages for the same objectId',
           action: async (ctx) => {
-            const { channel, objectsHelper, entryPathObject } = ctx;
+            const { helper, channel, client, entryInstance, realtimeObject } = ctx;
 
-            const mapId = objectsHelper.fakeMapObjectId();
+            helper.recordPrivateApi('read.realtime.options.maxMessageSize');
+            const maxMessageSize = client.options.maxMessageSize;
 
-            // assign map object to root
-            await objectsHelper.processObjectStateMessageOnChannel({
-              channel,
-              syncSerial: 'serial:cursor1',
-              state: [
-                objectsHelper.mapObject({
-                  objectId: 'root',
-                  siteTimeserials: { aaa: lexicoTimeserial('aaa', 0, 0) },
-                  initialEntries: {
-                    map: { timeserial: lexicoTimeserial('aaa', 0, 0), data: { objectId: mapId } },
-                  },
-                }),
-              ],
-            });
+            // create 3 keys on root, each with a string value nearly maxMessageSize in length.
+            // this ensures the server must split the sync across multiple OBJECT_SYNC messages
+            // since each key alone nearly fills a single message.
+            const keyNames = ['largeKey1', 'largeKey2', 'largeKey3'];
+            // map set op size = key length + data string length, so this reaches exactly maxMessageSize
+            const largeValue = 'x'.repeat(maxMessageSize - keyNames[0].length);
 
-            // send partial sync messages for the same map object, each with different materialised entries.
-            // initialEntries are identical across all partial messages for the same object - a server guarantee.
-            const partialMessages = [
-              {
-                syncSerial: 'serial:cursor2',
-                materialisedEntries: {
-                  key1: { timeserial: lexicoTimeserial('aaa', 0, 0), data: { number: 1 } },
-                  key2: { timeserial: lexicoTimeserial('aaa', 0, 0), data: { string: 'two' } },
-                },
-              },
-              {
-                syncSerial: 'serial:cursor3',
-                materialisedEntries: {
-                  key3: { timeserial: lexicoTimeserial('aaa', 0, 0), data: { number: 3 } },
-                  key4: { timeserial: lexicoTimeserial('aaa', 0, 0), data: { boolean: true } },
-                },
-              },
-              {
-                syncSerial: 'serial:', // end sync sequence
-                materialisedEntries: {
-                  key5: { timeserial: lexicoTimeserial('aaa', 0, 0), data: { string: 'five' } },
-                },
-              },
-            ];
+            for (const key of keyNames) {
+              await entryInstance.set(key, largeValue);
+            }
 
-            for (const partial of partialMessages) {
-              await objectsHelper.processObjectStateMessageOnChannel({
-                channel,
-                syncSerial: partial.syncSerial,
-                state: [
-                  objectsHelper.mapObject({
-                    objectId: mapId,
-                    siteTimeserials: { aaa: lexicoTimeserial('aaa', 0, 0) },
-                    initialEntries: {
-                      initialKey: { timeserial: lexicoTimeserial('aaa', 0, 0), data: { string: 'initial' } },
-                    },
-                    materialisedEntries: partial.materialisedEntries,
-                  }),
-                ],
-              });
+            // verify keys were set before detach
+            for (const key of keyNames) {
+              expect(entryInstance.get(key).value()).to.equal(largeValue, `Check ${key} was set before detach`);
             }
 
-            const map = entryPathObject.get('map');
+            await channel.detach();
+
+            // intercept transport to count OBJECT_SYNC messages received after reattach
+            let objectSyncMessageCount = 0;
+            helper.recordPrivateApi('call.connectionManager.activeProtocol.getTransport');
+            const transport = client.connection.connectionManager.activeProtocol.getTransport();
+            const onProtocolMessageOriginal = transport.onProtocolMessage;
+
+            helper.recordPrivateApi('replace.transport.onProtocolMessage');
+            transport.onProtocolMessage = function (message) {
+              if (message.action === 20) {
+                objectSyncMessageCount++;
+              }
+              helper.recordPrivateApi('call.transport.onProtocolMessage');
+              onProtocolMessageOriginal.call(transport, message);
+            };
 
-            expect(map.get('initialKey').value()).to.equal(
-              'initial',
-              'Check keys from the create operation are present',
+            // reattach and wait for the new sync sequence to complete
+            const syncedPromise = new Promise((resolve) => realtimeObject.on('synced', resolve));
+            await channel.attach();
+            await syncedPromise;
+
+            // verify the server sent multiple OBJECT_SYNC messages due to the partial sync, one for each large key
+            expect(objectSyncMessageCount).to.be.at.least(
+              3,
+              'Check that multiple OBJECT_SYNC messages were received (partial sync)',
             );
 
-            // check that materialised entries from all partial messages were merged
-            expect(map.get('key1').value()).to.equal(1, 'Check key1 from first partial sync');
-            expect(map.get('key2').value()).to.equal('two', 'Check key2 from first partial sync');
-            expect(map.get('key3').value()).to.equal(3, 'Check key3 from second partial sync');
-            expect(map.get('key4').value()).to.equal(true, 'Check key4 from second partial sync');
-            expect(map.get('key5').value()).to.equal('five', 'Check key5 from third partial sync');
+            // verify all keys were synced correctly
+            const newEntryPathObject = await channel.object.get();
+            for (const key of keyNames) {
+              expect(newEntryPathObject.get(key).value()).to.equal(
+                largeValue,
+                `Check ${key} was synced correctly after partial OBJECT_SYNC`,
+              );
+            }
           },
         },