@fluid-experimental/tree 1.3.3 → 1.3.4

package/lib/test/IdCompressor.tests.js

@@ -350,6 +350,22 @@ describe('IdCompressor', () => {
             const secondRange = compressor.takeNextCreationRange();
             expect(() => compressor.finalizeCreationRange(secondRange)).to.throw('Ranges finalized out of order.');
         });
+        it('can finalize ranges into clusters of varying sizes', () => {
+            for (let i = 1; i < 5; i++) {
+                for (let j = 0; j <= i; j++) {
+                    const compressor = createCompressor(Client.Client1, i);
+                    const ids = new Set();
+                    for (let k = 0; k <= j; k++) {
+                        ids.add(compressor.generateCompressedId());
+                    }
+                    compressor.finalizeCreationRange(compressor.takeNextCreationRange());
+                    const opIds = new Set();
+                    ids.forEach((id) => opIds.add(compressor.normalizeToOpSpace(id)));
+                    expect(ids.size).to.equal(opIds.size);
+                    opIds.forEach((id) => expect(isFinalId(id)).to.be.true);
+                }
+            }
+        });
         it('prevents finalizing unacceptably enormous amounts of ID allocation', () => {
             const compressor1 = createCompressor(Client.Client1);
             const integerLargerThanHalfMax = Math.round((Number.MAX_SAFE_INTEGER / 3) * 2);
@@ -568,6 +584,198 @@ describe('IdCompressor', () => {
             expect(normalizedToClient1SessionSpace).to.equal(id);
         });
     });
