cassproject 5.0.20 → 5.0.23

package/src/org/schema/EcOrganization.js

@@ -71,8 +71,8 @@ module.exports = class EcOrganization extends schema.Organization {
 			throw new Error("Employee is not Array");
 		let ary = this.employee;
 		let psid = person.shortId();
-		for (let i = 0; i < ary.length; i++) {
-			if (ary[i] == psid) return;
+		for (let employee of ary) {
+			if (employee == psid) return;
 		}
 		ary.push(psid);
 	}
@@ -110,7 +110,7 @@ module.exports = class EcOrganization extends schema.Organization {
 		let empAry = this.employee;
 		for (let i = 0; i < membAry.length; i++) {
 			let id = membAry[i];
-			if (id.toLowerCase().indexOf("person") > -1) {
+			if (id.toLowerCase().includes("person")) {
 				if (empAry.indexOf(id) <= -1) {
 					empAry.push(id);
 				}
@@ -132,8 +132,8 @@ module.exports = class EcOrganization extends schema.Organization {
 		if (ppkList == null) return JSON.stringify([]);
 		else {
 			let pemArray = [];
-			for (let i = 0; i < ppkList.length; i++) {
-				pemArray.push(ppkList[i].toPem());
+			for (let ppk of ppkList) {
+				pemArray.push(ppk.toPem());
 			}
 			return JSON.stringify(pemArray);
 		}
@@ -167,7 +167,6 @@ module.exports = class EcOrganization extends schema.Organization {
 			let msg = "Repository cannot be null for a rekey operation";
 			if (failure != null) failure(msg);
 			else global.auditLogger.report(global.auditLogger.LogCategory.SYSTEM, global.auditLogger.Severity.ERROR, "EcOrgRekeyAndSave", msg);
-			return;
 		} else {
 			let oldKey = await this.getCurrentOrgKey();
 			let newKey = EcPpk.generateKey();
@@ -180,7 +179,7 @@ module.exports = class EcOrganization extends schema.Organization {
 				oldKey,
 				newKey
 			);
-			this.addOrgKey(newKey);
+			await this.addOrgKey(newKey);
 			let newKeys = await EcEncryptedValue.encryptValue(
 				this.ppkListToPemArrayString(await this.getOrgKeys()),
 				EcOrganization.ORG_PPK_SET_KEY,
@@ -247,8 +246,8 @@ module.exports = class EcOrganization extends schema.Organization {
 			let ev = new EcEncryptedValue();
 			ev.copyFrom(o);
 			let orgKeysPPKPems = JSON.parse(await ev.decryptIntoString(null, null, eim));
-			for (let i = 0; i < orgKeysPPKPems.length; i++) {
-				orgKeys.push(EcPpk.fromPem(orgKeysPPKPems[i]));
+			for (let pem of orgKeysPPKPems) {
+				orgKeys.push(EcPpk.fromPem(pem));
 			}
 		} else if (o) {
 			orgKeys = o;
@@ -281,7 +280,8 @@ module.exports = class EcOrganization extends schema.Organization {
 	upgrade(eim) {
 		super.upgrade();
 		this.movePersonMembersToEmployee();
-		this.moveKeyField(eim);
+		//upgrade() is synchronous; the key move finishes in the background as before.
+		void this.moveKeyField(eim);
 	}
 	/**
 	 *  Attempts to find and return the organization's fingerprint from the id.

package/src/org/schema/EcQuestion.js

@@ -52,14 +52,14 @@ module.exports = class EcQuestion extends schema.Question {
 			return EcQuestion.HAND_GRADED_ESSAY;
 		}
 		if (this.suggestedAnswer == null) {
-			if (this.text != null && this.text.indexOf("__") != -1) {
+			if (this.text?.includes("__")) {
 				return EcQuestion.FILL_IN_THE_BLANK;
 			}
 			return EcQuestion.SHORT_ANSWER;
 		}
 		let l = this.suggestedAnswer.length;
 		if (l == 0) {
-			if (this.text != null && this.text.indexOf("__") != -1) {
+			if (this.text?.includes("__")) {
 				return EcQuestion.FILL_IN_THE_BLANK;
 			}
 			return EcQuestion.SHORT_ANSWER;
@@ -75,7 +75,7 @@ module.exports = class EcQuestion extends schema.Question {
 	cementAnswerId(id) {
 		if (this.acceptedAnswer != null) {
 			if (!EcArray.isArray(this.acceptedAnswer)) {
-				throw new Error("Accepted Answer is not Array");
+				throw new Error("Accepted Answer is not Array"); // NOSONAR - A TypeError would change the name and toString() callers see.
 			}
 			let ary = this.acceptedAnswer;
 			for (let i = 0; i < ary.length; i++) {
@@ -89,7 +89,7 @@ module.exports = class EcQuestion extends schema.Question {
 		}
 		if (this.suggestedAnswer != null) {
 			if (!EcArray.isArray(this.suggestedAnswer)) {
-				throw new Error("Suggested Answer is not Array");
+				throw new Error("Suggested Answer is not Array"); // NOSONAR - A TypeError would change the name and toString() callers see.
 			}
 			let ary = this.suggestedAnswer;
 			for (let i = 0; i < ary.length; i++) {
@@ -119,7 +119,7 @@ module.exports = class EcQuestion extends schema.Question {
 			this["acceptedAnswer"] = [];
 		}
 		if (!EcArray.isArray(this.acceptedAnswer)) {
-			throw new Error("Accepted Answer is not Array");
+			throw new Error("Accepted Answer is not Array"); // NOSONAR - A TypeError would change the name and toString() callers see.
 		}
 		let ary = this.acceptedAnswer;
 		ary.push(answer.id);
@@ -129,7 +129,7 @@ module.exports = class EcQuestion extends schema.Question {
 			this["suggestedAnswer"] = [];
 		}
 		if (!EcArray.isArray(this.suggestedAnswer)) {
-			throw new Error("Suggested Answer is not Array");
+			throw new Error("Suggested Answer is not Array"); // NOSONAR - A TypeError would change the name and toString() callers see.
 		}
 		let ary = this.suggestedAnswer;
 		ary.push(answer.id);
@@ -139,7 +139,7 @@ module.exports = class EcQuestion extends schema.Question {
 			return;
 		}
 		if (!EcArray.isArray(this.suggestedAnswer)) {
-			throw new Error("Suggested Answer is not Array");
+			throw new Error("Suggested Answer is not Array"); // NOSONAR - A TypeError would change the name and toString() callers see.
 		}
 		let ary = this.suggestedAnswer;
 		for (let i = 0; i < ary.length; i++) {
@@ -156,7 +156,7 @@ module.exports = class EcQuestion extends schema.Question {
 			return;
 		}
 		if (!EcArray.isArray(this.acceptedAnswer)) {
-			throw new Error("Accepted Answer is not Array");
+			throw new Error("Accepted Answer is not Array"); // NOSONAR - A TypeError would change the name and toString() callers see.
 		}
 		let ary = this.acceptedAnswer;
 		for (let i = 0; i < ary.length; i++) {

package/src/org/w3/skos/Concept.js

@@ -14,7 +14,7 @@ module.exports = class Concept extends EcRemoteLinkedData {
 		super("https://schema.cassproject.org/0.4/skos/", "Concept");
 	}
 
-	static TYPE_0_1 = "http://schema.cassproject.org/0.3/skos/Concept";
+	static TYPE_0_1 = "http://schema.cassproject.org/0.3/skos/Concept"; // NOSONAR - JSON-LD identifier, never fetched
 	static TYPE_0_2 = "https://schema.cassproject.org/0.3/skos/Concept";
 	static TYPE_0_3 = "https://schema.cassproject.org/0.4/skos/Concept";
 	static myType = this.TYPE_0_3;
@@ -48,10 +48,10 @@ module.exports = class Concept extends EcRemoteLinkedData {
 		}
 	}
 	getTypes() {
-		let a = [];
-		a.push(Concept.TYPE_0_3);
-		a.push(Concept.TYPE_0_2);
-		a.push(Concept.TYPE_0_1);
-		return a;
+		return [
+			Concept.TYPE_0_3,
+			Concept.TYPE_0_2,
+			Concept.TYPE_0_1,
+		];
 	}
 };

package/src/org/w3/skos/ConceptScheme.js

@@ -14,7 +14,7 @@ module.exports = class ConceptScheme extends EcRemoteLinkedData {
 	constructor() {
 		super("https://schema.cassproject.org/0.4/skos/", "ConceptScheme");
 	}
-	static TYPE_0_1 = "http://schema.cassproject.org/0.3/skos/ConceptScheme";
+	static TYPE_0_1 = "http://schema.cassproject.org/0.3/skos/ConceptScheme"; // NOSONAR - JSON-LD identifier, never fetched
 	static TYPE_0_2 = "https://schema.cassproject.org/0.3/skos/ConceptScheme";
 	static TYPE_0_3 = "https://schema.cassproject.org/0.4/skos/ConceptScheme";
 	static myType = this.TYPE_0_3;
@@ -41,10 +41,10 @@ module.exports = class ConceptScheme extends EcRemoteLinkedData {
 		}
 	}
 	getTypes() {
-		let a = [];
-		a.push(ConceptScheme.TYPE_0_3);
-		a.push(ConceptScheme.TYPE_0_2);
-		a.push(ConceptScheme.TYPE_0_1);
-		return a;
+		return [
+			ConceptScheme.TYPE_0_3,
+			ConceptScheme.TYPE_0_2,
+			ConceptScheme.TYPE_0_1,
+		];
 	}
 };

package/src/org/w3/skos/EcConcept.js

@@ -6,12 +6,11 @@ const EcRepository = require("../../cassproject/ebac/repository/EcRepository");
 module.exports = class EcConcept extends Concept {
 	constructor() {
 		super();
-		let me = this;
 		if (EcConcept.template != null) {
 			let you = EcConcept.template;
 			for (let key in you) {
 				if (typeof you[key] != "function")
-					me[key.replace("@", "")] = you[key];
+					this[key.replace("@", "")] = you[key];
 			}
 		}
 	}

package/src/org/w3/skos/EcConceptScheme.js

@@ -6,12 +6,11 @@ const EcRepository = require("../../cassproject/ebac/repository/EcRepository");
 module.exports = class EcConceptScheme extends ConceptScheme {
 	constructor() {
 		super();
-		let me = this;
 		if (EcConceptScheme.template != null) {
 			let you = EcConceptScheme.template;
 			for (let key in you) {
 				if (typeof you[key] != "function")
-					me[key.replace("@", "")] = you[key];
+					this[key.replace("@", "")] = you[key];
 			}
 		}
 	}

package/src/test/0.start.test.js

@@ -1,5 +1,5 @@
 
-if ((typeof Cypress !== 'undefined') && Cypress != null && Cypress.env != null)
+if ((typeof Cypress !== 'undefined') && Cypress != null)
 afterEach(() => {
     if (this.currentTest.state === 'failed') {
         Cypress.runner.end();

package/src/test/0.testLibraries.test.js

@@ -0,0 +1,172 @@
+// Checks that the parts of chai and sinon these tests rely on still behave as
+// expected, so an upgrade cannot make assertions pass for the wrong reason.
+const chai = require('chai');
+const sinon = require('sinon');
+
+const assert = chai.assert;
+const expect = chai.expect;
+
+// Runs fn and returns its chai AssertionError, failing if it did not throw one.
+function failure(fn) {
+    try {
+        fn();
+    } catch (e) {
+        if (e instanceof chai.AssertionError) return e;
+        throw e;
+    }
+    throw new Error('assertion did not fail');
+}
+
+describe('chai', () => {
+    it('assert passes and fails as expected', () => {
+        assert.equal(1, '1');
+        failure(() => assert.equal(1, 2));
+        assert.strictEqual(1, 1);
+        failure(() => assert.strictEqual(1, '1'));
+        assert.deepEqual({ a: [1, { b: 2 }] }, { a: [1, { b: 2 }] });
+        failure(() => assert.deepEqual({ a: [1] }, { a: [2] }));
+        assert.notEqual(1, 2);
+        failure(() => assert.notEqual(1, 1));
+        assert.isTrue(true);
+        failure(() => assert.isTrue(1));
+        assert.isFalse(false);
+        failure(() => assert.isFalse(0));
+        assert.isNull(null);
+        failure(() => assert.isNull(undefined));
+        assert.isNotNull(0);
+        failure(() => assert.isNotNull(null));
+        assert.isUndefined(undefined);
+        failure(() => assert.isUndefined(null));
+        assert.isDefined(null);
+        failure(() => assert.isDefined(undefined));
+        assert.isString('s');
+        failure(() => assert.isString(1));
+        assert.isObject({});
+        failure(() => assert.isObject('s'));
+        assert.isFunction(() => 0);
+        failure(() => assert.isFunction({}));
+        assert.isNaN(NaN);
+        failure(() => assert.isNaN(1));
+        assert.isAbove(2, 1);
+        failure(() => assert.isAbove(1, 1));
+        assert.isBelow(1, 2);
+        failure(() => assert.isBelow(2, 2));
+        assert.include([1, 2], 2);
+        assert.include('abc', 'b');
+        failure(() => assert.include([1, 2], 3));
+        assert.match('abc', /b/);
+        failure(() => assert.match('abc', /d/));
+        assert.lengthOf([1, 2], 2);
+        failure(() => assert.lengthOf([1], 2));
+        assert.exists(0);
+        failure(() => assert.exists(null));
+        class A { }
+        class B extends A { }
+        assert.instanceOf(new B(), A);
+        failure(() => assert.instanceOf({}, A));
+        assert.notInstanceOf(new A(), B);
+        failure(() => assert.notInstanceOf(new B(), A));
+        failure(() => assert.fail('message'));
+        assert.equal(failure(() => assert.fail('message')).message, 'message');
+    });
+
+    it('expect passes and fails as expected', () => {
+        expect(1).to.equal(1);
+        failure(() => expect(1).to.equal(2));
+        expect({ a: [1] }).to.deep.equal({ a: [1] });
+        failure(() => expect({ a: [1] }).to.deep.equal({ a: [2] }));
+        expect(true).to.be.true;
+        failure(() => expect(1).to.be.true);
+        expect(false).to.be.false;
+        failure(() => expect(0).to.be.false);
+        expect([1]).to.be.an('array').with.lengthOf(1);
+        failure(() => expect([1]).to.be.an('array').with.lengthOf(2));
+        expect('s').to.be.a('string');
+        failure(() => expect(1).to.be.a('string'));
+        expect(new Date()).to.be.an.instanceof(Date);
+        failure(() => expect({}).to.be.an.instanceof(Date));
+        expect('Row 2: x').to.contain('Row 2');
+        failure(() => expect('Row 2').to.contain('Row 3'));
+        expect([1, 2]).to.include(2);
+        failure(() => expect([1, 2]).to.include(3));
+        expect([1, 2]).to.not.include(3);
+        failure(() => expect([1, 2]).to.not.include(2));
+    });
+
+    it('should is available', () => {
+        const should = chai.should();
+        (1).should.equal(1);
+        failure(() => (1).should.equal(2));
+        should.not.exist(null);
+    });
+});
+
+describe('sinon', () => {
+    afterEach(() => sinon.restore());
+
+    it('spies record calls and arguments', () => {
+        const target = { f: (a) => a * 2 };
+        const spy = sinon.spy(target, 'f');
+        assert.isFalse(spy.called);
+        assert.equal(target.f(3), 6);
+        assert.isTrue(spy.called);
+        assert.isTrue(spy.calledOnce);
+        assert.equal(spy.callCount, 1);
+        assert.isTrue(spy.calledWith(3));
+        assert.isFalse(spy.calledWith(4));
+        assert.deepEqual(spy.firstCall.args, [3]);
+        assert.isTrue(spy.calledWith(sinon.match.any));
+        assert.isTrue(spy.calledWith(sinon.match.number));
+        assert.isFalse(spy.calledWith(sinon.match.string));
+    });
+
+    it('stubs resolve, reject, return and call fakes', async () => {
+        const target = { a: () => 1, b: () => 1, c: () => 1, d: () => 1 };
+        sinon.stub(target, 'a').resolves(5);
+        sinon.stub(target, 'b').rejects(new Error('no'));
+        sinon.stub(target, 'c').returns(7);
+        sinon.stub(target, 'd').callsFake((x) => x + 1);
+        assert.equal(await target.a(), 5);
+        let error;
+        await target.b().catch((e) => { error = e; });
+        assert.equal(error.message, 'no');
+        assert.equal(target.c(), 7);
+        assert.equal(target.d(1), 2);
+    });
+
+    it('stubs can be changed after creation and expose the original', () => {
+        const target = { f: () => 'original' };
+        const stub = sinon.stub(target, 'f').returns('first');
+        assert.equal(target.f(), 'first');
+        stub.callsFake(() => 'second');
+        assert.equal(target.f(), 'second');
+        assert.equal(stub.wrappedMethod(), 'original');
+        stub.rejects(new Error('later'));
+        return target.f().then(() => assert.fail('should reject'), (e) => assert.equal(e.message, 'later'));
+    });
+
+    it('restores originals, individually and all at once', () => {
+        const target = { f: () => 'f', g: () => 'g' };
+        const f = sinon.stub(target, 'f').returns('stubbed');
+        sinon.stub(target, 'g').returns('stubbed');
+        f.restore();
+        assert.equal(target.f(), 'f');
+        assert.equal(target.g(), 'stubbed');
+        sinon.restore();
+        assert.equal(target.g(), 'g');
+        assert.isUndefined(target.f.restore);
+    });
+
+    it('fake timers freeze the clock and restore it', () => {
+        const clock = sinon.useFakeTimers({ now: 1700000000000 });
+        try {
+            assert.equal(new Date().getTime(), 1700000000000);
+            assert.equal(Date.now(), 1700000000000);
+            clock.tick(5);
+            assert.equal(Date.now(), 1700000000005);
+        } finally {
+            clock.restore();
+        }
+        assert.isAbove(Date.now(), 1700000000005);
+    });
+});

package/src/test/1.ASNImport.test.js

@@ -0,0 +1,122 @@
+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 TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+const TITLE = "http://purl.org/dc/elements/1.1/title";
+const DESC = "http://purl.org/dc/terms/description";
+const CHILD = "http://purl.org/gem/qualifiers/hasChild";
+const STATEMENT = "http://purl.org/ASN/schema/core/Statement";
+const DOCUMENT = "http://purl.org/ASN/schema/core/StandardDocument";
+
+function asnDocument() {
+    return {
+        "http://asn.test/D1": { [TYPE]: [{ value: DOCUMENT }], [TITLE]: [{ value: "Doc" }], [DESC]: [{ value: "Doc desc" }], [CHILD]: [{ value: "http://asn.test/S1" }] },
+        "http://asn.test/S1": { [TYPE]: [{ value: STATEMENT }], [DESC]: [{ value: "Statement one" }], [CHILD]: [{ value: "http://asn.test/S2" }, { value: "http://asn.test/S3" }] },
+        "http://asn.test/S2": { [TYPE]: [{ value: STATEMENT }], [TITLE]: [{ value: "Two" }] },
+        "http://asn.test/S3": { [TYPE]: [{ value: STATEMENT }], [TITLE]: [{ value: "Three" }], [DESC]: [{ value: "Three desc" }] }
+    };
+}
+
+describe('ASNImport', () => {
+    afterEach(() => sinon.restore());
+
+    beforeEach(() => {
+        ASNImport.jsonCompetencies = {};
+        ASNImport.jsonFramework = null;
+        ASNImport.frameworkUrl = "";
+        ASNImport.lookThroughSource(asnDocument());
+    });
+
+    const run = (serverUrl, createFramework, repo) => new Promise((resolve, reject) => {
+        const failures = [];
+        ASNImport.importCompetencies(serverUrl, null, createFramework, (comps, fw) => resolve({ comps, fw, failures }), (e) => { failures.push(e); reject(e); }, () => { }, repo);
+    });
+
+    it('finds the framework, competencies and relation count', () => {
+        assert.equal(ASNImport.frameworkUrl, "http://asn.test/D1");
+        assert.deepEqual(Object.keys(ASNImport.jsonCompetencies), ["http://asn.test/S1", "http://asn.test/S2", "http://asn.test/S3"]);
+        assert.equal(ASNImport.competencyCount, 3);
+        assert.equal(ASNImport.relationCount, 2);
+    });
+
+    it('imports competencies keyed by their ASN ids and narrows relations with versioned ids', async () => {
+        const saved = [];
+        const repo = { selectedServer: SERVER, saveTo: (o, s) => { saved.push(o); s("ok"); } };
+        const { comps, fw } = await run(SERVER, false, repo);
+        assert.isNull(fw);
+        assert.deepEqual(comps.map(c => [c.id, c.name, c.description]), [
+            ["http://asn.test/S1", "Statement one", "Statement one"],
+            ["http://asn.test/S2", "Two", undefined],
+            ["http://asn.test/S3", "Three", "Three desc"]
+        ]);
+        const relations = saved.filter(o => o instanceof EcAlignment);
+        assert.deepEqual(relations.map(r => [r.source, r.target, r.relationType]).sort(), [
+            ["http://asn.test/S2", "http://asn.test/S1", "narrows"],
+            ["http://asn.test/S3", "http://asn.test/S1", "narrows"]
+        ]);
+        for (const r of relations) {
+            assert.isTrue(r.id.startsWith(SERVER));
+            assert.notEqual(r.id, r.shortId());
+        }
+    });
+
+    it('generates short relation ids when the repository server does not contain the server url', async () => {
+        const saved = [];
+        const repo = { selectedServer: SERVER, saveTo: (o, s) => { saved.push(o); s("ok"); } };
+        await run("http://other.test/", false, repo);
+        const relations = saved.filter(o => o instanceof EcAlignment);
+        assert.lengthOf(relations, 2);
+        for (const r of relations) {
+            assert.isTrue(r.id.startsWith("http://other.test/"));
+            assert.equal(r.id, r.shortId());
+        }
+    });
+
+    it('generates versioned relation ids and saves through EcRepository without a repository', async () => {
+        const saved = [];
+        sinon.stub(EcRepository, 'save').callsFake((o, s) => { saved.push(o); s("ok"); });
+        const { fw } = await run(SERVER, true, null);
+        const relations = saved.filter(o => o instanceof EcAlignment);
+        assert.lengthOf(relations, 2);
+        for (const r of relations)
+            assert.notEqual(r.id, r.shortId());
+        assert.equal(fw.id, "http://asn.test/D1");
+        assert.equal(fw.name, "Doc");
+        assert.equal(fw.description, "Doc desc");
+        assert.deepEqual(fw.competency, ["http://asn.test/S1", "http://asn.test/S2", "http://asn.test/S3"]);
+        assert.lengthOf(fw.relation, 2);
+    });
+
+    describe('createFramework without a framework url', () => {
+        const create = (serverUrl, repo) => new Promise((resolve, reject) => {
+            ASNImport.importedFramework = new EcFramework();
+            ASNImport.frameworkUrl = null;
+            ASNImport.competencies = {};
+            ASNImport.createFramework(serverUrl, null, (comps, fw) => resolve(fw), reject, repo);
+        });
+
+        it('generates a versioned id when the repository server contains the server url', async () => {
+            const fw = await create(SERVER, { selectedServer: SERVER, saveTo: (o, s) => s("ok") });
+            assert.isTrue(fw.id.startsWith(SERVER));
+            assert.notEqual(fw.id, fw.shortId());
+        });
+
+        it('generates a short id when the repository server does not contain the server url', async () => {
+            const fw = await create("http://other.test/", { selectedServer: SERVER, saveTo: (o, s) => s("ok") });
+            assert.isTrue(fw.id.startsWith("http://other.test/"));
+            assert.equal(fw.id, fw.shortId());
+        });
+
+        it('generates a versioned id without a repository', async () => {
+            sinon.stub(EcRepository, 'save').callsFake((o, s) => s("ok"));
+            const fw = await create(SERVER, null);
+            assert.isTrue(fw.id.startsWith(SERVER));
+            assert.notEqual(fw.id, fw.shortId());
+        });
+    });
+});

package/src/test/1.CSVExport.test.js

@@ -0,0 +1,57 @@
+require('../../index.js');
+const chai = require('chai');
+
+const assert = chai.assert;
+
+const CTX = "https://schema.cassproject.org/0.4";
+
+describe('CSVExport.CSVExportProcess', () => {
+    const competency = (props) => Object.assign({ "@context": CTX, "@type": "Competency" }, props);
+
+    it('skips falsy entries when building the export', () => {
+        const p = new CSVExport.CSVExportProcess();
+        p.buildExport([null, competency({ "@id": "http://x/1", name: "One" }), undefined, 0, "", false, competency({ "@id": "http://x/2", name: "Two" })], false);
+        assert.lengthOf(p.csvOutput, 2);
+        assert.equal(p.csvOutput[0].name, "One");
+        assert.equal(p.csvOutput[1].name, "Two");
+    });
+
+    it('flattens nested objects with dotted names when not piped', () => {
+        const p = new CSVExport.CSVExportProcess();
+        p.buildExport([competency({ "@id": "http://x/1", name: { "@language": "en", "@value": "One" } })], false);
+        assert.equal(p.csvOutput[0]["name.@language"], "en");
+        assert.equal(p.csvOutput[0]["name.@value"], "One");
+    });
+
+    it('joins piped arrays and objects with |', () => {
+        const p = new CSVExport.CSVExportProcess();
+        p.buildExport([competency({
+            "@id": "http://x/1",
+            "ceasn:keyword": ["a", "b"],
+            "ceasn:nested": { first: "x", second: ["y", "z"] }
+        })], true);
+        assert.equal(p.csvOutput[0]["ceasn:keyword"], "a|b");
+        assert.equal(p.csvOutput[0]["ceasn:nested"], "x|y|z");
+    });
+
+    it('formats piped ceterms:versionIdentifier entries as code~type~uri', () => {
+        const p = new CSVExport.CSVExportProcess();
+        p.buildExport([competency({
+            "@id": "http://x/1",
+            "ceterms:versionIdentifier": [
+                { "ceterms:identifierValueCode": "1.0", "ceterms:identifierTypeName": { "en-us": "Version" }, "ceterms:identifierType": "http://t/1" },
+                { "ceterms:identifierValueCode": "2.0" },
+                { "ceterms:identifierTypeName": { "en-us": "Only" } }
+            ]
+        })], true);
+        // Entries without an identifierType get no "|" separator; the final character is always dropped.
+        assert.equal(p.csvOutput[0]["ceterms:versionIdentifier"], "1.0~Version~http://t/1|2.0~Only");
+    });
+
+    it('fills missing columns with empty strings on earlier rows', () => {
+        const p = new CSVExport.CSVExportProcess();
+        p.buildExport([competency({ "@id": "http://x/1", name: "One" }), competency({ "@id": "http://x/2", name: "Two", description: "D" })], false);
+        assert.strictEqual(p.csvOutput[0].description, "");
+        assert.equal(p.csvOutput[1].description, "D");
+    });
+});