@vida-global/core 1.1.0

package/test/active_record/db/connectionConfiguration.test.js

@@ -0,0 +1,184 @@
+const { ConnectionConfiguration } = require('../../../lib/active_record/db/connectionConfiguration');
+const   TestHelpers               = require('@vida-global/test-helpers');
+
+
+const test = {
+    database: TestHelpers.Faker.Text.randomString(),
+    host:     TestHelpers.Faker.Text.randomString(),
+    password: TestHelpers.Faker.Text.randomString(),
+    port:     Math.random(),
+    username: TestHelpers.Faker.Text.randomString()
+}
+const production = {
+    database: TestHelpers.Faker.Text.randomString(),
+    host:     TestHelpers.Faker.Text.randomString(),
+    password: TestHelpers.Faker.Text.randomString(),
+    port:     Math.random(),
+    username: TestHelpers.Faker.Text.randomString()
+}
+
+const sqliteConfig = {
+    dialect: 'sqlite'
+};
+
+const databaseId1 = TestHelpers.Faker.Text.randomString();
+const databaseId2 = TestHelpers.Faker.Text.randomString();
+
+const origEnvDBPoolMin = process.env.DB_POOL_MIN;
+const origEnvDBPoolMax = process.env.DB_POOL_MAX;
+
+const spy = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
+afterEach(() => {
+    spy.mockReset();
+});
+
+
+describe('ConnectionConfiguration', () => {
+    it ('throws an error when there is no configuration for the database id', () => {
+        spy.mockImplementation(() => ({ test }));
+        expect(() => new ConnectionConfiguration(databaseId1)).toThrow();
+    });
+
+    it ('throws an error when there is no configuration for the environment', () => {
+        spy.mockImplementation(() => ({[databaseId1]: { production }}));
+        expect(() => new ConnectionConfiguration(databaseId1)).toThrow();
+    });
+
+    it ('throws an error when there is missing information for postgres', () => {
+        spy.mockImplementation(() => ({[databaseId1]: {test: {port: Math.random()}}}));
+        expect(() => new ConnectionConfiguration(databaseId1)).toThrow();
+    });
+
+    it ('does not require database details for sqlite', () => {
+        spy.mockImplementation(() => ({[databaseId1]: {test: sqliteConfig}}));
+        expect(() => new ConnectionConfiguration(databaseId1)).not.toThrow();
+    });
+
+    it ('returns the correct configuration values', () => {
+        spy.mockImplementation(() => {
+            return {
+                [databaseId1]: { test, production },
+                [databaseId2]: { test: {}, production: {} },
+            }
+        });
+
+        const config = new ConnectionConfiguration(databaseId1);
+
+        expect(config.database).toEqual(test.database);
+        expect(config.host).toEqual(test.host);
+        expect(config.password).toEqual(test.password);
+        expect(config.username).toEqual(test.username);
+        expect(config.ssl).toBeFalsy();
+    });
+
+    it ('returns the correct configuration values', () => {
+        const rawConfig = {...test, ssl: true};
+        spy.mockImplementation(() => ({[databaseId1]: { test: rawConfig }}));
+
+        const config = new ConnectionConfiguration(databaseId1);
+        expect(config.ssl).toBeTruthy();
+    });
+
+
+    describe('ConnectionConfiguration#loggingEnabled', () => {
+        it ('enables logging in development', () => {
+            const origEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'development';
+
+            spy.mockImplementation(() => ({[databaseId1]: {development: test}}));
+
+            const config = new ConnectionConfiguration(databaseId1);
+            expect(config.loggingEnabled).toBeTruthy();
+
+            process.env.NODE_ENV = origEnv;
+        });
+
+        it ('does not enable logging in production', () => {
+            const origEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'production';
+
+            spy.mockImplementation(() => ({[databaseId1]: { production }}));
+
+            const config = new ConnectionConfiguration(databaseId1);
+            expect(config.loggingEnabled).toBeFalsy();
+
+            process.env.NODE_ENV = origEnv;
+        });
+    });
+
+
+    describe('ConnectionConfiguration#pool', () => {
+        afterEach(() => {
+            process.env.DB_POOL_MIN = origEnvDBPoolMin;
+            process.env.DB_POOL_MAX = origEnvDBPoolMax;
+        });
+
+        it ('uses default pool values', () => {
+            spy.mockImplementation(() => ({[databaseId1]: {test}}));
+
+            const config = new ConnectionConfiguration(databaseId1);
+            expect(config.pool).toEqual({min: 0, max: 5});
+        });
+
+        it ('uses config variables when configured', () => {
+            const poolMax           = Math.random();
+            const poolMin           = Math.random();
+            process.env.DB_POOL_MIN = Math.random();
+            process.env.DB_POOL_MAX = Math.random();
+            const pooledTest        = {...test, pool: {min: poolMin, max: poolMax}};
+            spy.mockImplementation(() => ({[databaseId1]: {test: pooledTest}}));
+
+            const config = new ConnectionConfiguration(databaseId1);
+            expect(config.pool).toEqual({min: poolMin, max: poolMax});
+        });
+    });
+
+
+    describe('ConnectionConfiguration.configuredDatabaseIds', () => {
+        it ('returns a list of all configured databaseIds', () => {
+            const configs = {
+              [databaseId1]: { production, test },
+              [databaseId2]: { production, test }
+            };
+
+            spy.mockImplementation(() => configs);
+
+            expect(ConnectionConfiguration.configuredDatabaseIds()).toEqual([databaseId1, databaseId2]);
+        });
+
+        it ('returns only databaseIds configured for the current environment', () => {
+            const configs = {
+              [databaseId1]: { production },
+              [databaseId2]: { production, test }
+            };
+
+            spy.mockImplementation(() => configs);
+            expect(ConnectionConfiguration.configuredDatabaseIds()).toEqual([databaseId2]);
+        });
+    });
+
+
+    describe('ConnectionConfiguration#dialect', () => {
+        it ('defaults to postgres', () => {
+            spy.mockImplementation(() => ({[databaseId1]: { test }}));
+            const config = new ConnectionConfiguration(databaseId1);
+            expect(config.dialect).toEqual('postgres');
+        });
+
+        it ('returns sqlite when configured to do so', () => {
+            spy.mockImplementation(() => ({[databaseId1]: {test: sqliteConfig}}));
+            const config = new ConnectionConfiguration(databaseId1);
+            expect(config.dialect).toEqual('sqlite');
+        });
+    });
+
+
+    describe('ConnectionConfiguration#storage', () => {
+        it ('returns the correct path for sqlite database file', () => {
+            spy.mockImplementation(() => ({[databaseId1]: {test: sqliteConfig}}));
+            const config   = new ConnectionConfiguration(databaseId1);
+            const expected = `${process.cwd()}/config/db/database.test.sqlite`;
+            expect(config.storage).toEqual(expected);
+        });
+    });
+});

