@egi/smart-db 2.3.2 → 2.3.3

package/test/test.js

@@ -1,273 +0,0 @@
-const {SmartDbMysql} = require("../dist/drivers/smart-db-mysql");
-const {SmartDbSqlite3} = require("../dist/drivers/smart-db-sqlite3");
-const {SmartDbBetterSqlite3} = require("../dist/drivers/smart-db-better-sqlite3");
-const {SmartDbDictionary} = require("./model/smart-db-dictionary");
-
-const {COUNT, COALESCE, FIELD, VALUE} = require("../dist/smart-db-interface");
-
-const assert = require("assert");
-const {describe, it, done, before, after} = require("mocha");
-const {TestTableModel} = require("./model/test-table-model");
-const fs = require("fs");
-const _ = require("lodash");
-
-const LEARN = true;
-const engineTestConfigFile = "test/data/sql-engine-tests.json";
-
-let engineTestConfig;
-try {
-    if (fs.existsSync(engineTestConfigFile)) {
-        engineTestConfig = JSON.parse(fs.readFileSync(engineTestConfigFile).toString());
-    } else {
-        engineTestConfig = null;
-    }
-} catch (err) {
-    console.error("Unable to parse engine test configuration file");
-    console.error(err);
-    engineTestConfig = null;
-}
-
-function verify(buildData, dbType, testId) {
-    const testData = buildData.results();
-
-    if (LEARN && !engineTestConfig.results) {
-        engineTestConfig.results = {};
-    }
-
-    if (LEARN && !engineTestConfig.results[testId]) {
-        engineTestConfig.results[testId] = {};
-    }
-
-    if (LEARN || !engineTestConfig.results[testId][dbType]) {
-        engineTestConfig.results[testId][dbType] = testData;
-    } else {
-        assert(_.isEqual(testData, engineTestConfig.results[testId][dbType]), JSON.stringify({
-            id: testId,
-            expected: engineTestConfig.results[testId][dbType],
-            actual: testData
-        }, null, 2));
-    }
-}
-
-describe("Databases Setup", () => {
-    if (fs.existsSync("test/db/sqlite3.db")) {
-        fs.unlinkSync("test/db/sqlite3.db");
-    }
-
-    it("should return Sqlite3 DB handle for asynchronous tests", () => {
-        let db = new SmartDbSqlite3("test/db/sqlite3.db");
-        assert(!!db);
-
-        genericTests(db, "sqlite3", {
-            module: "smart-db-test",
-            sqlFilesDirectory: "test/db/sqlite3",
-            smartDbDictionary: SmartDbDictionary
-
-        });
-
-        sqlEngineTests(db, "sqlite3");
-    });
-
-    if (fs.existsSync("test/db/better-sqlite3.db")) {
-        fs.unlinkSync("test/db/better-sqlite3.db");
-    }
-
-    it("should return Better Sqlite3 DB handle for asynchronous tests", () => {
-        let db = new SmartDbBetterSqlite3("test/db/better-sqlite3.db");
-        assert(!!db);
-
-        genericTests(db, "better-sqlite3", {
-            module: "smart-db-test",
-            sqlFilesDirectory: "test/db/sqlite3",
-            smartDbDictionary: SmartDbDictionary
-        });
-    });
-
-    if (fs.existsSync("test/db/better-sqlite3-sync.db")) {
-        fs.unlinkSync("test/db/better-sqlite3-sync.db");
-    }
-
-    it("should return Better Sqlite3 DB handle for synchronous tests", () => {
-        let db = new SmartDbBetterSqlite3("test/db/better-sqlite3-sync.db");
-        assert(!!db);
-
-        genericSyncTests(db, "better-sqlite3", {
-            module: "smart-db-test",
-            sqlFilesDirectory: "test/db/sqlite3",
-            smartDbDictionary: SmartDbDictionary
-        });
-
-        sqlEngineTests(db, "better-sqlite3");
-    });
-
-    let mysqlDb;
-    it("should return Mysql DB handle", () => {
-        mysqlDb = new SmartDbMysql({
-            host: "localhost",
-            user: "root",
-            password: "foobar",
-            multipleStatements: true
-        });
-
-        assert(!!mysqlDb);
-    });
-
-    it("should cleanup previous test schema", () => {
-        return mysqlDb.exec("drop schema if exists `smart-db-test`");
-    });
-
-    it("should create test schema", () => {
-        return mysqlDb.exec("create schema `smart-db-test`");
-    });
-
-    it("should select test schema", () => {
-        return mysqlDb.exec("use `smart-db-test`").then(() => {
-            genericTests(mysqlDb, "mysql", {
-                module: "smart-db-test",
-                sqlFilesDirectory: "test/db/mysql",
-                smartDbDictionary: SmartDbDictionary
-            });
-
-            sqlEngineTests(mysqlDb, "mysql");
-        });
-    });
-});
-
-function genericTests(db, dbType, initOptions) {
-    describe("Common Asynchronous Tests for " + dbType, () => {
-        let moduleVersions;
-        let id1;
-
-        it("should run init script", () => {
-            return db.initDb(initOptions).then((versions) => {
-                moduleVersions = versions;
-            });
-        });
-
-        it("should contain module 'smart-db-core'", () => {
-            const hasCore = moduleVersions.find((version) => {
-                return version.module == "smart-db-core";
-            });
-
-            assert(!!hasCore);
-        });
-
-        it("should contain module 'smart-db-test'", () => {
-            const hasTest = moduleVersions.find((version) => {
-                return version.module == "smart-db-core";
-            });
-
-            assert(!!hasTest);
-        });
-
-        it("should insert value", () => {
-            return db.insert(TestTableModel, {
-                string: "test-string",
-                number: 42,
-                date: new Date(),
-                boolean: true
-            }).then((id) => {
-                id1 = id;
-                assert(id1 !== false, db.getLastError());
-                assert(id1 > 0, db.getLastBuildData().toString());
-            });
-        });
-
-        it("should select row", () => {
-            return db.getFirst(TestTableModel, {
-                id: id1
-            }).then((row) => {
-                assert(row !== false, db.getLastError());
-                assert(!!row, db.getLastBuildData().toString());
-                assert(typeof row.string == "string", "string type " + (typeof row.string));
-                assert(typeof row.number == "number", "number type " + (typeof row.number));
-                assert(typeof row.date == "object", "date type " + (typeof row.date));
-                assert(typeof row.boolean == "boolean", "boolean type " + (typeof row.boolean));
-            });
-        });
-
-        it("should truncate table", () => {
-            return db.delete(TestTableModel).then((n) => {
-                assert(n !== false, db.getLastError());
-                assert(n >= 0, db.getLastBuildData().toString());
-            });
-        });
-    });
-}
-
-
-function genericSyncTests(db, dbType, initOptions) {
-    describe("Common Synchronous Tests for " + dbType, () => {
-        let moduleVersions;
-        let id1;
-
-        it("should run init script", () => {
-            return db.initDb(initOptions).then((versions) => {
-                moduleVersions = versions;
-            });
-        });
-
-        it("should contain module 'smart-db-core'", () => {
-            const hasCore = moduleVersions.find((version) => {
-                return version.module == "smart-db-core";
-            });
-
-            assert(!!hasCore);
-        });
-
-        it("should contain module 'smart-db-test'", () => {
-            const hasTest = moduleVersions.find((version) => {
-                return version.module == "smart-db-core";
-            });
-
-            assert(!!hasTest);
-        });
-
-        it("should insert value", () => {
-            id1 = db.insertSync(TestTableModel, {
-                string: "test-string",
-                number: 42,
-                date: new Date(),
-                boolean: true
-            });
-            assert(id1 !== false, db.getLastError());
-            assert(id1 > 0, db.getLastBuildData().toString());
-        });
-
-        it("should select row", () => {
-            let row = db.getFirstSync(TestTableModel, {
-                id: id1
-            });
-
-            assert(row !== false, db.getLastError());
-            assert(!!row, db.getLastBuildData().toString());
-            assert(typeof row.string == "string", "string type " + (typeof row.string));
-            assert(typeof row.number == "number", "number type " + (typeof row.number));
-            assert(typeof row.date == "object", "date type " + (typeof row.date));
-            assert(typeof row.boolean == "boolean", "boolean type " + (typeof row.boolean));
-        });
-
-        it("should truncate table", () => {
-            let n = db.deleteSync(TestTableModel);
-            assert(n !== false, db.getLastError());
-            assert(n >= 0, db.getLastBuildData().toString());
-        });
-    });
-}
-
-function sqlEngineTests(db, dbType) {
-    if (engineTestConfig && engineTestConfig.tests) {
-        describe("SQL Engine Tests for " + dbType, () => {
-            _.forEach(engineTestConfig.tests, (testData, testId) => {
-                it("should perform test: " + testId, () => {
-                    let buildData = db.buildSelectStatement(testData.table, testData.query);
-                    verify(buildData, dbType, testId);
-                });
-            });
-
-            it("finalize SQL engine results", () => {
-                fs.writeFileSync(engineTestConfigFile, JSON.stringify(engineTestConfig, null, 2));
-            });
-        });
-    }
-}