+    describe('Eager final ID allocation', () => {
+        it('eagerly allocates final IDs when cluster creation has been finalized', () => {
+            const compressor = createCompressor(Client.Client1, 5);
+            const localId1 = compressor.generateCompressedId();
+            expect(isLocalId(localId1)).to.be.true;
+            const localId2 = compressor.generateCompressedId();
+            expect(isLocalId(localId2)).to.be.true;
+            compressor.finalizeCreationRange(compressor.takeNextCreationRange());
+            const finalId3 = compressor.generateCompressedId();
+            expect(isFinalId(finalId3)).to.be.true;
+            const finalId4 = compressor.generateCompressedId();
+            expect(isFinalId(finalId4)).to.be.true;
+            const finalId5 = compressor.generateCompressedId();
+            expect(isFinalId(finalId5)).to.be.true;
+            const localId6 = compressor.generateCompressedId();
+            expect(isLocalId(localId6)).to.be.true;
+            compressor.finalizeCreationRange(compressor.takeNextCreationRange());
+            const opSpaceId1 = compressor.normalizeToOpSpace(localId1);
+            const opSpaceId2 = compressor.normalizeToOpSpace(localId2);
+            const opSpaceId3 = compressor.normalizeToOpSpace(finalId3);
+            const opSpaceId4 = compressor.normalizeToOpSpace(finalId4);
+            const opSpaceId5 = compressor.normalizeToOpSpace(finalId5);
+            const opSpaceId6 = compressor.normalizeToOpSpace(localId6);
+            expectAssert(isFinalId(opSpaceId1));
+            expectAssert(isFinalId(opSpaceId2));
+            expectAssert(isFinalId(opSpaceId3) && opSpaceId3 === finalId3);
+            expectAssert(isFinalId(opSpaceId4) && opSpaceId4 === finalId4);
+            expectAssert(isFinalId(opSpaceId5) && opSpaceId5 === finalId5);
+            expectAssert(isFinalId(opSpaceId6));
+            expect(compressor.normalizeToSessionSpace(opSpaceId1)).to.equal(localId1);
+            expect(compressor.normalizeToSessionSpace(opSpaceId2)).to.equal(localId2);
+            expect(compressor.normalizeToSessionSpace(opSpaceId3)).to.equal(finalId3);
+            expect(compressor.normalizeToSessionSpace(opSpaceId4)).to.equal(finalId4);
+            expect(compressor.normalizeToSessionSpace(opSpaceId5)).to.equal(finalId5);
+            expect(compressor.normalizeToSessionSpace(opSpaceId6)).to.equal(localId6);
+        });
+        it('does not eagerly allocate final IDs for IDs with overrides', () => {
+            const compressor = createCompressor(Client.Client1, 5);
+            const localId1 = compressor.generateCompressedId();
+            compressor.finalizeCreationRange(compressor.takeNextCreationRange());
+            const override1 = compressor.generateCompressedId('override1');
+            expect(isLocalId(override1)).to.be.true;
+            const finalId1 = compressor.generateCompressedId();
+            expect(isFinalId(finalId1)).to.be.true;
+            generateCompressedIds(compressor, 5);
+            compressor.finalizeCreationRange(compressor.takeNextCreationRange());
+            const override2 = compressor.generateCompressedId('override2');
+            expect(isLocalId(override2)).to.be.true;
+            const finalId2 = compressor.generateCompressedId();
+            expect(isFinalId(finalId2)).to.be.true;
+            compressor.finalizeCreationRange(compressor.takeNextCreationRange());
+            const opSpaceId1 = compressor.normalizeToOpSpace(localId1);
+            const opSpaceId2 = compressor.normalizeToOpSpace(override1);
+            const opSpaceId3 = compressor.normalizeToOpSpace(finalId1);
+            const opSpaceId4 = compressor.normalizeToOpSpace(override2);
+            const opSpaceId5 = compressor.normalizeToOpSpace(finalId2);
+            expectAssert(isFinalId(opSpaceId1));
+            expectAssert(isFinalId(opSpaceId2));
+            expectAssert(isFinalId(opSpaceId3) && opSpaceId3 === finalId1);
+            expectAssert(isFinalId(opSpaceId4));
+            expectAssert(isFinalId(opSpaceId5) && opSpaceId5 === finalId2);
+            expect(compressor.normalizeToSessionSpace(opSpaceId1)).to.equal(localId1);
+            expect(compressor.normalizeToSessionSpace(opSpaceId2)).to.equal(override1);
+            expect(compressor.normalizeToSessionSpace(opSpaceId3)).to.equal(finalId1);
+            expect(compressor.normalizeToSessionSpace(opSpaceId4)).to.equal(override2);
+            expect(compressor.normalizeToSessionSpace(opSpaceId5)).to.equal(finalId2);
+        });
+        it('correctly normalizes eagerly allocated final IDs', () => {
+            const compressor = createCompressor(Client.Client1, 5);
+            const localId1 = compressor.generateCompressedId();
+            const range1 = compressor.takeNextCreationRange();
+            const localId2 = compressor.generateCompressedId();
+            const range2 = compressor.takeNextCreationRange();
+            expect(isLocalId(localId1)).to.be.true;
+            expect(isLocalId(localId2)).to.be.true;
+            compressor.finalizeCreationRange(range1);
+            compressor.finalizeCreationRange(range2);
+            const opSpaceId1 = compressor.normalizeToOpSpace(localId1);
+            const opSpaceId2 = compressor.normalizeToOpSpace(localId2);
+            expectAssert(isFinalId(opSpaceId1));
+            expectAssert(isFinalId(opSpaceId2));
+            expect(compressor.normalizeToSessionSpace(opSpaceId1)).to.equal(localId1);
+            expect(compressor.normalizeToSessionSpace(opSpaceId2)).to.equal(localId2);
+        });
+        it('generates correct eager finals when there are outstanding locals after cluster expansion', () => {
+            const compressor = createCompressor(Client.Client1, 2);
+            // Before cluster expansion
+            expect(isLocalId(compressor.generateCompressedId())).to.be.true;
+            const rangeA = compressor.takeNextCreationRange();
+            compressor.finalizeCreationRange(rangeA);
+            expect(isFinalId(compressor.generateCompressedId())).to.be.true;
+            // After cluster expansion
+            expect(isLocalId(compressor.generateCompressedId())).to.be.true;
+            const rangeB = compressor.takeNextCreationRange();
+            const localId = compressor.generateCompressedId();
+            expect(isLocalId(localId)).to.be.true;
+            // Take a range that won't be finalized in this test; the finalizing of range B should associate this range with finals
+            const rangeC = compressor.takeNextCreationRange();
+            compressor.finalizeCreationRange(rangeB);
+            const eagerId = compressor.generateCompressedId();
+            expect(isFinalId(eagerId)).to.be.true;
+            expect(compressor.recompress(compressor.decompress(localId))).to.equal(localId);
+            expect(compressor.recompress(compressor.decompress(eagerId))).to.equal(eagerId);
+            compressor.finalizeCreationRange(rangeC);
+            expect(compressor.recompress(compressor.decompress(localId))).to.equal(localId);
+            expect(compressor.recompress(compressor.decompress(eagerId))).to.equal(eagerId);
+        });
+        it('generates unique eager finals when multiple outstanding creation ranges during finalizing', () => {
+            const compressor = createCompressor(Client.Client1, 10 /* must be 10 for the test to make sense */);
+            // Make a first outstanding range
+            const id1_1 = compressor.generateCompressedId();
+            const id1_2 = compressor.generateCompressedId();
+            expect(isLocalId(id1_1)).to.be.true;
+            expect(isLocalId(id1_2)).to.be.true;
+            const range1 = compressor.takeNextCreationRange();
+            // Make a second outstanding range
+            const id2_1 = compressor.generateCompressedId();
+            const id2_2 = compressor.generateCompressedId();
+            expect(isLocalId(id2_1)).to.be.true;
+            expect(isLocalId(id2_2)).to.be.true;
+            const range2 = compressor.takeNextCreationRange();
+            // Finalize just the first one, which should create finals that align with both outstanding ranges
+            compressor.finalizeCreationRange(range1);
+            // Make a third range. This one should be composed of eager finals that align after the two ranges above.
+            const id3_1 = compressor.generateCompressedId();
+            const id3_2 = compressor.generateCompressedId();
+            expect(isFinalId(id3_1)).to.be.true;
+            expect(isFinalId(id3_2)).to.be.true;
+            const range3 = compressor.takeNextCreationRange();
+            // Finalize both initial ranges.
+            compressor.finalizeCreationRange(range2);
+            compressor.finalizeCreationRange(range3);
+            // Make some more eager finals that should be aligned correctly.
+            const id4_1 = compressor.generateCompressedId();
+            const id4_2 = compressor.generateCompressedId();
+            expect(isFinalId(id4_1)).to.be.true;
+            expect(isFinalId(id4_2)).to.be.true;
+            // Assert everything is unique and consistent.
+            const ids = new Set();
+            const uuids = new Set();
+            [id1_1, id1_2, id2_1, id2_2, id3_1, id3_2, id4_1, id4_2].forEach((id) => {
+                ids.add(id);
+                uuids.add(compressor.decompress(id));
+            });
+            expect(ids.size).to.equal(8);
+            expect(uuids.size).to.equal(8);
+        });
+        it('generates unique eager finals when there are still outstanding locals after a cluster is expanded', () => {
+            // const compressor = createCompressor(Client.Client1, 4 /* must be 4 for the test to make sense */);
+            const compressor = new IdCompressor(sessionIds.get(Client.Client1), 0);
+            compressor.clusterCapacity = 4;
+            // Make locals to fill half the future cluster
+            const id1_1 = compressor.generateCompressedId();
+            const id1_2 = compressor.generateCompressedId();
+            expect(isLocalId(id1_1)).to.be.true;
+            expect(isLocalId(id1_2)).to.be.true;
+            const range1 = compressor.takeNextCreationRange();
+            // Make locals to overflow the future cluster
+            const id2_1 = compressor.generateCompressedId();
+            const id2_2 = compressor.generateCompressedId();
+            const id2_3 = compressor.generateCompressedId();
+            expect(isLocalId(id2_1)).to.be.true;
+            expect(isLocalId(id2_2)).to.be.true;
+            expect(isLocalId(id2_3)).to.be.true;
+            const range2 = compressor.takeNextCreationRange();
+            // Finalize the first range. This should align the first four locals (i.e. all of range1, and 2/3 of range2)
+            compressor.finalizeCreationRange(range1);
+            // Make a single range that should still be overflowing the initial cluster (i.e. be local)
+            const id3_1 = compressor.generateCompressedId();
+            expect(isLocalId(id3_1)).to.be.true;
+            const range3 = compressor.takeNextCreationRange();
+            // First finalize should expand the cluster and align all outstanding ranges.
+            compressor.finalizeCreationRange(range2);
+            // All generated IDs should have aligned finals (even though range3 has not been finalized)
+            const allIds = [id1_1, id1_2, id2_1, id2_2, id2_3, id3_1];
+            allIds.forEach((id) => expect(isFinalId(compressor.normalizeToOpSpace(id))).to.be.true);
+            compressor.finalizeCreationRange(range3);
+            // Make one eager final
+            const id4_1 = compressor.generateCompressedId();
+            allIds.push(id4_1);
+            expect(isFinalId(id4_1)).to.be.true;
+            // Assert everything is unique and consistent.
+            const ids = new Set();
+            const uuids = new Set();
+            allIds.forEach((id) => {
+                ids.add(id);
+                uuids.add(compressor.decompress(id));
+            });
+            expect(ids.size).to.equal(7);
+            expect(uuids.size).to.equal(7);
+        });
+    });
     describe('Serialization', () => {
         it('can serialize an empty compressor', () => {
             const compressor = createCompressor(Client.Client1);
@@ -905,7 +1113,7 @@ describe('IdCompressor', () => {
             });
         });
         itNetwork('produces consistent IDs with large fuzz input', (network) => {
-            const generator = take(1000, makeOpGenerator({ includeOverrides: true }));
+            const generator = take(2000, makeOpGenerator({ includeOverrides: true }));
             performFuzzActions(generator, network, 1984, undefined, true, (network) => network.assertNetworkState());
             network.deliverOperations(DestinationClient.All);
         });
@@ -941,91 +1149,6 @@ describe('IdCompressor', () => {
             const emptyId = (id + 1);
             expect(() => network.getCompressor(Client.Client2).decompress(emptyId)).to.throw('Compressed ID was not generated by this compressor');
         });
-        describe('Eager final ID allocation', () => {
-            it('eagerly allocates final IDs when cluster creation has been finalized', () => {
-                const compressor = createCompressor(Client.Client1, 5);
-                const localId1 = compressor.generateCompressedId();
-                expect(isLocalId(localId1)).to.be.true;
-                const localId2 = compressor.generateCompressedId();
-                expect(isLocalId(localId2)).to.be.true;
-                compressor.finalizeCreationRange(compressor.takeNextCreationRange());
-                const finalId3 = compressor.generateCompressedId();
-                expect(isFinalId(finalId3)).to.be.true;
-                const finalId4 = compressor.generateCompressedId();
-                expect(isFinalId(finalId4)).to.be.true;
-                const finalId5 = compressor.generateCompressedId();
-                expect(isFinalId(finalId5)).to.be.true;
-                const localId6 = compressor.generateCompressedId();
-                expect(isLocalId(localId6)).to.be.true;
-                compressor.finalizeCreationRange(compressor.takeNextCreationRange());
-                const opSpaceId1 = compressor.normalizeToOpSpace(localId1);
-                const opSpaceId2 = compressor.normalizeToOpSpace(localId2);
-                const opSpaceId3 = compressor.normalizeToOpSpace(finalId3);
-                const opSpaceId4 = compressor.normalizeToOpSpace(finalId4);
-                const opSpaceId5 = compressor.normalizeToOpSpace(finalId5);
-                const opSpaceId6 = compressor.normalizeToOpSpace(localId6);
-                expectAssert(isFinalId(opSpaceId1));
-                expectAssert(isFinalId(opSpaceId2));
-                expectAssert(isFinalId(opSpaceId3) && opSpaceId3 === finalId3);
-                expectAssert(isFinalId(opSpaceId4) && opSpaceId4 === finalId4);
-                expectAssert(isFinalId(opSpaceId5) && opSpaceId5 === finalId5);
-                expectAssert(isFinalId(opSpaceId6));
-                expect(compressor.normalizeToSessionSpace(opSpaceId1)).to.equal(localId1);
-                expect(compressor.normalizeToSessionSpace(opSpaceId2)).to.equal(localId2);
-                expect(compressor.normalizeToSessionSpace(opSpaceId3)).to.equal(finalId3);
-                expect(compressor.normalizeToSessionSpace(opSpaceId4)).to.equal(finalId4);
-                expect(compressor.normalizeToSessionSpace(opSpaceId5)).to.equal(finalId5);
-                expect(compressor.normalizeToSessionSpace(opSpaceId6)).to.equal(localId6);
-            });
-            it('does not eagerly allocate final IDs for IDs with overrides', () => {
-                const compressor = createCompressor(Client.Client1, 5);
-                const localId1 = compressor.generateCompressedId();
-                compressor.finalizeCreationRange(compressor.takeNextCreationRange());
-                const override1 = compressor.generateCompressedId('override1');
-                expect(isLocalId(override1)).to.be.true;
-                const finalId1 = compressor.generateCompressedId();
-                expect(isFinalId(finalId1)).to.be.true;
-                generateCompressedIds(compressor, 5);
-                compressor.finalizeCreationRange(compressor.takeNextCreationRange());
-                const override2 = compressor.generateCompressedId('override2');
-                expect(isLocalId(override2)).to.be.true;
-                const finalId2 = compressor.generateCompressedId();
-                expect(isFinalId(finalId2)).to.be.true;
-                compressor.finalizeCreationRange(compressor.takeNextCreationRange());
-                const opSpaceId1 = compressor.normalizeToOpSpace(localId1);
-                const opSpaceId2 = compressor.normalizeToOpSpace(override1);
-                const opSpaceId3 = compressor.normalizeToOpSpace(finalId1);
-                const opSpaceId4 = compressor.normalizeToOpSpace(override2);
-                const opSpaceId5 = compressor.normalizeToOpSpace(finalId2);
-                expectAssert(isFinalId(opSpaceId1));
-                expectAssert(isFinalId(opSpaceId2));
-                expectAssert(isFinalId(opSpaceId3) && opSpaceId3 === finalId1);
-                expectAssert(isFinalId(opSpaceId4));
-                expectAssert(isFinalId(opSpaceId5) && opSpaceId5 === finalId2);
-                expect(compressor.normalizeToSessionSpace(opSpaceId1)).to.equal(localId1);
-                expect(compressor.normalizeToSessionSpace(opSpaceId2)).to.equal(override1);
-                expect(compressor.normalizeToSessionSpace(opSpaceId3)).to.equal(finalId1);
-                expect(compressor.normalizeToSessionSpace(opSpaceId4)).to.equal(override2);
-                expect(compressor.normalizeToSessionSpace(opSpaceId5)).to.equal(finalId2);
-            });
-            it('correctly normalizes eagerly allocated final IDs', () => {
-                const compressor = createCompressor(Client.Client1, 5);
-                const localId1 = compressor.generateCompressedId();
-                const range1 = compressor.takeNextCreationRange();
-                const localId2 = compressor.generateCompressedId();
-                const range2 = compressor.takeNextCreationRange();
-                expect(isLocalId(localId1)).to.be.true;
-                expect(isLocalId(localId2)).to.be.true;
-                compressor.finalizeCreationRange(range1);
-                compressor.finalizeCreationRange(range2);
-                const opSpaceId1 = compressor.normalizeToOpSpace(localId1);
-                const opSpaceId2 = compressor.normalizeToOpSpace(localId2);
-                expectAssert(isFinalId(opSpaceId1));
-                expectAssert(isFinalId(opSpaceId2));
-                expect(compressor.normalizeToSessionSpace(opSpaceId1)).to.equal(localId1);
-                expect(compressor.normalizeToSessionSpace(opSpaceId2)).to.equal(localId2);
-            });
-        });
         describe('Finalizing', () => {
             itNetwork('can finalize IDs from multiple clients', (network) => {
                 network.allocateAndSendIds(Client.Client1, 3, {
@@ -1163,7 +1286,7 @@ describe('IdCompressor', () => {
                 expectSequencedLogsAlign(network, Client.Client1, Client.Client2);
             });
             itNetwork('can serialize after a large fuzz input', 3, (network) => {
-                const generator = take(1000, makeOpGenerator({ includeOverrides: true }));
+                const generator = take(2000, makeOpGenerator({ includeOverrides: true }));
                 performFuzzActions(generator, network, Math.PI, undefined, true, (network) => {
                     // Periodically check that everyone in the network has the same serialized state
                     network.deliverOperations(DestinationClient.All);