package/test/active_record/db/migrator.test.js

@@ -0,0 +1,266 @@
+const { ConnectionConfiguration } = require('../../../lib/active_record/db/connectionConfiguration');
+const { Migrator }                = require('../../../lib/active_record/db/migrator');
+const { QueryInterface }          = require('../../../lib/active_record/db/queryInterface');
+const { Sequelize }               = require('sequelize');
+const   TestHelpers               = require('@vida-global/test-helpers');
+
+
+const connectionConfig = {database: ' ', host: ' ', password: ' ', username: ' '};
+const migrationModule  = {up: jest.fn(), down: jest.fn()};
+
+const configSpy  = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
+configSpy.mockImplementation(() => ({default: {test: connectionConfig}}));
+
+const transactionSpy = jest.spyOn(QueryInterface.prototype, 'transaction');
+transactionSpy.mockImplementation(callback => callback());
+
+const MockQueryInterface = {
+    createTable:  jest.fn(),
+    dropTable:    jest.fn(),
+    addColumn:    jest.fn(),
+    removeColumn: jest.fn(),
+    addIndex:     jest.fn(),
+    removeIndex:  jest.fn(),
+    renameColumn: jest.fn(),
+    changeColumn: jest.fn()
+}
+jest.mock('sequelize', () => {
+    class MockSequelize {
+        static DataTypes = {INTEGER: 'INTEGER', DATE: 'DATE'};
+    }
+    return {Sequelize: MockSequelize};
+});
+
+Sequelize.prototype.getQueryInterface = () => MockQueryInterface;
+
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('Migrator', () => {
+    const migrator = new Migrator();
+    const moduleSpy = jest.spyOn(migrator, 'migrationModule', 'get');
+    moduleSpy.mockImplementation(() => migrationModule);
+
+    describe('Migrator#run', () => {
+        it ('calls the migration migrate `up` callback within a transaction', async () => {
+            await migrator.run();
+            expect(transactionSpy).toHaveBeenCalledTimes(1);
+            expect(migrationModule.up).toHaveBeenCalledTimes(1);
+        });
+
+        it ('throws an error if there is no `up`', async () => {
+            const origUp = migrationModule.up;
+            delete migrationModule.up
+
+            expect(async () => {await migrator.run()}).rejects.toThrow();
+
+            migrationModule.up = origUp;
+        });
+    });
+
+
+    describe('Migrator#down', () => {
+        it ('calls the migration migrate `down` callback within a transaction', async () => {
+            await migrator.rollback();
+            expect(transactionSpy).toHaveBeenCalledTimes(1);
+            expect(migrationModule.down).toHaveBeenCalledTimes(1);
+        });
+
+        it ('does not throw an error if there is no `down`', async () => {
+            const origDown = migrationModule.down;
+            delete migrationModule.down
+
+            try {
+                await migrator.rollback();
+            } catch(err) {
+                expect(1).toBe(2); // if we get here, an error was thrown
+            }
+
+            migrationModule.down = origDown;
+        });
+    });
+
+
+    describe('Migrator#createTable', () => {
+        const idCol      = { allowNull: false, autoIncrement: true, primaryKey: true, type: 'INTEGER'};
+        const createdCol = {allowNull: false, type: 'DATE'};
+        const updatedCol = {allowNull: false, type: 'DATE'};
+
+        it ('calls `createTable` on the query interface and includes default columns', async () => {
+            const tableName = TestHelpers.Faker.Text.randomString();
+            const details   = {
+                id:         idCol,
+                [TestHelpers.Faker.Text.randomString().toLowerCase()]:  Math.random(),
+                created_at: createdCol,
+                updated_at: updatedCol,
+            };
+
+            await migrator.createTable(tableName, details);
+            expect(MockQueryInterface.createTable).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.createTable).toHaveBeenCalledWith(tableName, details);
+        });
+
+        it ('ensures the columns are snake cased', async () => {
+            const tableName = TestHelpers.Faker.Text.randomString();
+            const details   = {
+                id:         idCol,
+                myColumn:   1,
+                created_at: createdCol,
+                updated_at: updatedCol,
+            };
+
+            await migrator.createTable(tableName, details);
+            expect(MockQueryInterface.createTable).toHaveBeenCalledWith(tableName, {
+                id:         idCol,
+                my_column:  1,
+                created_at: createdCol,
+                updated_at: updatedCol,
+            });
+        });
+    });
+
+
+    describe('Migrator#dropTable', () => {
+        it ('calls `dropTable` on the query interface', async () => {
+            const tableName = TestHelpers.Faker.Text.randomString();
+            await migrator.dropTable(tableName);
+            expect(MockQueryInterface.dropTable).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.dropTable).toHaveBeenCalledWith(tableName);
+        });
+    });
+
+
+    describe('Migrator#addColumn', () => {
+        it ('calls `addColumn` on the query interface', async () => {
+            const tableName  = TestHelpers.Faker.Text.randomString();
+            const columnName = TestHelpers.Faker.Text.randomString();
+            const details   = {
+                [TestHelpers.Faker.Text.randomString()]: Math.random(),
+            };
+          
+            await migrator.addColumn(tableName, columnName, details);
+            expect(MockQueryInterface.addColumn).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.addColumn).toHaveBeenCalledWith(tableName, columnName, details);
+        });
+    });
+
+
+    describe('Migrator#removeColumn', () => {
+        it ('calls `removeColumn` on the query interface', async () => {
+            const tableName  = TestHelpers.Faker.Text.randomString();
+            const columnName = TestHelpers.Faker.Text.randomString();
+            await migrator.removeColumn(tableName, columnName);
+            expect(MockQueryInterface.removeColumn).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.removeColumn).toHaveBeenCalledWith(tableName, columnName);
+        });
+    });
+
+
+    describe('Migrator#addIndex', () => {
+        const tableName  = TestHelpers.Faker.Text.randomString();
+        const fields     = [
+            TestHelpers.Faker.Text.randomString(),
+            TestHelpers.Faker.Text.randomString()
+        ];
+
+        it ('calls `addColumn` on the query interface', async () => {
+            const options          = {concurrently: true, unique: true, where: {}, name: 'foo'};
+            const expectedOptions  = structuredClone(options);
+            expectedOptions.fields = fields; 
+          
+            await migrator.addIndex(tableName, fields, options);
+
+            expect(MockQueryInterface.addIndex).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.addIndex).toHaveBeenCalledWith(tableName, expectedOptions);
+        });
+
+
+        it ('does not pass unset options', async () => {
+            const options          = {};
+            const expectedOptions  = {fields: fields};
+          
+            await migrator.addIndex(tableName, fields, options);
+
+            expect(MockQueryInterface.addIndex).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.addIndex).toHaveBeenCalledWith(tableName, expectedOptions);
+        });
+
+
+        it ('does not pass false or null options', async () => {
+            const options          = {concurrently: false, unique: false, where: null, name: null};
+            const expectedOptions  = {fields: fields};
+          
+            await migrator.addIndex(tableName, fields, options);
+
+            expect(MockQueryInterface.addIndex).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.addIndex).toHaveBeenCalledWith(tableName, expectedOptions);
+        });
+    });
+
+
+    describe('Migrator#removeIndex', () => {
+        it ('calls `removeIndex` on the query interface', async () => {
+            const tableName = TestHelpers.Faker.Text.randomString();
+            const fields     = [
+                TestHelpers.Faker.Text.randomString(),
+                TestHelpers.Faker.Text.randomString()
+            ];
+
+            await migrator.removeIndex(tableName, fields);
+            expect(MockQueryInterface.removeIndex).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.removeIndex).toHaveBeenCalledWith(tableName, fields, {});
+        });
+
+        it ('sets `concurrently` when set to true', async () => {
+            const tableName = TestHelpers.Faker.Text.randomString();
+            const fields     = [
+                TestHelpers.Faker.Text.randomString(),
+                TestHelpers.Faker.Text.randomString()
+            ];
+
+            await migrator.removeIndex(tableName, fields, true);
+            expect(MockQueryInterface.removeIndex).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.removeIndex).toHaveBeenCalledWith(tableName, fields, {concurrently: true});
+        });
+    });
+
+
+    describe('Migrator#renameColumn', () => {
+        it ('calls `renameColumn` on the query interface', async () => {
+            const tableName = TestHelpers.Faker.Text.randomString();
+            const oldName   = TestHelpers.Faker.Text.randomString();
+            const newName   = TestHelpers.Faker.Text.randomString().toLowerCase();
+
+            await migrator.renameColumn(tableName, oldName, newName);
+            expect(MockQueryInterface.renameColumn).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.renameColumn).toHaveBeenCalledWith(tableName, oldName, newName);
+        });
+
+        it ('ensures the columns are snake cased', async () => {
+            const tableName = TestHelpers.Faker.Text.randomString();
+            const oldName   = TestHelpers.Faker.Text.randomString();
+            const newName   = 'myColumn';
+
+            await migrator.renameColumn(tableName, oldName, newName);
+            expect(MockQueryInterface.renameColumn).toHaveBeenCalledWith(tableName, oldName, 'my_column');
+        });
+    });
+
+
+    describe('Migrator#changeColumn', () => {
+        it ('calls `changeColumn` on the query interface', async () => {
+            const tableName = TestHelpers.Faker.Text.randomString();
+            const colName   = TestHelpers.Faker.Text.randomString();
+            const options   = {
+                [TestHelpers.Faker.Text.randomString()]: Math.random(),
+            };
+
+            await migrator.changeColumn(tableName, colName, options);
+            expect(MockQueryInterface.changeColumn).toHaveBeenCalledTimes(1);
+            expect(MockQueryInterface.changeColumn).toHaveBeenCalledWith(tableName, colName, options);
+        });
+    });
+});

