cassproject 5.0.22 → 5.0.23

package/src/test/1.EcRsaOaep.test.js

@@ -68,18 +68,8 @@ describe("EcRsaOaep", () => {
         assert.isTrue(elapsed < 1);
         assert.isTrue(randomString == decrypted);
     });
-    it('signing then verifying', () => {
-        console.log("Deprecated. See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main");
-        return;
-    });
-    it('signing then verifying (utf-8)', () => {
-        console.log("Deprecated. See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main");
-        return;
-    });
-    it('signing then verifying w/caching', () => {
-        console.log("Deprecated. See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main");
-        return;
-    });
+    // SHA-1 signing then verifying (plain, utf-8 and w/caching) is no longer tested here.
+    // See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main
     it('signing then verifying (sha256)', () => {
         let randomString = EcAes.newIv(256*4);
         let ppk = EcPpk.fromPem(

package/src/test/1.EcRsaOaepAsync.test.js

@@ -71,18 +71,8 @@ describe("EcRsaOaepAsync", () => {
         assert.isTrue(elapsed < 1);
         assert.isTrue(randomString == decrypted);
     });
-    it('signing then verifying', async () => {
-        console.log("Deprecated. See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main");
-        return;
-    });
-    it('signing then verifying (utf-8)', async () => {
-        console.log("Deprecated. See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main");
-        return;
-    });
-    it('signing then verifying w/caching', async () => {
-        console.log("Deprecated. See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main");
-        return;
-    });
+    // SHA-1 signing then verifying (plain, utf-8 and w/caching) is no longer tested here.
+    // See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main
     it('signing then verifying (sha256)', async () => {
         let randomString = EcAes.newIv(256*4);
         let ppk = EcPpk.fromPem(

package/src/test/1.EcRsaOaepAsyncWorker.test.js

@@ -74,18 +74,8 @@ describe("EcRsaOaepAsyncWorker", () => {
         assert.isTrue(elapsed < 1);
         assert.isTrue(randomString == decrypted);
     });
-    it('signing then verifying', async () => {
-        console.log("Deprecated. See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main");
-        return;
-    });
-    it('signing then verifying (utf-8)', async () => {
-        console.log("Deprecated. See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main");
-        return;
-    });
-    it('signing then verifying w/caching', async () => {
-        console.log("Deprecated. See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main");
-        return;
-    });
+    // SHA-1 signing then verifying (plain, utf-8 and w/caching) is no longer tested here.
+    // See https://github.com/Lomilar/node-fips-rsassa-pkcs1-15-sha1/tree/main
     it('signing then verifying (sha256)', async () => {
         let randomString = EcAes.newIv(256 * 4);
         let ppk = EcPpk.fromPem(

package/src/test/1.EcRsaOaepAsyncWorker.workers.test.js

@@ -0,0 +1,147 @@
+// Checks that, under Node, the crypto "worker" classes really run on web-worker
+// threads. The other worker tests only check results, which would also pass if
+// creating the workers failed and every call fell back to the main thread.
+require('../../index.js');
+const chai = require('chai');
+const sinon = require('sinon');
+const EcRsaOaepAsyncWorker = require('../com/eduworks/ec/crypto/EcRsaOaepAsyncWorker.js');
+const EcAesCtrAsyncWorker = require('../com/eduworks/ec/crypto/EcAesCtrAsyncWorker.js');
+const EcRsaOaepAsync = require('../com/eduworks/ec/crypto/EcRsaOaepAsync.js');
+const EcAesCtrAsync = require('../com/eduworks/ec/crypto/EcAesCtrAsync.js');
+const EcRsaOaep = require('../com/eduworks/ec/crypto/EcRsaOaep.js');
+const EcAesCtr = require('../com/eduworks/ec/crypto/EcAesCtr.js');
+const EcAes = require('../com/eduworks/ec/crypto/EcAes.js');
+const EcPpk = require('../com/eduworks/ec/crypto/EcPpk.js');
+const EcCrypto = require('../com/eduworks/ec/crypto/EcCrypto.js');
+
+const assert = chai.assert;
+
+describe('EcRsaOaepAsyncWorker threads (Node)', function () {
+    this.timeout(60000);
+    let ppk, pk, posted, caching;
+    const fallbacks = [];
+
+    before(async function () {
+        if (typeof window !== 'undefined') this.skip();
+        // Cached decryptions never reach a worker.
+        caching = EcCrypto.caching;
+        EcCrypto.caching = false;
+        EcRsaOaepAsyncWorker.teardown();
+        ppk = await EcPpk.generateKeyAsync();
+        pk = ppk.toPk();
+    });
+
+    beforeEach(() => {
+        // Any use of the main-thread implementations means the worker path was skipped.
+        fallbacks.length = 0;
+        for (const [cls, names] of [[EcRsaOaepAsync, ['encrypt', 'decrypt', 'sign', 'signSha256', 'verify', 'verifySha256']], [EcAesCtrAsync, ['encrypt', 'decrypt']]])
+            for (const n of names) fallbacks.push(sinon.spy(cls, n));
+        posted = [];
+    });
+
+    afterEach(() => sinon.restore());
+    after(() => {
+        EcRsaOaepAsyncWorker.teardown();
+        if (caching !== undefined) EcCrypto.caching = caching;
+    });
+
+    function watchWorkers() {
+        EcRsaOaepAsyncWorker.initWorker();
+        for (const w of EcRsaOaepAsyncWorker.w)
+            if (!w.postMessage.restore)
+                sinon.stub(w, 'postMessage').callsFake(function (msg, origin) {
+                    posted.push(msg.cmd);
+                    return w.postMessage.wrappedMethod.call(w, msg, origin);
+                });
+    }
+
+    function assertNoFallback() {
+        for (const f of fallbacks)
+            assert.isFalse(f.called, `fell back to ${f.toString()}`);
+    }
+
+    it('provides a Worker implementation', () => {
+        assert.isFunction(global.Worker);
+    });
+
+    it('starts one worker per rotation without logging errors', () => {
+        const report = sinon.spy(global.auditLogger, 'report');
+        EcRsaOaepAsyncWorker.initWorker();
+        assert.lengthOf(EcRsaOaepAsyncWorker.w, EcRsaOaepAsyncWorker.rotations);
+        for (const w of EcRsaOaepAsyncWorker.w) {
+            assert.isNotNull(w);
+            assert.isFunction(w.postMessage);
+            assert.isFunction(w._worker.terminate);
+        }
+        assert.isFalse(report.calledWith(sinon.match.any, sinon.match.any, 'EcRsaOaepAsyncWorker'), 'worker creation logged an error');
+    });
+
+    // ASCII interoperates with the main-thread classes. Non-ASCII text only round-trips
+    // worker to worker: the worker path encodes UTF-8 differently.
+    it('encrypts and decrypts on a worker', async () => {
+        watchWorkers();
+        const text = 'Hello, workers';
+        assert.equal(EcRsaOaep.decrypt(ppk, await EcRsaOaepAsyncWorker.encrypt(pk, text)), text);
+        assert.equal(await EcRsaOaepAsyncWorker.decrypt(ppk, EcRsaOaep.encrypt(pk, text)), text);
+        const utf8 = 'Hello, workers ✓';
+        assert.equal(await EcRsaOaepAsyncWorker.decrypt(ppk, await EcRsaOaepAsyncWorker.encrypt(pk, utf8)), utf8);
+        assert.equal(await EcRsaOaepAsyncWorker.decrypt(ppk, EcRsaOaep.encrypt(pk, utf8)), utf8);
+        assert.deepEqual(posted, ['encryptRsaOaep', 'decryptRsaOaep', 'encryptRsaOaep', 'decryptRsaOaep', 'decryptRsaOaep']);
+        assertNoFallback();
+    });
+
+    it('signs and verifies on a worker', async () => {
+        watchWorkers();
+        const text = 'Sign me';
+        const sha1 = await EcRsaOaepAsyncWorker.sign(ppk, text);
+        const sha256 = await EcRsaOaepAsyncWorker.signSha256(ppk, text);
+        assert.equal(sha256, EcRsaOaep.signSha256(ppk, text));
+        assert.isTrue(await EcRsaOaepAsyncWorker.verify(pk, text, sha1));
+        assert.isTrue(await EcRsaOaepAsyncWorker.verifySha256(pk, text, sha256));
+        assert.isFalse(await EcRsaOaepAsyncWorker.verifySha256(pk, text + '!', sha256));
+        const utf8 = 'Sign me ✓';
+        assert.isTrue(await EcRsaOaepAsyncWorker.verifySha256(pk, utf8, await EcRsaOaepAsyncWorker.signSha256(ppk, utf8)));
+        assert.deepEqual(posted, ['signRsaOaep', 'signSha256RsaOaep', 'verifyRsaOaep', 'verifyRsaOaepSha256', 'verifyRsaOaepSha256', 'signSha256RsaOaep', 'verifyRsaOaepSha256']);
+        assertNoFallback();
+    });
+
+    it('runs AES-CTR on a worker', async () => {
+        watchWorkers();
+        const secret = EcAes.newSecret(32), iv = EcAes.newIv(16), text = 'AES on a worker';
+        assert.equal(EcAesCtr.decrypt(await EcAesCtrAsyncWorker.encrypt(text, secret, iv), secret, iv), text);
+        assert.equal(await EcAesCtrAsyncWorker.decrypt(EcAesCtr.encrypt(text, secret, iv), secret, iv), text);
+        const utf8 = 'AES on a worker ✓';
+        assert.equal(await EcAesCtrAsyncWorker.decrypt(await EcAesCtrAsyncWorker.encrypt(utf8, secret, iv), secret, iv), utf8);
+        assert.deepEqual(posted, ['encryptAesCtr', 'decryptAesCtr', 'encryptAesCtr', 'decryptAesCtr']);
+        assertNoFallback();
+    });
+
+    it('rotates work across all workers', async () => {
+        watchWorkers();
+        const used = new Set();
+        EcRsaOaepAsyncWorker.w.forEach((w, i) => w.postMessage.callsFake(function (msg, origin) {
+            used.add(i);
+            return w.postMessage.wrappedMethod.call(w, msg, origin);
+        }));
+        const text = 'rotate';
+        await Promise.all(Array.from({ length: EcRsaOaepAsyncWorker.rotations }, () => EcRsaOaepAsyncWorker.encrypt(pk, text)));
+        assert.equal(used.size, EcRsaOaepAsyncWorker.rotations);
+    });
+
+    it('resolves the string "null" when the worker cannot decrypt', async () => {
+        watchWorkers();
+        assert.strictEqual(await EcRsaOaepAsyncWorker.decrypt(ppk, 'bm90IGNpcGhlcnRleHQ='), 'null');
+        assert.deepEqual(posted, ['decryptRsaOaep']);
+    });
+
+    it('terminates the workers on teardown and starts new ones afterwards', async () => {
+        EcRsaOaepAsyncWorker.initWorker();
+        const old = EcRsaOaepAsyncWorker.w.map((w) => sinon.spy(w._worker, 'terminate'));
+        EcRsaOaepAsyncWorker.teardown();
+        assert.isNull(EcRsaOaepAsyncWorker.w);
+        for (const t of old) assert.isTrue(t.calledOnce);
+        watchWorkers();
+        assert.equal(await EcRsaOaepAsyncWorker.decrypt(ppk, EcRsaOaep.encrypt(pk, 'again')), 'again');
+        assertNoFallback();
+    });
+});

package/src/test/1.FrameworkImport.test.js

@@ -0,0 +1,170 @@
+require('../../index.js');
+const chai = require('chai');
+const sinon = require('sinon');
+const EcRepository = require('../org/cassproject/ebac/repository/EcRepository.js');
+
+const assert = chai.assert;
+
+const SERVER = "http://repo.test/api/";
+const SRC = "http://src.test/api/data/";
+
+function fixtures() {
+    const store = {};
+    const comp = (n) => {
+        const c = new EcCompetency();
+        c.id = SRC + "c" + n;
+        c.name = "Comp " + n;
+        store[c.id] = c;
+        return c;
+    };
+    const c1 = comp(1);
+    const c2 = comp(2);
+    const r1 = new EcAlignment();
+    r1.id = SRC + "r1";
+    r1.source = c2.shortId();
+    r1.target = c1.shortId();
+    r1.relationType = "narrows";
+    store[r1.id] = r1;
+    const source = new EcFramework();
+    source.id = SRC + "fw";
+    source.name = "Source";
+    source.competency = [c1.id, c2.id];
+    source.relation = [r1.id];
+    const target = new EcFramework();
+    target.id = SERVER + "fw";
+    target.name = "Target";
+    return { store, source, target };
+}
+
+describe('FrameworkImport.importCompetencies', () => {
+    let store;
+    let gets;
+    beforeEach(() => {
+        gets = [];
+        sinon.stub(EcRepository, 'getAs').callsFake((id, obj, success, failure) => {
+            gets.push(id);
+            if (store[id] == null) return failure("missing " + id);
+            obj.copyFrom(JSON.parse(store[id].toJson()));
+            success(obj);
+        });
+    });
+    afterEach(() => sinon.restore());
+
+    const run = (source, target, copy, serverUrl, repo) => new Promise((resolve, reject) => {
+        FrameworkImport.importCompetencies(source, target, copy, serverUrl, null, (c, r) => resolve({ c, r }), reject, repo);
+    });
+    const savingRepo = (saved, selectedServer) => ({ selectedServer: selectedServer || SERVER, saveTo: (o, s) => { saved.push(o); s("ok"); } });
+
+    it('reports missing source, target and competencies', () => {
+        const failures = [];
+        FrameworkImport.importCompetencies(null, null, false, SERVER, null, null, (e) => failures.push(e));
+        FrameworkImport.importCompetencies(new EcFramework(), null, false, SERVER, null, null, (e) => failures.push(e));
+        FrameworkImport.importCompetencies(new EcFramework(), new EcFramework(), false, SERVER, null, null, (e) => failures.push(e));
+        assert.deepEqual(failures, ["Source Framework not set", "Target Framework not Set", "Source Has No Competencies"]);
+    });
+
+    describe('copy', () => {
+        it('copies competencies and relations with versioned ids and remapped endpoints', async () => {
+            const f = fixtures();
+            store = f.store;
+            const saved = [];
+            const { c, r } = await run(f.source, f.target, true, SERVER, savingRepo(saved));
+            assert.lengthOf(c, 2);
+            assert.lengthOf(r, 1);
+            for (const x of c.concat(r)) {
+                assert.isTrue(x.id.startsWith(SERVER));
+                assert.notEqual(x.id, x.shortId());
+            }
+            assert.deepEqual(c.map(x => x.name), ["Comp 1", "Comp 2"]);
+            assert.equal(r[0].source, c[1].shortId());
+            assert.equal(r[0].target, c[0].shortId());
+            assert.deepEqual(f.target.competency.slice().sort(), c.map(x => x.shortId()).sort());
+            assert.deepEqual(f.target.relation, [r[0].shortId()]);
+            assert.deepEqual(gets, [SRC + "c1", SRC + "c2", SRC + "r1"]);
+        });
+
+        it('copies with short ids when the repository server does not contain the server url', async () => {
+            const f = fixtures();
+            store = f.store;
+            const { c, r } = await run(f.source, f.target, true, "http://other.test/", savingRepo([]));
+            for (const x of c.concat(r)) {
+                assert.isTrue(x.id.startsWith("http://other.test/"));
+                assert.equal(x.id, x.shortId());
+            }
+        });
+
+        it('copies with versioned ids through EcRepository when there is no repository', async () => {
+            const f = fixtures();
+            store = f.store;
+            const saved = [];
+            sinon.stub(EcRepository, 'save').callsFake((o, s) => { saved.push(o); s("ok"); });
+            const { c, r } = await run(f.source, f.target, true, SERVER, null);
+            for (const x of c.concat(r))
+                assert.notEqual(x.id, x.shortId());
+            assert.lengthOf(saved, 5);
+        });
+    });
+
+    describe('link', () => {
+        it('links every competency and relation when the target has none', async () => {
+            const f = fixtures();
+            store = f.store;
+            const saved = [];
+            const { c, r } = await run(f.source, f.target, false, SERVER, savingRepo(saved));
+            assert.deepEqual(c.map(x => x.id), [SRC + "c1", SRC + "c2"]);
+            assert.deepEqual(r.map(x => x.id), [SRC + "r1"]);
+            assert.deepEqual(f.target.competency, [SRC + "c1", SRC + "c2"]);
+            assert.deepEqual(f.target.relation, [SRC + "r1"]);
+            assert.deepEqual(saved, [f.target, f.target]);
+        });
+
+        it('skips competencies already in the target by exact or unversioned id', async () => {
+            const f = fixtures();
+            store = f.store;
+            f.source.competency = [SRC + "c1", SRC + "c2/123"];
+            store[SRC + "c2/123"] = store[SRC + "c2"];
+            f.target.competency = [SRC + "c1", SRC + "c2"];
+            let done = false;
+            FrameworkImport.importCompetencies(f.source, f.target, false, SERVER, null, () => { done = true; }, () => { done = true; }, savingRepo([]));
+            await new Promise(r => setTimeout(r, 20));
+            assert.deepEqual(gets, []);
+            // Nothing was linked, so the completion check never fires.
+            assert.isFalse(done);
+        });
+
+        it('only fetches the competencies the target is missing, and then never completes', async () => {
+            const f = fixtures();
+            store = f.store;
+            f.target.competency = [SRC + "c1"];
+            const saved = [];
+            let done = false;
+            FrameworkImport.importCompetencies(f.source, f.target, false, SERVER, null, () => { done = true; }, () => { done = true; }, savingRepo(saved));
+            await new Promise(r => setTimeout(r, 20));
+            assert.deepEqual(gets, [SRC + "c2"]);
+            assert.deepEqual(f.target.competency, [SRC + "c1", SRC + "c2"]);
+            assert.deepEqual(saved, []);
+            assert.isFalse(done);
+        });
+
+        it('skips a relation whose id is in the target, or whose same-index competency id is in the target relations', async () => {
+            const f = fixtures();
+            store = f.store;
+            f.target.relation = [SRC + "r1"];
+            let done = false;
+            FrameworkImport.importCompetencies(f.source, f.target, false, SERVER, null, () => { done = true; }, () => { done = true; }, savingRepo([]));
+            await new Promise(r => setTimeout(r, 20));
+            assert.deepEqual(gets, [SRC + "c1", SRC + "c2"]);
+            assert.isFalse(done);
+
+            const g = fixtures();
+            store = g.store;
+            gets.length = 0;
+            // The relation check compares against source.competency[i], not source.relation[i].
+            g.target.relation = [SRC + "c1"];
+            FrameworkImport.importCompetencies(g.source, g.target, false, SERVER, null, () => { done = true; }, () => { done = true; }, savingRepo([]));
+            await new Promise(r => setTimeout(r, 20));
+            assert.deepEqual(gets, [SRC + "c1", SRC + "c2"]);
+            assert.isFalse(done);
+        });
+    });
+});

package/src/test/1.MedbiqImport.test.js

@@ -0,0 +1,92 @@
+require('../../index.js');
+const chai = require('chai');
+const sinon = require('sinon');
+const EcRepository = require('../org/cassproject/ebac/repository/EcRepository.js');
+
+const assert = chai.assert;
+
+const SERVER = "http://repo.test/api/";
+
+const competencyObject = (title, extra) => ({ lom: { general: Object.assign({ title: { string: title } }, extra) } });
+
+describe('MedbiqImport', () => {
+    afterEach(() => {
+        sinon.restore();
+        MedbiqImport.medbiqXmlCompetencies = null;
+    });
+
+    describe('medbiqXmlLookForCompetencyObject', () => {
+        it('collects competency objects that have lom.general and skips the rest', () => {
+            MedbiqImport.medbiqXmlCompetencies = [];
+            MedbiqImport.medbiqXmlLookForCompetencyObject({
+                root: {
+                    CompetencyObject: [
+                        competencyObject("One", { description: { string: "Desc" }, identifier: { entry: "urn:1" } }),
+                        competencyObject("Two"),
+                        { lom: { other: 1 } },
+                        { lom: null },
+                        { nothing: true }
+                    ],
+                    nested: { CompetencyObject: competencyObject("Three") }
+                }
+            });
+            const found = MedbiqImport.medbiqXmlCompetencies;
+            assert.deepEqual(found.map(c => c.name), ["One", "Two", "Three"]);
+            assert.equal(found[0].description, "Desc");
+            assert.equal(found[0].url, "urn:1");
+            assert.equal(found[1].description, "");
+            assert.isUndefined(found[1].url);
+        });
+    });
+
+    describe('importCompetencies', () => {
+        const prepare = (names) => {
+            MedbiqImport.medbiqXmlCompetencies = names.map((n) => {
+                const c = new EcCompetency();
+                c.name = n;
+                return c;
+            });
+        };
+        const run = (serverUrl, repo) => new Promise((resolve, reject) => {
+            const progress = [];
+            MedbiqImport.importCompetencies(serverUrl, null, (comps) => resolve({ comps, progress }), reject, (p) => progress.push(JSON.parse(JSON.stringify(p))), repo);
+        });
+
+        it('generates versioned ids when the repository server contains the server url', async () => {
+            prepare(["a", "b"]);
+            const saved = [];
+            const repo = { selectedServer: SERVER + "extra", saveTo: (o, s) => { saved.push(o); s("ok"); } };
+            const { comps, progress } = await run(SERVER, repo);
+            assert.lengthOf(comps, 2);
+            assert.lengthOf(saved, 2);
+            for (const c of comps) {
+                assert.notEqual(c.id, c.shortId());
+                assert.isTrue(c.id.startsWith(SERVER));
+            }
+            assert.deepEqual(progress, [{ competencies: 2 }]);
+        });
+
+        it('generates short ids when the repository server does not contain the server url', async () => {
+            prepare(["a"]);
+            const repo = { selectedServer: SERVER, saveTo: (o, s) => s("ok") };
+            const { comps } = await run("http://other.test/", repo);
+            assert.equal(comps[0].id, comps[0].shortId());
+            assert.isTrue(comps[0].id.startsWith("http://other.test/"));
+        });
+
+        it('generates versioned ids and saves through EcRepository when there is no repository', async () => {
+            prepare(["a"]);
+            const save = sinon.stub(EcRepository, 'save').callsFake((o, s) => s("ok"));
+            const { comps } = await run(SERVER, null);
+            assert.notEqual(comps[0].id, comps[0].shortId());
+            assert.isTrue(save.calledOnce);
+        });
+
+        it('reports progress every INCREMENTAL_STEP saves and at the end', async () => {
+            prepare(["a", "b", "c", "d", "e", "f"]);
+            const repo = { selectedServer: SERVER, saveTo: (o, s) => s("ok") };
+            const { progress } = await run(SERVER, repo);
+            assert.deepEqual(progress, [{ competencies: 5 }, { competencies: 6 }]);
+        });
+    });
+});