nodejs-nomer 1.3.9 → 1.3.10

package/dist/result.js

@@ -36,7 +36,7 @@ var Result = exports["default"] = /*#__PURE__*/function () {
       var columns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
       var arr = [];
       result.split('\n').forEach(function (line) {
-        arr.push(line.split('\t'));
+        if (line.trim()) arr.push(line.split('\t'));
       });
       return columns ? arr.map(function (v) {
         return Object.assign.apply(Object, _toConsumableArray(columns.map(function (k, i) {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "nodejs-nomer",
-  "version": "1.3.9",
+  "version": "1.3.10",
   "description": "NodeJS wrapper for nomer",
   "bin": {
     "nomer": "./bin/nomer"
   },
   "main": "index.js",
   "scripts": {
-    "test": "npm run test",
+    "test": "jest",
     "build": "babel src -d dist",
     "preinstall": "./install_nomer.sh"
   },
@@ -27,13 +27,15 @@
   "homepage": "https://github.com/zedomel/nodejs-nomer#readme",
   "devDependencies": {
     "@babel/cli": "^7.24.8",
-    "@babel/core": "^7.24.9",
-    "@babel/preset-env": "^7.24.8",
+    "@babel/core": "^7.28.5",
+    "@babel/preset-env": "^7.28.5",
+    "babel-jest": "^30.2.0",
     "babel-loader": "^9.1.3",
+    "jest": "^30.2.0",
     "webpack": "^5.93.0",
     "webpack-cli": "^5.1.4"
   },
   "dependencies": {
     "properties-file": "^3.5.1"
   }
-}
+}

package/src/result.js

@@ -9,7 +9,8 @@ export default class Result {
     static tsv(result, columns = null) {
         const arr = [];
         result.split('\n').forEach((line) => {
-            arr.push(line.split('\t'));
+            if (line.trim())
+                arr.push(line.split('\t'));
         });
 
         return columns ? arr.map((v) => Object.assign(...columns.map((k, i) => ({ [k]: v[i] })))) : arr

package/test/index.test.js

@@ -0,0 +1,334 @@
+import { Nomer } from '../src/index';
+import readline from "readline";
+import fs from "fs"
+
+describe('Nomer Integration Tests', () => {
+    let nomer;
+
+    beforeAll(() => {
+        // Initialize Nomer instance
+        nomer = new Nomer();
+    });
+
+    describe('version', () => {
+        it('should return nomer version string', () => {
+            const result = nomer.version();
+            expect(result).toBeTruthy();
+            expect(result).toContain('0.5.17');
+        });
+    });
+
+    describe('properties', () => {
+        it('should return properties configuration', () => {
+            const result = nomer.properties();
+            expect(result).toBeTruthy();
+            expect(result).toContain('nomer.');
+        });
+    });
+
+    describe('inputSchema', () => {
+        it('should return input schema', () => {
+            const result = nomer.inputSchema();
+            expect(result).toBeTruthy();
+            // Should be valid JSON
+            expect(() => JSON.parse(result)).not.toThrow();
+        });
+    });
+
+    describe('outputSchema', () => {
+        it('should return output schema', () => {
+            const result = nomer.outputSchema();
+            expect(result).toBeTruthy();
+            // Should be valid JSON
+            expect(() => JSON.parse(result)).not.toThrow();
+        });
+    });
+
+    describe('matcher', () => {
+        it('should return list of matchers in tsv format', () => {
+            const result = nomer.matcher();
+            expect(result).toBeTruthy();
+            expect(result).toContain('col'); // TSV format
+        });
+
+        it('should return list of matchers in json format', () => {
+            const result = nomer.matcher('json');
+            expect(result).toBeTruthy();
+            expect(() => JSON.parse(result)).not.toThrow();
+        });
+
+        it('should return verbose matcher information', () => {
+            const result = nomer.matcher('tsv', true);
+            expect(result).toBeTruthy();
+            expect(result).toContain('col');
+        });
+    });
+
+    describe('append', () => {
+        it('should append taxonomic information for valid species', () => {
+            const result = nomer.append('\tHomo sapiens\t', 'col');
+            expect(result).toBeTruthy();
+            expect(result).toContain('HAS_ACCEPTED_NAME');
+        });
+
+        it('should return result in json format', () => {
+            const result = nomer.append('\tHomo sapiens\t', 'col', 'json');
+            expect(result).toBeTruthy();
+            expect(() => JSON.parse(result)).not.toThrow();
+        });
+
+        it('should handle invalid taxa gracefully', () => {
+            const result = nomer.append('\tInvalidTaxonXYZ123\t', 'col');
+            expect(result).toBeTruthy();
+            expect(result).toContain('NONE');
+        });
+    });
+
+    describe('replace', () => {
+        it('should replace query with matched taxonomic information', () => {
+            const result = nomer.replace('\tHomo sapiens\t', 'col');
+            expect(result).toBeTruthy();
+            expect(result).toContain('COL:6MB3T')
+        });
+
+        it('should handle invalid taxa', () => {
+            const query = '\tInvalidtaxonXYZ123\t';
+            const result = nomer.replace(query, 'col');
+            expect(result).toBeTruthy();
+            expect(result).toContain('null');
+        });
+    });
+
+    describe('appendAsync', () => {
+        it('should return a spawn process', (done) => {
+            const process = nomer.appendAsync('col');
+
+            expect(process).toBeTruthy();
+            expect(process.stdin).toBeTruthy();
+            expect(process.stdout).toBeTruthy();
+            expect(process.stderr).toBeTruthy();
+
+            let output = '';
+
+            process.stdout.on('data', (data) => {
+                output += data.toString();
+            });
+
+            process.on('close', (code) => {
+                expect(code).toBe(0);
+                expect(output).toBeTruthy();
+                expect(output).toContain('HAS_ACCEPTED_NAME');
+                done();
+            });
+
+            // Write test data and close stdin
+            process.stdin.write('\tHomo sapiens\t\n');
+            process.stdin.end();
+        }, 10000);
+
+        it('should handle streaming multiple queries', (done) => {
+            const process = nomer.appendAsync('col');
+
+            let output = '';
+
+            process.stdout.on('data', (data) => {
+                output += data.toString();
+            });
+
+            process.on('close', (code) => {
+                expect(code).toBe(0);
+                expect(output).toBeTruthy();
+                // Each line should be valid JSON
+                const lines = output.trim().split('\n');
+                lines.forEach(line => {
+                    if (line.trim()) {
+                        expect(line).toContain('HAS_ACCEPTED_NAME');
+                    }
+                });
+                done();
+            });
+
+            // Write multiple queries
+            process.stdin.write('\tHomo sapiens\t\n');
+            process.stdin.write('\tCanis lupus\t\n');
+            process.stdin.end();
+        }, 10000);
+    });
+
+    it('should handle streaming multiple queries in json', (done) => {
+        const process = nomer.appendAsync('col', 'json');
+
+        let output = '';
+
+        process.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+
+        process.on('close', (code) => {
+            expect(code).toBe(0);
+            expect(output).toBeTruthy();
+            // Each line should be valid JSON
+            const lines = output.trim().split('\n');
+            lines.forEach(line => {
+                if (line.trim()) {
+                    expect(() => JSON.parse(line)).not.toThrow();
+                }
+            });
+            done();
+        });
+
+        // Write multiple queries
+        process.stdin.write('\tHomo sapiens\t\n');
+        process.stdin.write('\tCanis lupus\t\n');
+        process.stdin.end();
+    }, 10000);
+
+    it('should handle streaming multiple wht pipe split', (done) => {
+        const process = nomer.appendAsync('col');
+
+        let output = [];
+
+        const rl = readline.createInterface({ input: process.stdout });
+        rl.on('line', (line) => {
+            const trimmed = line.replace(/\r$/, ''); // strip CR if present
+            if (trimmed.length > 0) {
+                output.push(trimmed);
+            }
+        });
+
+        process.on('close', (code) => {
+            expect(code).toBe(0);
+            expect(output).toBeTruthy();
+            // Each line should be valid JSON
+            output.forEach(line => {
+                if (line.trim()) {
+                    expect(line).toMatch(/HAS_ACCEPTED_NAME|SYNONYM_OF/);
+                }
+            });
+            done();
+        });
+
+        // Write multiple queries
+        process.stdin.write('\tHomo sapiens\t\n');
+        process.stdin.write('\tCanis lupus\t\n');
+        process.stdin.write('\tBauhinia acuminata\t\n');
+        process.stdin.end();
+    }, 10000);
+
+    // describe('clean', () => {
+    //     it('should execute clean command', () => {
+    //         const result = nomer.clean();
+    //         // Clean may return empty or success message
+    //         expect(result !== null).toBe(true);
+    //     });
+    // });
+
+    describe('Nomer with custom properties', () => {
+        it('should use custom properties file', () => {
+            // Create a nomer instance with properties
+            const tempFile = './test/test.properties';
+            try {
+                fs.writeFileSync(tempFile, 'nomer.test.property=value\n');
+                const customNomer = new Nomer(tempFile);
+                const result = customNomer.properties();
+                expect(result).toBeTruthy();
+                expect(result).toContain('nomer.test.property=value');
+            } finally {
+                fs.unlinkSync(tempFile);
+            }
+        });
+
+        it('should use custom echo option', () => {
+            const customNomer = new Nomer(null, '-n');
+            const result = customNomer.append('\Homo sapiens\t');
+            expect(result).toBeTruthy();
+        });
+    });
+
+    describe('toJson', () => {
+        it('should convert result to json', () => {
+            const tsvResult = nomer.append('\tHomo sapiens\t', 'col', 'json');
+            const jsonResult = nomer.toJson(tsvResult);
+            expect(jsonResult).toBeTruthy();
+            expect(Array.isArray(jsonResult)).toBe(true);
+            if (jsonResult.length > 0) {
+                expect(typeof jsonResult[0]).toBe('object');
+                expect(jsonResult[0]).toHaveProperty('species');
+            }
+        });
+    });
+
+    describe('toArray', () => {
+        it('should convert result to array', () => {
+            const result = nomer.append('\tHomo sapiens\t', 'col');
+            const arrayResult = nomer.toArray(result);
+            expect(arrayResult).toBeTruthy();
+            expect(Array.isArray(arrayResult)).toBe(true);
+        });
+
+        it('should convert result to array with custom columns', () => {
+            const result = nomer.append('\tHomo sapiens\t', 'col');
+            const columns = ['id', 'name'];
+            const arrayResult = nomer.toArray(result, columns);
+            expect(arrayResult).toBeTruthy();
+            expect(Array.isArray(arrayResult)).toBe(true);
+            if (arrayResult.length > 0) {
+                expect(arrayResult[0]).toHaveProperty('id');
+                expect(arrayResult[0]).toHaveProperty('name');
+            }
+        });
+
+        it('should convert  streaming result to array', (done) => {
+            const process = nomer.appendAsync('col');
+
+            let output = '';
+            process.stdout.on('data', (data) => {
+                if (data.toString().trim())
+                    output += data.toString();
+            });
+
+            process.on('close', (code) => {
+                expect(code).toBe(0);
+                expect(output).toBeTruthy();
+                const arrayResult = nomer.toArray(output);
+                expect(arrayResult).toBeTruthy();
+                expect(Array.isArray(arrayResult)).toBe(true);
+                // Each line should be valid JSON
+                arrayResult.forEach(arr => {
+                    expect(arr[3]).toMatch(/HAS_ACCEPTED_NAME|SYNONYM_OF/);
+                });
+                done();
+            });
+
+            // Write multiple queries
+            process.stdin.write('\tHomo sapiens\t\n');
+            process.stdin.write('\tCanis lupus\t\n');
+            process.stdin.write('\tBauhinia acuminata\t\n');
+            process.stdin.end();
+        }, 10000);
+    });
+
+    describe('toObject', () => {
+        it('should convert result to object with schema', () => {
+            const result = nomer.append('\tHomo sapiens\t', 'col');
+            const objectResult = nomer.toObject(result);
+            expect(objectResult).toBeTruthy();
+            expect(Array.isArray(objectResult)).toBe(true);
+            if (objectResult.length > 0) {
+                expect(typeof objectResult[0]).toBe('object');
+            }
+        });
+    });
+
+    describe('getPropertiesPath', () => {
+        it('should return null when no properties path is set', () => {
+            const testNomer = new Nomer();
+            expect(testNomer.getPropertiesPath()).toBe(null);
+        });
+
+        it('should return properties path when set', () => {
+            const testNomer = new Nomer('./test.properties');
+            expect(testNomer.getPropertiesPath()).toBe('./test.properties');
+        });
+    });
+});

package/test/script.js

@@ -0,0 +1,48 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const Nomer = require("nodejs-nomer");
+
+const tempFilePath = path.join(os.tmpdir(), 'nomer.properties');
+fs.writeFileSync(tempFilePath, `nomer.schema.input=[{"column":0,"type":"externalId"},{"column": 1,"type":"name"},{"column": 2,"type":"path"}]`);
+
+console.log(tempFilePath);
+const nomer = new Nomer.Nomer(tempFilePath);
+
+console.time("version")
+console.log(nomer.version());
+console.timeEnd("version")
+
+
+console.time("append async")
+const process = nomer.appendAsync("gbif")
+process.stdout.on('data', (data) => {
+    const obj = nomer.toObject(data.toString()).filter((obj) => obj.matchType !== "NONE")
+    console.log(obj);
+})
+process.stdout.on('end', () => {
+    console.log('append async end');
+})
+
+process.stdin.on('error', (e) => {
+    console.log('stdin error: ' + e)
+});
+
+// process.stdin.write("\tSenegalia\t\n")
+process.stdin.write("\tSenegalia\tPlantae\n")
+process.stdin.end()
+
+
+// console.time("append")
+// const results = []
+// for (let index = 0; index < 100; index++) {
+//     results.push(nomer.append("\tBauhinia rufa\t", "gbif"))
+// }
+// console.timeEnd("append")
+
+// console.time("toObject")
+// for (let index = 0; index < results.length; index++) {
+//     const element = results[index];
+//     nomer.toObject(element)
+// }
+// console.timeEnd("toObject")

package/test/utils.test.js

@@ -0,0 +1,182 @@
+const { execSync, spawn } = require('child_process');
+import { runNomer, runNomerAsync, getNomerSimpleCmd, getNomerValidateCmd, getNomerMatchCmd } from "../src/utils";
+
+// Mock child_process
+jest.mock('child_process');
+
+describe('utils', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Suppress console.log in tests
+        jest.spyOn(console, 'log').mockImplementation(() => { });
+    });
+
+    afterEach(() => {
+        console.log.mockRestore();
+    });
+
+    describe('getNomerValidateCmd', () => {
+        it('should throw error when filepath is empty string', () => {
+            expect(() => getNomerValidateCmd("")).toThrow();
+        });
+
+        it('should generate basic validate command', () => {
+            const result = getNomerValidateCmd("/path/to/file");
+            expect(result).toBe("curl -L /path/to/file | nomer validate-term");
+        });
+
+        it('should generate validate command with custom cmd', () => {
+            const result = getNomerValidateCmd("/path/to/file", "validate-term-link");
+            expect(result).toBe("curl -L /path/to/file | nomer validate-term-link");
+        });
+
+        it('should generate validate command with properties', () => {
+            const result = getNomerValidateCmd("/path/to/file", "validate-term", "props.properties");
+            expect(result).toBe("curl -L /path/to/file | nomer validate-term -p props.properties");
+        });
+    });
+
+    describe('getNomerMatchCmd', () => {
+        it('should generate basic match command without query', () => {
+            const result = getNomerMatchCmd();
+            expect(result).toBe("nomer append globi-taxon-cache");
+        });
+
+        it('should generate match command with query', () => {
+            const result = getNomerMatchCmd("Homo sapiens");
+            expect(result).toBe("echo -e 'Homo sapiens' | nomer append globi-taxon-cache");
+        });
+
+        it('should generate match command with custom echo option', () => {
+            const result = getNomerMatchCmd("Homo sapiens", "append", "globi-taxon-cache", null, null, "-n");
+            expect(result).toBe("echo -n 'Homo sapiens' | nomer append globi-taxon-cache");
+        });
+
+        it('should generate match command with properties', () => {
+            const result = getNomerMatchCmd("", "append", "globi-taxon-cache", "props.properties");
+            expect(result).toBe("nomer append globi-taxon-cache -p props.properties");
+        });
+
+        it('should generate match command with output format', () => {
+            const result = getNomerMatchCmd("", "append", "globi-taxon-cache", null, "json");
+            expect(result).toBe("nomer append globi-taxon-cache -o json");
+        });
+
+        it('should generate match command with all options', () => {
+            const result = getNomerMatchCmd("Homo sapiens", "replace", "custom-matcher", "props.properties", "json", "-e");
+            expect(result).toBe("echo -e 'Homo sapiens' | nomer replace custom-matcher -p props.properties -o json");
+        });
+    });
+
+    describe('getNomerSimpleCmd', () => {
+        it('should generate basic version command', () => {
+            const result = getNomerSimpleCmd();
+            expect(result).toBe("nomer version");
+        });
+
+        it('should generate command with custom cmd', () => {
+            const result = getNomerSimpleCmd("clean");
+            expect(result).toBe("nomer clean");
+        });
+
+        it('should generate command with properties', () => {
+            const result = getNomerSimpleCmd("version", false, "props.properties");
+            expect(result).toBe("nomer version -p props.properties");
+        });
+
+        it('should generate command with output format', () => {
+            const result = getNomerSimpleCmd("version", false, null, "json");
+            expect(result).toBe("nomer version -o json");
+        });
+
+        it('should generate command with verbose flag', () => {
+            const result = getNomerSimpleCmd("version", true);
+            expect(result).toBe("nomer version -v");
+        });
+
+        it('should generate command with all options', () => {
+            const result = getNomerSimpleCmd("matchers", true, "props.properties", "tsv");
+            expect(result).toBe("nomer matchers -p props.properties -o tsv -v");
+        });
+    });
+
+    describe('runNomer', () => {
+        it('should execute command and return trimmed result', () => {
+            const mockResult = Buffer.from('result output\n\n');
+            execSync.mockReturnValue(mockResult);
+
+            const result = runNomer('nomer version');
+
+            expect(execSync).toHaveBeenCalledWith('nomer version', {
+                maxBuffer: 4096 * 4096
+            });
+            expect(result).toBe('result output');
+        });
+
+        it('should return null on error and log message', () => {
+            const mockError = new Error('Command failed');
+            execSync.mockImplementation(() => {
+                throw mockError;
+            });
+
+            const result = runNomer('nomer version');
+
+            expect(console.log).toHaveBeenCalledWith('Error running nomer cmd: Command failed');
+            expect(result).toBe(null);
+        });
+
+        it('should handle empty result', () => {
+            execSync.mockReturnValue(Buffer.from(''));
+
+            const result = runNomer('nomer version');
+
+            expect(result).toBeUndefined();
+        });
+
+        it('should trim whitespace from result', () => {
+            const mockResult = Buffer.from('  result with spaces  \n\t');
+            execSync.mockReturnValue(mockResult);
+
+            const result = runNomer('nomer version');
+
+            expect(result).toBe('  result with spaces');
+        });
+    });
+
+    describe('runNomerAsync', () => {
+        it('should spawn process with correct arguments', () => {
+            const mockProcess = { stdout: {}, stderr: {}, stdin: {} };
+            spawn.mockReturnValue(mockProcess);
+
+            const result = runNomerAsync('nomer append globi-taxon-cache');
+
+            expect(spawn).toHaveBeenCalledWith('nomer', ['append', 'globi-taxon-cache'], {
+                shell: true
+            });
+            expect(result).toBe(mockProcess);
+        });
+
+        it('should handle complex commands with multiple arguments', () => {
+            const mockProcess = { stdout: {}, stderr: {}, stdin: {} };
+            spawn.mockReturnValue(mockProcess);
+
+            const result = runNomerAsync('nomer append globi-taxon-cache -p props.properties -o json');
+
+            expect(spawn).toHaveBeenCalledWith('nomer', ['append', 'globi-taxon-cache', '-p', 'props.properties', '-o', 'json'], {
+                shell: true
+            });
+            expect(result).toBe(mockProcess);
+        });
+
+        it('should split command on whitespace', () => {
+            const mockProcess = { stdout: {}, stderr: {}, stdin: {} };
+            spawn.mockReturnValue(mockProcess);
+
+            runNomerAsync('echo -e test | nomer version');
+
+            expect(spawn).toHaveBeenCalledWith('echo', ['-e', 'test', '|', 'nomer', 'version'], {
+                shell: true
+            });
+        });
+    });
+});