MergeTree: Add stress for LocalReferences

packages/dds/merge-tree/src/test/client.localReferenceFarm.spec.ts

@@ -0,0 +1,117 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { strict as assert } from "assert";
+import random from "random-js";
+import { doOverRange } from ".";
+import { LocalReference, ReferenceType } from "..";
+import {
+    IMergeTreeOperationRunnerConfig,
+    removeRange,
+    runMergeTreeOperationRunner,
+    generateClientNames,
+    IConfigRange,
+} from "./mergeTreeOperationRunner";
+import { TestClient } from "./testClient";
+import { TestClientLogger } from "./testClientLogger";
+
+ const defaultOptions: Record<"initLen" | "modLen", IConfigRange> & IMergeTreeOperationRunnerConfig = {
+    initLen: {min: 2, max: 4},
+    modLen: {min: 1, max: 8},
+    opsPerRoundRange: { min: 10, max: 10 },
+    rounds: 10,
+    operations: [removeRange],
+    growthFunc: (input: number) => input * 2,
+};
+
+
+describe("MergeTree.Client", () => {
+    // Generate a list of single character client names, support up to 69 clients
+    const clientNames = generateClientNames();
+
+    doOverRange(defaultOptions.initLen, defaultOptions.growthFunc, (initLen)=>{
+        doOverRange(defaultOptions.modLen, defaultOptions.growthFunc, (modLen)=>{
+
+            it(`LocalReferenceFarm_${initLen}_${modLen}`, async () => {
+                const mt = random.engines.mt19937();
+                mt.seedWithArray([0xDEADBEEF, 0xFEEDBED, initLen, modLen]);
+
+                const clients: TestClient[] = new Array(3).fill(0).map(()=> new TestClient());
+                clients.forEach(
+                    (c, i) => c.startOrUpdateCollaboration(clientNames[i]));
+
+                let seq = 0;
+                // init with random values
+                seq = runMergeTreeOperationRunner(
+                    mt,
+                    seq,
+                    clients,
+                    initLen,
+                    defaultOptions
+                );
+                // add local references
+                const refs: LocalReference[][]=[];
+
+                const validateRefs = (reason: string, workload:()=>void)=>{
+                    const preWorkload = TestClientLogger.toString(clients);
+                    workload();
+                    for(let c=1;c<clients.length;c++){
+                        for(let r =0; r<refs[c].length;r++){
+                            const pos0 = refs[0][r].toPosition();
+                            const posC = refs[c][r].toPosition();
+                            if(pos0 !== posC){
+                                assert.equal(
+                                    pos0, posC,
+                                    `${reason}:\n${preWorkload}\n${TestClientLogger.toString(clients)}`);
+                            }
+                        }
+                    }
+                    // console.log(`${reason}:\n${preWorkload}\n${TestClientLogger.toString(clients)}`)
+                };
+
+                validateRefs("Initialize", ()=>{
+                    clients.forEach((c,i)=>{
+                        refs.push([]);
+                        for(let t = 0;t<c.getLength();t++){
+                            const seg = c.getContainingSegment(t);
+                            const lref = new LocalReference(c, seg.segment, seg.offset, ReferenceType.SlideOnRemove);
+                            c.addLocalReference(lref);
+                            lref.addProperties({t});
+                            refs[i].push(lref);
+                        }
+                    });
+                });
+
+
+                validateRefs("After Init Zamboni",()=>{
+                    //trigger zamboni multiple times as it is incremental
+                    for(let i = clients[0].getCollabWindow().minSeq;i<=seq;i++){
+                        clients.forEach((c)=>c.updateMinSeq(i));
+                    }
+                });
+
+                validateRefs("After More Ops", ()=>{
+                    // init with random values
+                    seq = runMergeTreeOperationRunner(
+                        mt,
+                        seq,
+                        clients,
+                        modLen,
+                        defaultOptions,
+                    );
+                });
+
+
+                validateRefs("After Final Zamboni",()=>{
+                    //trigger zamboni multiple times as it is incremental
+                    for(let i = clients[0].getCollabWindow().minSeq;i<=seq;i++){
+                        clients.forEach((c)=>c.updateMinSeq(i));
+                    }
+                });
+
+            })
+        });
+    });
+});