package/test/active_record/db/queryInterface.test.js

@@ -0,0 +1,66 @@
+const { Connection }              = require('../../../lib/active_record/db/connection');
+const { ConnectionConfiguration } = require('../../../lib/active_record/db/connectionConfiguration');
+const { QueryInterface }          = require('../../../lib/active_record/db/queryInterface');
+const { Sequelize }               = require('sequelize');
+const   TestHelpers               = require('@vida-global/test-helpers');
+
+
+const tableName1     = TestHelpers.Faker.Text.randomString();
+const tableName2     = TestHelpers.Faker.Text.randomString();
+const MockQueryInterface = {
+    showAllTables: jest.fn(()          => [tableName1, tableName2]),
+    describeTable: jest.fn((tableName) => ({name: tableName}))
+}
+jest.mock('sequelize', () => {
+    class MockSequelize {
+        transaction = jest.fn()
+    }
+    return {Sequelize: MockSequelize};
+});
+
+Sequelize.prototype.getQueryInterface = () => MockQueryInterface;
+
+
+const connectionConfig = {database: ' ', host: ' ', password: ' ', username: ' '};
+const configSpy        = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
+configSpy.mockImplementation(() => ({default: {test: connectionConfig}}));
+
+const connection     = new Connection();
+const queryInterface = new QueryInterface(connection);
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('QueryInterface', () => {
+    describe('QueryInterface#allTables', () => {
+        it ('uses the sequelize queryInterface to fetch the list of tables', async () => {
+            await queryInterface.allTables();
+            expect(MockQueryInterface.showAllTables).toHaveBeenCalledTimes(1);
+        });
+
+        it ('uses the sequelize queryInterface to fetch the details of all tables', async () => {
+            await queryInterface.allTables();
+            expect(MockQueryInterface.describeTable).toHaveBeenCalledTimes(2);
+            expect(MockQueryInterface.describeTable).toHaveBeenCalledWith(tableName1);
+            expect(MockQueryInterface.describeTable).toHaveBeenCalledWith(tableName2);
+        });
+
+        it ('returns the details of all tables', async () => {
+            const tables = await queryInterface.allTables();
+            expect(tables[tableName1]).toEqual({name: tableName1});
+            expect(tables[tableName2]).toEqual({name: tableName2});
+        });
+    });
+
+
+    describe('QueryInterface#transaction', () => {
+        it ('uses the sequelize queryInterface wrap a callback in a transaction', async () => {
+            const callback = jest.fn();
+            await queryInterface.transaction(callback);
+            expect(connection._sequelize.transaction).toHaveBeenCalledTimes(1);
+            expect(connection._sequelize.transaction).toHaveBeenCalledWith(callback);
+        });
+    });
+});