package/test/test2.js

@@ -1,252 +0,0 @@
-const {SmartDbMysql} = require("../dist/drivers/smart-db-mysql");
-const {SmartDbBetterSqlite3} = require("../dist/drivers/smart-db-better-sqlite3");
-const {smartDbLog} = require("../dist");
-
-const {COUNT, COALESCE, FIELD, VALUE} = require("../dist/smart-db-interface");
-
-const assert = require("assert");
-const {describe, it, done, before, after} = require("mocha");
-const {TestTableModel} = require("./model/test-table-model");
-const fs = require("fs");
-
-describe("Databases Setup", () => {
-    if (fs.existsSync("test/test.sqlite3")) {
-        fs.unlinkSync("test/test.sqlite3");
-    }
-
-    it("should return Sqlite3 DB handle for asynchronous tests", () => {
-        let db = new SmartDbBetterSqlite3("test/test.sqlite3");
-        assert(!!db);
-
-        genericTests(db, "sqlite3", {
-            module: "smart-db-test",
-            sqlFilesDirectory: "test/sqlite3"
-        });
-    });
-
-    it("should return Sqlite3 DB handle for synchronous tests", () => {
-        let db = new SmartDbBetterSqlite3("test/test-sync.sqlite3");
-        assert(!!db);
-
-        genericSyncTests(db, "sqlite3", {
-            module: "smart-db-test",
-            sqlFilesDirectory: "test/sqlite3"
-        });
-    });
-
-    let mysqlDb;
-    it("should return Mysql DB handle", () => {
-        let db = new SmartDbMysql({
-            host: "localhost",
-            user: "root",
-            password: "foobar",
-            multipleStatements: true
-        });
-
-        assert(!!db);
-    });
-
-    it("should cleanup previous test schema", () => {
-        return mysqlDb.exec("drop schema if exists `smart-db-test`");
-    });
-
-    it("should create test schema", () => {
-        return mysqlDb.exec("create schema `smart-db-test`");
-    });
-
-    it("should select test schema", () => {
-        return mysqlDb.exec("use `smart-db-test`").then(() => {
-            genericTests(mysqlDb, "mysql", {
-                module: "smart-db-test",
-                sqlFilesDirectory: "test/mysql"
-            });
-        });
-    });
-});
-
-
-function genericTests(db, dbType, initOptions) {
-    describe("Common Asynchronous Tests for " + dbType, () => {
-        let moduleVersions;
-        let id1;
-
-        it("should run init script", () => {
-            return db.initDb(initOptions).then((versions) => {
-                moduleVersions = versions;
-            });
-        });
-
-        it("should contain module 'smart-db-core'", () => {
-            const hasCore = moduleVersions.find((version) => {
-                return version.module == "smart-db-core";
-            });
-
-            assert(!!hasCore);
-        });
-
-        it("should contain module 'smart-db-test'", () => {
-            const hasTest = moduleVersions.find((version) => {
-                return version.module == "smart-db-core";
-            });
-
-            assert(!!hasTest);
-        });
-
-        it("should insert value", () => {
-            return db.insert(TestTableModel, {
-                string: "test-string",
-                number: 42,
-                date: new Date(),
-                boolean: true
-            }).then((id) => {
-                id1 = id;
-                assert(id1 !== false, db.getLastError());
-                assert(id1 > 0, db.getLastBuildData().toString());
-            });
-        });
-
-        it("show generate correct SQL", () => {
-            return db.getFirst(TestTableModel, {
-                expression: [{
-                    compare: "number",
-                    with: 42
-                }, {
-                    compare: "number",
-                    with: 21
-                }],
-                or: {
-                    number: 22,
-                    expression: [{
-                        compare: "number",
-                        with: 42
-                    }, {
-                        compare: "string",
-                        with: VALUE("ss")
-                    }]
-                }
-            }, [
-                "number",
-                FIELD("boolean", "t1"),
-                VALUE("ss", "test"),
-                COUNT("*", "bla"),
-                COALESCE(["number", 43], "xset")
-            ]).then((row) => {
-                console.log(db.getLastBuildData());
-            });
-        });
-
-        it("should select row", () => {
-            return db.getFirst(TestTableModel, {
-                id: id1
-            }).then((row) => {
-                assert(row !== false, db.getLastError());
-                assert(!!row, db.getLastBuildData().toString());
-                assert(typeof row.string == "string", "string type " + (typeof row.string));
-                assert(typeof row.number == "number", "number type " + (typeof row.number));
-                assert(typeof row.date == "object", "date type " + (typeof row.date));
-                assert(typeof row.boolean == "boolean", "boolean type " + (typeof row.boolean));
-            });
-        });
-
-        it("should truncate table", () => {
-            return db.delete(TestTableModel).then((n) => {
-                assert(n !== false, db.getLastError());
-                assert(n >= 0, db.getLastBuildData().toString());
-            });
-        });
-    });
-}
-
-
-function genericSyncTests(db, dbType, initOptions) {
-    describe("Common Synchronous Tests for " + dbType, () => {
-        let moduleVersions;
-        let id1;
-
-        it("should run init script", () => {
-            return db.initDb(initOptions).then((versions) => {
-                moduleVersions = versions;
-            });
-        });
-
-        it("should contain module 'smart-db-core'", () => {
-            const hasCore = moduleVersions.find((version) => {
-                return version.module == "smart-db-core";
-            });
-
-            assert(!!hasCore);
-        });
-
-        it("should contain module 'smart-db-test'", () => {
-            const hasTest = moduleVersions.find((version) => {
-                return version.module == "smart-db-core";
-            });
-
-            assert(!!hasTest);
-        });
-
-        it("should insert value", () => {
-            return db.insertSync(TestTableModel, {
-                string: "test-string",
-                number: 42,
-                date: new Date(),
-                boolean: true
-            }).then((id) => {
-                id1 = id;
-                assert(id1 !== false, db.getLastError());
-                assert(id1 > 0, db.getLastBuildData().toString());
-            });
-        });
-
-        it("show generate correct SQL", () => {
-            return db.getFirst(TestTableModel, {
-                expression: [{
-                    compare: "number",
-                    with: 42
-                }, {
-                    compare: "number",
-                    with: 21
-                }],
-                or: {
-                    number: 22,
-                    expression: [{
-                        compare: "number",
-                        with: 42
-                    }, {
-                        compare: "string",
-                        with: VALUE("ss")
-                    }]
-                }
-            }, [
-                "number",
-                FIELD("boolean", "t1"),
-                VALUE("ss", "test"),
-                COUNT("*", "bla"),
-                COALESCE(["number", 43], "xset")
-            ]).then((row) => {
-                console.log(db.getLastBuildData());
-            });
-        });
-
-        it("should select row", () => {
-            return db.getFirst(TestTableModel, {
-                id: id1
-            }).then((row) => {
-                assert(row !== false, db.getLastError());
-                assert(!!row, db.getLastBuildData().toString());
-                assert(typeof row.string == "string", "string type " + (typeof row.string));
-                assert(typeof row.number == "number", "number type " + (typeof row.number));
-                assert(typeof row.date == "object", "date type " + (typeof row.date));
-                assert(typeof row.boolean == "boolean", "boolean type " + (typeof row.boolean));
-            });
-        });
-
-        it("should truncate table", () => {
-            return db.delete(TestTableModel).then((n) => {
-                assert(n !== false, db.getLastError());
-                assert(n >= 0, db.getLastBuildData().toString());
-            });
-        });
-    });
-}
-