packages/dds/merge-tree/src/test/testClientLogger.ts

@@ -54,6 +54,16 @@ export function createClientsAtInitialState<TClients extends ClientMap>(
     return {...clients, all};
 }
 export class TestClientLogger {
+
+    public static toString(clients: readonly TestClient[]){
+
+        return clients.map((c)=>this.getSegString(c)).reduce<[string,string]>((pv,cv)=>{
+            pv[0]+=`|${cv.acked.padEnd(cv.local.length,"")}`;
+            pv[1]+=`|${cv.local.padEnd(cv.acked.length,"")}`;
+            return pv;
+        },["",""]).join("\n");
+    }
+
     private readonly incrementalLog = false;
 
     private readonly paddings: number[] = [];
@@ -80,7 +90,7 @@ export class TestClientLogger {
                 const clientLogIndex = i*2
 
                 this.ackedLine[clientLogIndex]=getOpString(op.sequencedMessage ?? c.makeOpMessage(op.op))
-                const segStrings = this.getSegString(c);
+                const segStrings = TestClientLogger.getSegString(c);
                 this.ackedLine[clientLogIndex + 1] = segStrings.acked;
                 this.localLine[clientLogIndex +1] = segStrings.local;
 
@@ -109,14 +119,18 @@ export class TestClientLogger {
     }
 
     private addNewLogLine() {
-        if (this.incrementalLog) {
-            console.log(this.ackedLine.map((v, i) => v.padEnd(this.paddings[i])).join(" | "));
-            console.log(this.ackedLine.map((v, i) => v.padEnd(this.paddings[i])).join(" | "));
+        if(this.incrementalLog){
+            while(this.roundLogLines.length > 0){
+                const logLine = this.roundLogLines.shift();
+                if(logLine.some((c)=>c.trim().length >0)){
+                    console.log(logLine.map((v, i) => v.padEnd(this.paddings[i])).join(" | "));
+                }
+            }
         }
         this.ackedLine = [];
         this.localLine = [];
         this.clients.forEach((cc, clientLogIndex)=>{
-            const segStrings = this.getSegString(cc);
+            const segStrings = TestClientLogger.getSegString(cc);
             this.ackedLine.push("", segStrings.acked);
             this.localLine.push("", segStrings.local);
 
@@ -153,17 +167,21 @@ export class TestClientLogger {
         return baseText;
     }
 
-    public toString() {
-        let str =
-            `_: Local State\n`
-            + `-: Deleted\n`
-            + `*: Unacked Insert and Delete\n`
-            + `${this.clients[0].getCollabWindow().minSeq}: msn/offset\n`
-            + `Op format <seq>:<ref>:<client><type>@<pos1>,<pos2>\n`
-            + `sequence number represented as offset from msn. L means local.\n`
-            + `op types: 0) insert 1) remove 2) annotate\n`;
-        if (this.title) {
-            str += `${this.title}\n`;
+    public toString(excludeHeader: boolean = false) {
+        let str = "";
+        if(!excludeHeader){
+            str +=
+                `_: Local State\n`
+                + `-: Deleted\n`
+                + `*: Unacked Insert and Delete\n`
+                + `${this.clients[0].getCollabWindow().minSeq}: msn/offset\n`
+                + `Op format <seq>:<ref>:<client><type>@<pos1>,<pos2>\n`
+                + `sequence number represented as offset from msn. L means local.\n`
+                + `op types: 0) insert 1) remove 2) annotate\n`;
+
+            if (this.title) {
+                str += `${this.title}\n`;
+            }
         }
         str += this.roundLogLines
             .filter((line)=>line.some((c)=>c.trim().length >0))
@@ -172,7 +190,7 @@ export class TestClientLogger {
         return str;
     }
 
-    private getSegString(client: TestClient): { acked: string, local: string } {
+    private static getSegString(client: TestClient): { acked: string, local: string } {
         let acked: string = "";
         let local: string = "";
         const nodes = [...client.mergeTree.root.children];