Feat/changeset ts (#6594)

* Migrated changeset

* Added more tests.

* Fixed test scopes

src/tests/backend-new/specs/easysync-other.test.ts

@@ -0,0 +1,166 @@
+'use strict';
+
+import {applyToAttribution, applyToText, checkRep, deserializeOps, exportedForTestingOnly, filterAttribNumbers, joinAttributionLines, makeAttribsString, makeSplice, moveOpsToNewPool, opAttributeValue, splitAttributionLines} from '../../../static/js/Changeset';
+import AttributePool from '../../../static/js/AttributePool';
+import {randomMultiline, poolOrArray} from '../easysync-helper';
+import padutils from '../../../static/js/pad_utils';
+import {describe, it, expect} from 'vitest'
+import Op from "../../../static/js/Op";
+import {MergingOpAssembler} from "../../../static/js/MergingOpAssembler";
+import {Attribute} from "../../../static/js/types/Attribute";
+
+
+describe('easysync-other', function () {
+  describe('filter attribute numbers', function () {
+    const testFilterAttribNumbers = (testId: number, cs: string, filter: Function, correctOutput: string) => {
+      it(`testFilterAttribNumbers#${testId}`, async function () {
+        const str = filterAttribNumbers(cs, filter);
+        expect(str).to.equal(correctOutput);
+      });
+    };
+
+    testFilterAttribNumbers(1, '*0*1+1+2+3*1+4*2+5*0*2*1*b*c+6',
+        (n: number) => (n % 2) === 0, '*0+1+2+3+4*2+5*0*2*c+6');
+    testFilterAttribNumbers(2, '*0*1+1+2+3*1+4*2+5*0*2*1*b*c+6',
+        (n: number) => (n % 2) === 1, '*1+1+2+3*1+4+5*1*b+6');
+  });
+
+  describe('make attribs string', function () {
+    const testMakeAttribsString = (testId: number, pool: string[], opcode: string, attribs: string | Attribute[], correctString: string) => {
+      it(`testMakeAttribsString#${testId}`, async function () {
+        const p = poolOrArray(pool);
+        padutils.warnDeprecatedFlags.disabledForTestingOnly = true;
+        try {
+          expect(makeAttribsString(opcode, attribs, p)).to.equal(correctString);
+        } finally {
+          // @ts-ignore
+          delete padutils.warnDeprecatedFlags.disabledForTestingOnly;
+        }
+      });
+    };
+
+    testMakeAttribsString(1, ['bold,'], '+', [
+      ['bold', ''],
+    ], '');
+    testMakeAttribsString(2, ['abc,def', 'bold,'], '=', [
+      ['bold', ''],
+    ], '*1');
+    testMakeAttribsString(3, ['abc,def', 'bold,true'], '+', [
+      ['abc', 'def'],
+      ['bold', 'true'],
+    ], '*0*1');
+    testMakeAttribsString(4, ['abc,def', 'bold,true'], '+', [
+      ['bold', 'true'],
+      ['abc', 'def'],
+    ], '*0*1');
+  });
+
+  describe('other', function () {
+    it('testMoveOpsToNewPool', async function () {
+      const pool1 = new AttributePool();
+      const pool2 = new AttributePool();
+
+      pool1.putAttrib(['baz', 'qux']);
+      pool1.putAttrib(['foo', 'bar']);
+
+      pool2.putAttrib(['foo', 'bar']);
+
+      expect(moveOpsToNewPool('Z:1>2*1+1*0+1$ab', pool1, pool2))
+          .to.equal('Z:1>2*0+1*1+1$ab');
+      expect(moveOpsToNewPool('*1+1*0+1', pool1, pool2)).to.equal('*0+1*1+1');
+    });
+
+    it('testMakeSplice', async function () {
+      const t = 'a\nb\nc\n';
+      let splice = makeSplice(t, 5, 0, 'def')
+      const t2 = applyToText(splice, t);
+      expect(t2).to.equal('a\nb\ncdef\n');
+    });
+
+    it('makeSplice at the end', async function () {
+      const orig = '123';
+      const ins = '456';
+      expect(applyToText(makeSplice(orig, orig.length, 0, ins), orig))
+          .to.equal(`${orig}${ins}`);
+    });
+
+    it('testToSplices', async function () {
+      const cs = checkRep('Z:z>9*0=1=4-3+9=1|1-4-4+1*0+a$123456789abcdefghijk');
+      const correctSplices = [
+        [5, 8, '123456789'],
+        [9, 17, 'abcdefghijk'],
+      ];
+      expect(exportedForTestingOnly.toSplices(cs)).to.eql(correctSplices);
+    });
+
+    it('opAttributeValue', async function () {
+      const p = new AttributePool();
+      p.putAttrib(['name', 'david']);
+      p.putAttrib(['color', 'green']);
+
+      const stringOp = (str: string) => deserializeOps(str).next().value as Op;
+
+      padutils.warnDeprecatedFlags.disabledForTestingOnly = true;
+      try {
+        expect(opAttributeValue(stringOp('*0*1+1'), 'name', p)).to.equal('david');
+        expect(opAttributeValue(stringOp('*0+1'), 'name', p)).to.equal('david');
+        expect(opAttributeValue(stringOp('*1+1'), 'name', p)).to.equal('');
+        expect(opAttributeValue(stringOp('+1'), 'name', p)).to.equal('');
+        expect(opAttributeValue(stringOp('*0*1+1'), 'color', p)).to.equal('green');
+        expect(opAttributeValue(stringOp('*1+1'), 'color', p)).to.equal('green');
+        expect(opAttributeValue(stringOp('*0+1'), 'color', p)).to.equal('');
+        expect(opAttributeValue(stringOp('+1'), 'color', p)).to.equal('');
+      } finally {
+        // @ts-ignore
+        delete padutils.warnDeprecatedFlags.disabledForTestingOnly;
+      }
+    });
+
+    describe('applyToAttribution', function () {
+      const runApplyToAttributionTest = (testId: number, attribs: string[], cs: string, inAttr: string, outCorrect: string) => {
+        it(`applyToAttribution#${testId}`, async function () {
+          const p = poolOrArray(attribs);
+          const result = applyToAttribution(checkRep(cs), inAttr, p);
+          expect(result).to.equal(outCorrect);
+        });
+      };
+
+      // turn c<b>a</b>ctus\n into a<b>c</b>tusabcd\n
+      runApplyToAttributionTest(1,
+          ['bold,', 'bold,true'], 'Z:7>3-1*0=1*1=1=3+4$abcd', '+1*1+1|1+5', '+1*1+1|1+8');
+
+      // turn "david\ngreenspan\n" into "<b>david\ngreen</b>\n"
+      runApplyToAttributionTest(2,
+          ['bold,', 'bold,true'], 'Z:g<4*1|1=6*1=5-4$', '|2+g', '*1|1+6*1+5|1+1');
+    });
+
+    describe('split/join attribution lines', function () {
+      const testSplitJoinAttributionLines = (randomSeed: number) => {
+        const stringToOps = (str: string) => {
+          const assem = new MergingOpAssembler();
+          const o = new Op('+');
+          o.chars = 1;
+          for (let i = 0; i < str.length; i++) {
+            const c = str.charAt(i);
+            o.lines = (c === '\n' ? 1 : 0);
+            o.attribs = (c === 'a' || c === 'b' ? `*${c}` : '');
+            assem.append(o);
+          }
+          return assem.toString();
+        };
+
+        it(`testSplitJoinAttributionLines#${randomSeed}`, async function () {
+          const doc = `${randomMultiline(10, 20)}\n`;
+
+          const theJoined = stringToOps(doc);
+          const theSplit = doc.match(/[^\n]*\n/g)!.map(stringToOps);
+
+          expect(splitAttributionLines(theJoined, doc)).to.eql(theSplit);
+          expect(joinAttributionLines(theSplit)).to.equal(theJoined);
+        });
+      };
+
+      for (let i = 0; i < 10; i++) testSplitJoinAttributionLines(i);
+    });
+  });
+});