imerss-bioinfo 1.0.0

package/test/testDataSource.js

@@ -0,0 +1,182 @@
+/* eslint-env node */
+
+"use strict";
+
+const fluid = require("infusion"),
+    jqUnit = fluid.require("node-jqunit", null, "jqUnit");
+
+require("../src/utils/dataSource.js");
+
+const hortis = fluid.registerNamespace("hortis");
+fluid.registerNamespace("hortis.tests");
+
+hortis.tests.retryResponses = {
+    resolve: {
+        sequence: [{
+            type: "resolve",
+            payload: 42
+        }],
+        expected: {
+            minTime: 0,
+            type: "resolve",
+            payload: 42
+        }
+    },
+    oneReject: {
+        sequence: [{
+            type: "reject",
+            payload: "error"
+        }, {
+            type: "resolve",
+            payload: 42
+        }],
+        expected: {
+            minTime: 900,
+            type: "resolve",
+            payload: 42
+        }
+    },
+    twoReject: {
+        sequence: [{
+            type: "reject",
+            payload: "error1"
+        }, {
+            type: "reject",
+            payload: "error2"
+        }, {
+            type: "resolve",
+            payload: 42
+        }],
+        expected: {
+            minTime: 1900,
+            type: "resolve",
+            payload: 42
+        }
+    },
+    threeReject: {
+        sequence: [{
+            type: "reject",
+            payload: "error1"
+        }, {
+            type: "reject",
+            payload: "error2"
+        }, {
+            type: "reject",
+            payload: "error3"
+        }, {
+            type: "resolve",
+            payload: 42
+        }],
+        expected: {
+            minTime: 2900,
+            type: "reject",
+            payload: "error3"
+        }
+    }
+};
+
+fluid.defaults("hortis.tests.retryingMockDataSource", {
+    gradeNames: ["fluid.dataSource.retrying", "fluid.dataSource.noencoding"],
+    members: {
+        index: 0
+    },
+    sequence: [],
+    listeners: {
+        "onRead.impl": {
+            funcName: "hortis.tests.retryingMockDataSource.impl",
+            args: ["{that}"]
+        }
+    }
+});
+
+hortis.tests.retryingMockDataSource.impl = function (that) {
+    fluid.log("Test request " + that.index + " against sequence ", that.options.sequence);
+    const record = that.options.sequence[that.index++];
+    const togo = fluid.promise();
+    togo[record.type](record.payload);
+    return togo;
+};
+
+fluid.each(hortis.tests.retryResponses, function (value, key) {
+    jqUnit.asyncTest("Test of retrying data source: " + key, function () {
+        jqUnit.expect(3);
+        const dataSource = hortis.tests.retryingMockDataSource({
+            sequence: value.sequence
+        });
+        const now = Date.now();
+        const checkResponse = function (type, payload) {
+            jqUnit.assertEquals("Expected response type", value.expected.type, type);
+            jqUnit.assertDeepEq("Expected response payload", value.expected.payload, payload);
+            const delay = (Date.now() - now);
+            jqUnit.assertTrue("Response at expected time", delay > value.expected.minTime);
+            jqUnit.start();
+        };
+        const promise = dataSource.get();
+        promise.then(function (payload) {
+            checkResponse("resolve", payload);
+        }, function (payload) {
+            checkResponse("reject", payload);
+        });
+    });
+});
+
+fluid.defaults("hortis.tests.rateLimitingDataSource", {
+    gradeNames: ["fluid.dataSource", "fluid.dataSource.withRateLimiter"],
+    members: {
+        index: 0,
+        launchTimes: []
+    },
+    sequence: [],
+    listeners: {
+        "onRead.impl": {
+            funcName: "hortis.tests.rateLimitingDataSource.impl",
+            args: ["{that}"]
+        }
+    },
+    components: {
+        encoding: {
+            type: "fluid.dataSource.encoding.none"
+        }
+    }
+});
+
+hortis.tests.rateLimitingDataSource.impl = function (that) {
+    fluid.log("Rate limiting test request " + that.index);
+    const now = Date.now();
+    that.launchTimes[that.index] = now;
+    return fluid.promise().resolve(that.index++);
+};
+
+jqUnit.asyncTest("Test of rate limiting data source: ", function () {
+    jqUnit.expect(6);
+    const dataSource = hortis.tests.rateLimitingDataSource();
+    const now = Date.now();
+    const requests = fluid.generate(5, 0).map(function () {
+        return dataSource.get();
+    });
+    const resultsPromise = fluid.promise.sequence(requests);
+    resultsPromise.then(function (results) {
+        const expected = fluid.iota(5);
+        jqUnit.assertDeepEq("Got expected results", expected, results);
+        jqUnit.assertTrue("First response received pretty soon", (dataSource.launchTimes[0] - now) < 100);
+        for (let i = 1; i < 5; ++i) {
+            jqUnit.assertTrue("Request " + (i + 1) + " is not early", (dataSource.launchTimes[i] - dataSource.launchTimes[i - 1]) > 1000);
+        }
+        jqUnit.start();
+    });
+});
+
+
+jqUnit.asyncTest("Test of in memory caching data source: ", async function () {
+    const dataSource = fluid.inMemoryCachedSource();
+    const key = {id: 1};
+    const firstResponse = await dataSource.get(key);
+    jqUnit.assertUndefined("No initial contents", firstResponse);
+    const doc = {
+        name: "Veronica peregrina xalapensis"
+    };
+    await dataSource.set(key, doc);
+    const secondResponse = await dataSource.get(key);
+    jqUnit.assertDeepEq("Stored contents", doc, secondResponse);
+    jqUnit.start();
+});

