easysync tests: move to separate files

Author: webzwo0i

src/tests/frontend/specs/easysync-assembler.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const Changeset = require('../../../static/js/Changeset');
+const {poolOrArray} = require('./easysync-helper.js');
+
+describe('easysync', function () {
+  it('opAssembler', async function () {
+    const x = '-c*3*4+6|3=az*asdf0*1*2*3+1=1-1+1*0+1=1-1+1|c=c-1';
+    const iter = Changeset.opIterator(x);
+    const assem = Changeset.opAssembler();
+    while (iter.hasNext()) assem.append(iter.next());
+    expect(assem.toString()).to.equal(x);
+  });
+
+  it('smartOpAssembler', async function () {
+    const x = '-c*3*4+6|3=az*asdf0*1*2*3+1=1-1+1*0+1=1-1+1|c=c-1';
+    const iter = Changeset.opIterator(x);
+    const assem = Changeset.smartOpAssembler();
+    while (iter.hasNext()) assem.append(iter.next());
+    assem.endDocument();
+    expect(assem.toString()).to.equal(x);
+  });
+
+  describe('append atext to assembler', function () {
+    const testAppendATextToAssembler = (testId, atext, correctOps) => {
+      it(`testAppendATextToAssembler#${testId}`, async function () {
+        const assem = Changeset.smartOpAssembler();
+        Changeset.appendATextToAssembler(atext, assem);
+        expect(assem.toString()).to.equal(correctOps);
+      });
+    };
+
+    testAppendATextToAssembler(1, {
+      text: '\n',
+      attribs: '|1+1',
+    }, '');
+    testAppendATextToAssembler(2, {
+      text: '\n\n',
+      attribs: '|2+2',
+    }, '|1+1');
+    testAppendATextToAssembler(3, {
+      text: '\n\n',
+      attribs: '*x|2+2',
+    }, '*x|1+1');
+    testAppendATextToAssembler(4, {
+      text: '\n\n',
+      attribs: '*x|1+1|1+1',
+    }, '*x|1+1');
+    testAppendATextToAssembler(5, {
+      text: 'foo\n',
+      attribs: '|1+4',
+    }, '+3');
+    testAppendATextToAssembler(6, {
+      text: '\nfoo\n',
+      attribs: '|2+5',
+    }, '|1+1+3');
+    testAppendATextToAssembler(7, {
+      text: '\nfoo\n',
+      attribs: '*x|2+5',
+    }, '*x|1+1*x+3');
+    testAppendATextToAssembler(8, {
+      text: '\n\n\nfoo\n',
+      attribs: '|2+2*x|2+5',
+    }, '|2+2*x|1+1*x+3'); //TODO: why isn't this |2+2*x|1+4 ?
+  });
+});

src/tests/frontend/specs/easysync-compose.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const Changeset = require('../../../static/js/Changeset');
+const AttributePool = require('../../../static/js/AttributePool');
+const {randomMultiline, randomTestChangeset} = require('./easysync-helper.js');
+
+describe('easysync', function () {
+  describe('compose', function () {
+    const testCompose = (randomSeed) => {
+      it(`testCompose#${randomSeed}`, async function () {
+        const p = new AttributePool();
+
+        const startText = `${randomMultiline(10, 20)}\n`;
+
+        const x1 = randomTestChangeset(startText);
+        const change1 = x1[0];
+        const text1 = x1[1];
+
+        const x2 = randomTestChangeset(text1);
+        const change2 = x2[0];
+        const text2 = x2[1];
+
+        const x3 = randomTestChangeset(text2);
+        const change3 = x3[0];
+        const text3 = x3[1];
+
+        const change12 = Changeset.checkRep(Changeset.compose(change1, change2, p));
+        const change23 = Changeset.checkRep(Changeset.compose(change2, change3, p));
+        const change123 = Changeset.checkRep(Changeset.compose(change12, change3, p));
+        const change123a = Changeset.checkRep(Changeset.compose(change1, change23, p));
+        expect(change123a).to.equal(change123);
+
+        expect(Changeset.applyToText(change12, startText)).to.equal(text2);
+        expect(Changeset.applyToText(change23, text1)).to.equal(text3);
+        expect(Changeset.applyToText(change123, startText)).to.equal(text3);
+      });
+    };
+
+    for (let i = 0; i < 30; i++) testCompose(i);
+  });
+
+  describe('compose attributes', function () {
+    it('simpleComposeAttributesTest', async function () {
+      const p = new AttributePool();
+      p.putAttrib(['bold', '']);
+      p.putAttrib(['bold', 'true']);
+      const cs1 = Changeset.checkRep('Z:2>1*1+1*1=1$x');
+      const cs2 = Changeset.checkRep('Z:3>0*0|1=3$');
+      const cs12 = Changeset.checkRep(Changeset.compose(cs1, cs2, p));
+      expect(cs12).to.equal('Z:2>1+1*0|1=2$x');
+    });
+  });
+});

