catalog.spec.js

/*
This is part of datacrate, a node.js library for working with 
DataCrates.  Copyright (C) 2018  University of Technology Sydney

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

const chai = require('chai');
const chaiFiles = require('chai-files');
chai.use(chaiFiles);
const _ = require('lodash');
const assert = chai.assert;
const expect = chai.expect;
const file = chaiFiles.file;

const fs = require('fs-extra');

const catalog = require('../lib/catalog.js');

const ORG = { 
	'id': 'https://www.uts.edu.au',
	'name': 'University of Technology Sydney'
};

const OWNER = 'https://orcid.org/0000-0001-5152-5307';
const APPROVER = 'admin';

const DATASET_ID = 'DATASET_ID';

// get catalog item by id: returns null if the item isn't unique, because
// this should always make the test fail

function get_id(c, id) {
	const match = c['@graph'].filter((item) => item['@id'] === id);
	if( match.length ) {
		if( match.length > 1 ) {
			console.error(`Warning: catalog has ${match.length} items with ID ${id}`);
			return null;
		} else {
			return match[0];
		}
	} else {
		return null;
	}
}

// this one returns an array of items with the requested type

function get_type(c, t) {
	return c['@graph'].filter((item) => item['@type'] === t);
}


var mdp, dp, cj, cjds;


describe("Convert a ReDBox 2.0 DataPub to CATALOG.json", () => {

	before(async () => {
		mdp = await fs.readJson('./test_data/datapub.json');
		dp = mdp['metadata'];
		cj = await catalog.datapub2catalog({
			'id': DATASET_ID,
			'datapub': dp,
			'organisation': ORG,
			'owner': OWNER,
			'approver': APPROVER
		});
		const roots = cj['@graph'].filter((item) => {return item['path'] === 'data/'});
		cjds = roots[0];
		await fs.writeJson('./test_data/CATALOG.json', cj, { 'spaces': 4 });
	});

	it("has a root dataset", () => {
  		expect(cjds).to.be.a('object');
	});

	it("has string @id values for every graph item", () => {
		cj['@graph'].map((i) => {
			console.log("graph items @id: " + JSON.stringify(i['@id']));
			expect(i).to.have.property('@id');
			expect(i['@id']).to.be.a('string');
		})
	});


	it("has a dataset item with correct metadata", () => {
		assert(cj, "Got an object");
		assert(cj['@graph'], "Catalog has a @graph");
		const dataset = get_id(cj, DATASET_ID);
		assert(dataset, "Graph has an item with id " + DATASET_ID);
		expect(dataset['name']).to.equal(dp['title']);
		expect(dataset['description']).to.equal(dp['description']);
		expect(dataset['publisher']['@id']).to.equal(ORG['id'])
		expect(dataset['keywords']).to.equal(dp['finalKeywords'].join(', '));
	});

	it("has a create action with the owner", () => {
		const cas = get_type(cj, 'CreateAction');
		expect(cas).to.have.length(1);
		const ca = cas[0];
		expect(ca['agent']['@id']).to.equal(OWNER);
	});

	it("has an update action with the approver", () => {
		const uas = get_type(cj, 'UpdateAction');
		expect(uas).to.have.length(1);
		const ua = uas[0];
		expect(ua['agent']['@id']).to.equal(APPROVER);
	});

	it("has the payload files", () => {
		const files = get_type(cj, "File");
		const datalocs = dp['dataLocations'];
		expect(files).to.have.length(datalocs.length);
		const fids = files.map((f) => f['@id']).sort();
		const dlids = datalocs.map((dl) => dl['name']).sort();
		expect(fids).to.eql(dlids);
	});

// const DATASET_PROPERTIES = {
// 	'about': make_subjects,
// 	'spatialCoverage': make_spatial,
// 	'temporalCoverate': make_temporal,
// 	'funder': make_funders,
// 	'licence': make_licence,
// 	'citation': make_related_works
// };

	it("has subjects", () => {
		// FORs and SEOs
		const fields = [ 'dc:subject_anzsrc:for', 'dc:subject_anzsrc:seo'];
		const SUBJECT_IRI_PREFIX = {
    	'dc:subject_anzsrc:for': '_:FOR/',
    	'dc:subject_anzsrc:seo': '_:SEO/'
		};
		const about = cjds['about'].map((i) => i['@id']);
		_.forEach(fields, (field) => {
			const pref = SUBJECT_IRI_PREFIX[field];
			const expectsubs = dp[field].map((f) => { return f['name'] });
			const subjects = cj['@graph'].filter((i) => { return i['@id'].startsWith(pref) });
			const gotsubs = subjects.map((f) => { return f['name']} );
			expect(gotsubs.sort()).to.eql(expectsubs.sort());			
		})
	});

	it("has spatial coverage", () => {
		assert(false);
	});

	it("has temporal coverage", () => {
		assert(false);
	});

	it("has funders", () => {
		assert(false);
	});

	it("has a licence", () => {
		assert(false);
	});

	it("has related works", () => {
		assert(false);
	});


});