proskomma-core 0.9.7 → 0.9.12

package/test/code/main/mutate_add.cjs

@@ -0,0 +1,180 @@
+const path = require('path');
+const test = require('tape');
+const fse = require('fs-extra');
+const { Proskomma } = require('../../../src/index.cjs');
+const { pkWithDocs } = require('../../lib/load.js');
+const { blocksSpec2Query } = require('../../../src/util/scriptlike/blocksSpec.cjs');
+
+const testGroup = 'Mutate Add Operations';
+
+const pk = new Proskomma();
+let content = fse.readFileSync(
+  path.resolve(__dirname, '../../test_data/usx/web_rut.usx'),
+).toString();
+
+test(
+  `Document (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(10);
+      let query = '{ docSets { id } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 0);
+      query = `mutation { addDocument(` +
+        `selectors: [{key: "lang", value: "eng"}, {key: "abbr", value: "ust"}], ` +
+        `contentType: "usx", ` +
+        `content: """${content}"""` +
+        `tags: ["foo", "baa"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.addDocument, true);
+      query = '{ docSets { id documents { id tags mainSequence { nBlocks } } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.docSets.length, 1);
+      t.equal(result.data.docSets[0].documents.length, 1);
+      t.ok(result.data.docSets[0].documents[0].mainSequence.nBlocks > 0);
+      t.equal(result.data.docSets[0].documents[0].tags.length, 2);
+      t.ok(result.data.docSets[0].documents[0].tags.includes('foo'));
+      t.ok(result.data.docSets[0].documents[0].tags.includes('baa'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Sequence (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(9);
+      let query = '{ documents { id nSequences sequences { id type } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const docId = result.data.documents[0].id;
+      const nSequences = result.data.documents[0].nSequences;
+      t.equal(result.data.documents[0].sequences.filter(s => s.type === 'banana').length, 0);
+      query = `mutation { newSequence(` +
+        ` documentId: "${docId}"` +
+        ` type: "banana"` +
+        ` tags: ["yellow", "tasty"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const newSequenceId = result.data.newSequence;
+      query = '{ documents { id nSequences sequences { id type tags } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.documents[0].nSequences, nSequences + 1);
+      const bananaSequence = result.data.documents[0].sequences.filter(s => s.type === 'banana');
+      t.equal(bananaSequence.length, 1);
+      t.equal(result.data.documents[0].sequences.filter(s => s.id === newSequenceId).length, 1);
+      t.ok(bananaSequence[0].tags.includes('yellow'));
+      t.ok(bananaSequence[0].tags.includes('tasty'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Sequence with graft (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(8);
+      let query = '{ documents { id nSequences sequences { id type } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const docId = result.data.documents[0].id;
+      const nSequences = result.data.documents[0].nSequences;
+      t.equal(result.data.documents[0].sequences.filter(s => s.type === 'table').length, 0);
+      query = `mutation { newSequence(` +
+        ` documentId: "${docId}"` +
+        ` type: "table"` +
+        ` graftToMain: true) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const newSequenceId = result.data.newSequence;
+      query = '{ documents { id mainSequence { id blocks { bg { payload } } } nSequences sequences { id type } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.documents[0].nSequences, nSequences + 1);
+      t.equal(result.data.documents[0].sequences.filter(s => s.type === 'table').length, 1);
+      t.equal(result.data.documents[0].sequences.filter(s => s.id === newSequenceId).length, 1);
+      const mainSequenceFirstBlockGrafts = result.data.documents[0].mainSequence.blocks[0].bg.map(g => g.payload);
+      t.ok(mainSequenceFirstBlockGrafts.includes(newSequenceId));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Sequence with block content (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(8);
+      const blocksSpec = fse.readJSONSync(path.resolve(__dirname, '../../test_data/inputBlockSpec/mk1.json'));
+      const blockQuery = blocksSpec2Query(blocksSpec);
+      let query = '{ documents { id nSequences sequences { id type } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const docId = result.data.documents[0].id;
+      const nSequences = result.data.documents[0].nSequences;
+      t.equal(result.data.documents[0].sequences.filter(s => s.type === 'table').length, 1);
+      query = `mutation { newSequence(` +
+        ` documentId: "${docId}"` +
+        ` type: "randomText"` +
+        ` blocksSpec: ${blockQuery}` +
+        ` graftToMain: true) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const newSequenceId = result.data.newSequence;
+      query = '{ documents { id nSequences sequences { id type blocks { text } } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.documents[0].nSequences, nSequences + 1);
+      const newSequence = result.data.documents[0].sequences.filter(s => s.id === newSequenceId)[0];
+      t.equal(result.data.documents[0].sequences.filter(s => s.id === newSequenceId).length, 1);
+      t.equal(newSequence.type, 'randomText');
+      t.ok(newSequence.blocks[0].text.startsWith('Start of the Good News'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Block (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(7);
+      const pk = pkWithDocs(
+        [
+          ['../test_data/usfm/1pe_webbe.usfm', {
+            lang: 'eng',
+            abbr: 'web',
+          }],
+        ],
+      );
+      let query = '{ documents { id mainSequence { id nBlocks } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const docId = result.data.documents[0].id;
+      const seqId = result.data.documents[0].mainSequence.id;
+      const nBlocks = result.data.documents[0].mainSequence.nBlocks;
+      t.equal(nBlocks, 3);
+      query = `mutation { newBlock(documentId: "${docId}" sequenceId: "${seqId}" blockN: 1, blockScope: "blockTag/q4") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.newBlock, true);
+      query = '{ documents { id mainSequence { id nBlocks blocks(positions:[1]) { bs { payload } } } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.documents[0].mainSequence.nBlocks, nBlocks + 1);
+      t.equal(result.data.documents[0].mainSequence.blocks[0].bs.payload, 'blockTag/q4');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+

package/test/code/main/mutate_delete.cjs

@@ -0,0 +1,236 @@
+const path = require('path');
+const test = require('tape');
+const fse = require('fs-extra');
+const {
+  pkWithDoc,
+  pkWithDocs,
+} = require('../../lib/load.js');
+
+const testGroup = 'Mutate Delete Operations';
+
+test(
+  `DocSet (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(9);
+      const pk = pkWithDoc('../test_data/usx/web_rut.usx', {
+        lang: 'eng',
+        abbr: 'ust',
+      }, {}, {}, [], [])[0];
+      let query = '{ docSets { id } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 1);
+      query = `mutation { deleteDocSet(docSetId: "foo/baa") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.deleteDocSet, false);
+      query = '{ docSets { id } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.docSets.length, 1);
+      query = `mutation { deleteDocSet(docSetId: "${result.data.docSets[0].id}") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.deleteDocSet, true);
+      query = '{ nDocSets nDocuments }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.nDocSets, 0);
+      t.equal(result.data.nDocuments, 0);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Reload Deleted DocSet (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const selectors = {
+        lang: 'eng',
+        abbr: 'ust',
+      };
+      const pk = pkWithDoc('../test_data/usx/web_rut.usx', selectors, {}, {}, [], [])[0];
+      let query = '{ docSets { id } }';
+      let result = await pk.gqlQuery(query);
+      query = `mutation { deleteDocSet(docSetId: "${result.data.docSets[0].id}") }`;
+      result = await pk.gqlQuery(query);
+      query = '{ docSets { id } nDocuments}';
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.docSets.length, 0);
+      t.equal(result.data.nDocuments, 0);
+      const content = fse.readFileSync(path.resolve(__dirname, '../../test_data/usx/web_rut.usx'));
+
+      t.doesNotThrow(
+        () => pk.importDocument(
+          selectors,
+          'usx',
+          content,
+          {},
+        ),
+      );
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Document (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(9);
+      const pk = pkWithDocs(
+        [
+          ['../test_data/usx/web_rut.usx', {
+            lang: 'eng',
+            abbr: 'ust',
+          }],
+          ['../test_data/usx/web_psa150.usx', {
+            lang: 'eng',
+            abbr: 'ust',
+          }],
+        ],
+      );
+      let query = '{ docSets { id documents { id } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 1);
+      t.equal(result.data.docSets[0].documents.length, 2);
+      const aDocumentId = result.data.docSets[0].documents[0].id;
+      query = `mutation { deleteDocument(docSetId: "${result.data.docSets[0].id}", documentId: "foobaa") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.deleteDocument, false);
+      query = '{ docSets { id documents { id } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.docSets[0].documents.length, 2);
+      query = `mutation { deleteDocument(docSetId: "${result.data.docSets[0].id}", documentId: "${aDocumentId}") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.deleteDocument, true);
+      query = '{ docSets { id documents { id } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.docSets.length, 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Inline Sequence (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(12);
+      const pk = pkWithDocs(
+        [
+          ['../test_data/usx/web_rut.usx', {
+            lang: 'eng',
+            abbr: 'ust',
+          }],
+        ],
+      );
+      let query = '{ documents { id nSequences mainSequence { id blocks(positions:[0]) { items { type subType payload } } } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.documents.length, 1);
+      const docId = result.data.documents[0].id;
+      const nSequences = result.data.documents[0].nSequences;
+      const items = result.data.documents[0].mainSequence.blocks[0].items;
+      const mainId = result.data.documents[0].mainSequence.id;
+      const graft = items.filter(i => i.type === 'graft')[0];
+      query = `mutation { deleteSequence(documentId: "foo" sequenceId: "${graft.payload}") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors.length, 1);
+      t.ok(result.errors[0].message.startsWith('Document \'foo\' not found'));
+      query = `mutation { deleteSequence(documentId: "${docId}" sequenceId: "${mainId}") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors.length, 1);
+      t.ok(result.errors[0].message.startsWith('Cannot delete main sequence'));
+      query = `mutation { deleteSequence(documentId: "${docId}" sequenceId: "baa") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.deleteSequence, false);
+      query = `mutation { deleteSequence(documentId: "${docId}" sequenceId: "${graft.payload}") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.deleteSequence, true);
+      query = '{ documents { id nSequences mainSequence { id blocks(positions:[0]) { items { type subType payload } } } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.documents[0].nSequences, nSequences - 2);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Block-Grafted Sequence (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      const pk = pkWithDocs(
+        [
+          ['../test_data/usx/not_nfc18_phm.usx', {
+            lang: 'fra',
+            abbr: 'nfc18',
+          }],
+        ],
+      );
+      let query = '{ documents { id nSequences mainSequence { id blocks(positions:[0]) { bg { subType payload } } } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.documents.length, 1);
+      const docId = result.data.documents[0].id;
+      const nSequences = result.data.documents[0].nSequences;
+      const graftSeqId = result.data.documents[0].mainSequence.blocks[0].bg[0].payload;
+      query = `mutation { deleteSequence(documentId: "${docId}" sequenceId: "${graftSeqId}") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.deleteSequence, true);
+      query = '{ documents { id nSequences } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.documents[0].nSequences, nSequences - 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Block (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      const pk = pkWithDocs(
+        [
+          ['../test_data/usfm/1pe_webbe.usfm', {
+            lang: 'eng',
+            abbr: 'web',
+          }],
+        ],
+      );
+      let query = '{ documents { id mainSequence { id nBlocks } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const docId = result.data.documents[0].id;
+      const seqId = result.data.documents[0].mainSequence.id;
+      const nBlocks = result.data.documents[0].mainSequence.nBlocks;
+      t.equal(nBlocks, 3);
+      query = `mutation { deleteBlock(documentId: "${docId}" sequenceId: "${seqId}" blockN: 1) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.deleteBlock, true);
+      query = '{ documents { id mainSequence { id nBlocks  blocks { items { type subType payload } } } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.documents[0].mainSequence.nBlocks, nBlocks - 1);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/mutate_rehash.cjs

@@ -0,0 +1,68 @@
+const path = require('path');
+const test = require('tape');
+const fse = require('fs-extra');
+const { pkWithDoc } = require('../../lib/load.js');
+
+const pk = pkWithDoc('../test_data/usx/web_psa150.usx', {
+  lang: 'eng',
+  abbr: 'web',
+}, {}, {}, [], [])[0];
+
+const testGroup = 'Rehash';
+
+test(
+  `One Document (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(8);
+      let query = '{ docSets { id documents { id mainSequence { nBlocks blocks { dump } } } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 1);
+      const nMainSequenceBlocks = result.data.docSets[0].documents[0].mainSequence.nBlocks;
+      query = `mutation { rehashDocSet(docSetId: "${result.data.docSets[0].id}") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.rehashDocSet, true);
+      query = '{ docSets { id documents { id mainSequence { nBlocks blocks { dump } } } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 1);
+      t.equal(result.data.docSets[0].documents.length, 1);
+      t.equal(result.data.docSets[0].documents[0].mainSequence.nBlocks, nMainSequenceBlocks);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `After adding document (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      let query = '{ docSets { id documents { id mainSequence { nBlocks blocks { dump } } } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets.length, 1);
+      // const firstDocumentId = result.data.docSets[0].documents[0].id;
+      // const nMainSequenceBlocks = result.data.docSets[0].documents[0].mainSequence.nBlocks;
+      const content = fse.readFileSync(path.resolve(__dirname, '../../test_data/usx/web_rut.usx'));
+
+      pk.importDocument({
+        lang: 'eng',
+        abbr: 'web',
+      }, 'usx', content);
+      query = `mutation { rehashDocSet(docSetId: "${result.data.docSets[0].id}") }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.rehashDocSet, true);
+      query = '{ docSets { id documents { id mainSequence { nBlocks blocks { dump } } } } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.equal(result.data.docSets[0].documents.length, 2);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/mutate_tags.cjs

@@ -0,0 +1,90 @@
+const test = require('tape');
+const { pkWithDoc } = require('../../lib/load.js');
+
+const pk = pkWithDoc('../test_data/usx/web_rut.usx', {
+  lang: 'eng',
+  abbr: 'ust',
+}, {}, {}, [], [])[0];
+
+const testGroup = 'Mutate Tags';
+
+test(
+  `DocSet (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      let query = '{ docSets { id tags } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const docSet = result.data.docSets[0];
+      t.equal(docSet.tags.length, 0);
+      query = `mutation { addDocSetTags(docSetId: "${docSet.id}", tags: ["foo", "baa"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.addDocSetTags.length, 2);
+      query = `mutation { addDocSetTags(docSetId: "${docSet.id}", tags: ["foo", "frob"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.addDocSetTags.length, 3);
+      query = `mutation { removeDocSetTags(docSetId: "${docSet.id}", tags: ["baa", "frob"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.removeDocSetTags.length, 1);
+      t.ok(result.data.removeDocSetTags.includes('foo'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Document (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      let query = '{ docSets { id documents { id tags } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const docSet = result.data.docSets[0];
+      const document = docSet.documents[0];
+      t.equal(document.tags.length, 0);
+      query = `mutation { addDocumentTags(docSetId: "${docSet.id}", documentId: "${document.id}", tags: ["foo", "baa"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.addDocumentTags.length, 2);
+      query = `mutation { addDocumentTags(docSetId: "${docSet.id}", documentId: "${document.id}", tags: ["foo", "frob"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.addDocumentTags.length, 3);
+      query = `mutation { removeDocumentTags(docSetId: "${docSet.id}", documentId: "${document.id}", tags: ["baa", "frob"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.removeDocumentTags.length, 1);
+      t.ok(result.data.removeDocumentTags.includes('foo'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Sequence (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      let query = '{ docSets { id documents { id mainSequence { id tags } } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const docSet = result.data.docSets[0];
+      const document = docSet.documents[0];
+      const sequence = document.mainSequence;
+      t.equal(sequence.tags.length, 0);
+      query = `mutation { addSequenceTags(docSetId: "${docSet.id}", documentId: "${document.id}", sequenceId: "${sequence.id}", tags: ["foo", "baa"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.addSequenceTags.length, 2);
+      query = `mutation { addSequenceTags(docSetId: "${docSet.id}", documentId: "${document.id}", sequenceId: "${sequence.id}", tags: ["foo", "frob"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.addSequenceTags.length, 3);
+      query = `mutation { removeSequenceTags(docSetId: "${docSet.id}", documentId: "${document.id}", sequenceId: "${sequence.id}", tags: ["baa", "frob"]) }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.data.removeSequenceTags.length, 1);
+      t.ok(result.data.removeSequenceTags.includes('foo'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);