src/tests/frontend/specs/easysync-follow.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const Changeset = require('../../../static/js/Changeset');
+const AttributePool = require('../../../static/js/AttributePool');
+const {randomMultiline, randomTestChangeset} = require('./easysync-helper.js');
+
+describe('easysync', function () {
+  describe('follow & compose', function () {
+    const testFollow = (randomSeed) => {
+      it(`testFollow#${randomSeed}`, async function () {
+        const p = new AttributePool();
+
+        const startText = `${randomMultiline(10, 20)}\n`;
+
+        const cs1 = randomTestChangeset(startText)[0];
+        const cs2 = randomTestChangeset(startText)[0];
+
+        const afb = Changeset.checkRep(Changeset.follow(cs1, cs2, false, p));
+        const bfa = Changeset.checkRep(Changeset.follow(cs2, cs1, true, p));
+
+        const merge1 = Changeset.checkRep(Changeset.compose(cs1, afb));
+        const merge2 = Changeset.checkRep(Changeset.compose(cs2, bfa));
+
+        expect(merge2).to.equal(merge1);
+      });
+    };
+    for (let i = 0; i < 30; i++) testFollow(i);
+  });
+
+  describe('followAttributes & composeAttributes', function () {
+    const p = new AttributePool();
+    p.putAttrib(['x', '']);
+    p.putAttrib(['x', 'abc']);
+    p.putAttrib(['x', 'def']);
+    p.putAttrib(['y', '']);
+    p.putAttrib(['y', 'abc']);
+    p.putAttrib(['y', 'def']);
+    let n = 0;
+
+    const testFollow = (a, b, afb, bfa, merge) => {
+      it(`manual #${++n}`, async function () {
+        expect(Changeset.followAttributes(a, b, p)).to.equal(afb);
+        expect(Changeset.followAttributes(b, a, p)).to.equal(bfa);
+        expect(Changeset.composeAttributes(a, afb, true, p)).to.equal(merge);
+        expect(Changeset.composeAttributes(b, bfa, true, p)).to.equal(merge);
+      });
+    };
+
+    testFollow('', '', '', '', '');
+    testFollow('*0', '', '', '*0', '*0');
+    testFollow('*0', '*0', '', '', '*0');
+    testFollow('*0', '*1', '', '*0', '*0');
+    testFollow('*1', '*2', '', '*1', '*1');
+    testFollow('*0*1', '', '', '*0*1', '*0*1');
+    testFollow('*0*4', '*2*3', '*3', '*0', '*0*3');
+    testFollow('*0*4', '*2', '', '*0*4', '*0*4');
+  });
+
+  describe('chracterRangeFollow', function () {
+    const testCharacterRangeFollow = (testId, cs, oldRange, insertionsAfter, correctNewRange) => {
+      it(`testCharacterRangeFollow#${testId}`, async function () {
+        cs = Changeset.checkRep(cs);
+        expect(Changeset.characterRangeFollow(cs, oldRange[0], oldRange[1], insertionsAfter))
+            .to.eql(correctNewRange);
+      });
+    };
+
+    testCharacterRangeFollow(1, 'Z:z>9*0=1=4-3+9=1|1-4-4+1*0+a$123456789abcdefghijk',
+        [7, 10], false, [14, 15]);
+    testCharacterRangeFollow(2, 'Z:bc<6|x=b4|2-6$', [400, 407], false, [400, 401]);
+    testCharacterRangeFollow(3, 'Z:4>0-3+3$abc', [0, 3], false, [3, 3]);
+    testCharacterRangeFollow(4, 'Z:4>0-3+3$abc', [0, 3], true, [0, 0]);
+    testCharacterRangeFollow(5, 'Z:5>1+1=1-3+3$abcd', [1, 4], false, [5, 5]);
+    testCharacterRangeFollow(6, 'Z:5>1+1=1-3+3$abcd', [1, 4], true, [2, 2]);
+    testCharacterRangeFollow(7, 'Z:5>1+1=1-3+3$abcd', [0, 6], false, [1, 7]);
+    testCharacterRangeFollow(8, 'Z:5>1+1=1-3+3$abcd', [0, 3], false, [1, 2]);
+    testCharacterRangeFollow(9, 'Z:5>1+1=1-3+3$abcd', [2, 5], false, [5, 6]);
+    testCharacterRangeFollow(10, 'Z:2>1+1$a', [0, 0], false, [1, 1]);
+    testCharacterRangeFollow(11, 'Z:2>1+1$a', [0, 0], true, [0, 0]);
+  });
+});