package/tsconfig.json

@@ -1,32 +0,0 @@
-{
-  "compileOnSave": false,
-  "compilerOptions": {
-    "baseUrl": ".",
-    "outDir": "dist",
-    "sourceMap": true,
-    "declaration": true,
-    "downlevelIteration": true,
-    "experimentalDecorators": true,
-    "moduleResolution": "node",
-    "module": "ES2020",
-    "inlineSources": true,
-    //"importHelpers": true,
-    "target": "ES2020",
-    "allowSyntheticDefaultImports": true,
-    //"esModuleInterop": true,
-    "lib": [
-      "es6",
-      "ES2020",
-      "dom"
-    ],
-    "paths": {
-      "*": [
-        "node_modules/*"
-      ]
-    }
-  },
-  "include": [
-    "src/*.ts",
-    "src/**/*.ts"
-  ]
-}

package/tsconfig.pro.json

@@ -1,32 +0,0 @@
-{
-  "compileOnSave": false,
-  "compilerOptions": {
-    "baseUrl": ".",
-    "outDir": "dist",
-    "sourceMap": false,
-    "declaration": true,
-    "downlevelIteration": true,
-    "experimentalDecorators": true,
-    "moduleResolution": "node",
-    "module": "ES2020",
-    "inlineSources": false,
-    //"importHelpers": true,
-    "target": "ES2020",
-    "allowSyntheticDefaultImports": true,
-    //"esModuleInterop": true,
-    "lib": [
-      "es6",
-      "ES2020",
-      "dom"
-    ],
-    "paths": {
-      "*": [
-        "node_modules/*"
-      ]
-    }
-  },
-  "include": [
-    "src/*.ts",
-    "src/**/*.ts"
-  ]
-}

package/tsconfig.test-model.json

@@ -1,23 +0,0 @@
-{
-  "compileOnSave": false,
-  "compilerOptions": {
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "target": "es5",
-    "noImplicitAny": true,
-    "moduleResolution": "node",
-    "declaration": true,
-    "sourceMap": true,
-    "baseUrl": ".",
-    "allowSyntheticDefaultImports": true,
-    "paths": {
-      "*": [
-        "node_modules/*"
-      ]
-    }
-  },
-  "include": [
-    "test/model/*.ts"
-  ]
-}
-