package/test/testiNatObsSource.js

@@ -0,0 +1,38 @@
+/* eslint-env node */
+
+"use strict";
+
+const fluid = require("infusion");
+
+const hortis = fluid.registerNamespace("hortis");
+
+require("../src/iNaturalist/taxonAPI.js");
+
+const source = hortis.iNatTaxonSource({
+    disableCache: false
+});
+
+// Old queries:
+// "Acmispon americanus var. americanus" - to test resolution of multiple returned taxa
+// Calandrinia ciliata - test resolution onto "name" rather than "matched name"
+// Symphyotrichum chilense x subspicatum - test normalisation of "x"
+// Veronica peregrina var. xalapensis - test not being confused by things beginning with x!
+// Abies grandis - test how we extract species name from document - led to including species in first place
+// Achillea millefolium complex - Convert rank of "complex" to "species" as per AS
+// Adenocaulon bicolor - test retrieving subclass
+// Balanus glandula/Balanus crenatus - test caching of missing values
+// {id: 47429}
+// {obsId: 86945066}
+
+const testSource = async function () {
+    try {
+        const result = await source.get({obsId: 86945066});
+        console.log("Got result ", result);
+        console.log("Got taxon name ", result.doc.results[0].taxon.name);
+
+    } catch (e) {
+        console.log("Error fetching observation ", e);
+    }
+};
+
+source.events.onCreate.then(testSource);

package/test/testiNatSource.js

@@ -0,0 +1,50 @@
+/* eslint-env node */
+
+"use strict";
+
+const fluid = require("infusion");
+
+const hortis = fluid.registerNamespace("hortis");
+
+require("../src/iNaturalist/taxonAPI.js");
+
+const source = hortis.iNatTaxonSource({
+    disableCache: false
+});
+
+// Old queries:
+// "Acmispon americanus var. americanus" - to test resolution of multiple returned taxa
+// Calandrinia ciliata - test resolution onto "name" rather than "matched name"
+// Symphyotrichum chilense x subspicatum - test normalisation of "x"
+// Veronica peregrina var. xalapensis - test not being confused by things beginning with x!
+// Abies grandis - test how we extract species name from document - led to including species in first place
+// Achillea millefolium complex - Convert rank of "complex" to "species" as per AS
+// Adenocaulon bicolor - test retrieving subclass
+// Balanus glandula/Balanus crenatus - test caching of missing values
+// {id: 47429}
+// {obsId: 86945066}
+
+const testSource = async function () {
+    try {
+        const query = "Balanus glandula/Balanus crenatus";
+        const sane = hortis.sanitizeSpeciesName(query);
+        const result = await source.get({name: sane});
+        console.log(result);
+        // const parents = await hortis.iNat.getAncestry(result.doc.id, source.byId);
+        // console.log(parents);
+        const rankTarget = {
+            Kingdom: "",
+            Phylum: "",
+            Subclass: "Magnoliidae", // test overriding
+            Order: "",
+            Genus: "",
+            Species: ""
+        };
+        await hortis.iNat.getRanks(result.doc.id, rankTarget, source.byId);
+        console.log(rankTarget);
+    } catch (e) {
+        console.log("Error fetching ancestry ", e);
+    }
+};
+
+source.events.onCreate.then(testSource);