@vida-global/core 1.2.4 → 1.3.0

package/test/activeRecord/db/connectionConfiguration.test.js

@@ -0,0 +1,128 @@
+const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
+const   Helpers                   = require('../helpers/connectionConfiguration');
+
+
+afterEach(() => {
+    Helpers.fetchConfigsSpy.mockReset();
+    process.env.DB_POOL_MIN = Helpers.originalEnv.dbPoolMin;
+    process.env.DB_POOL_MAX = Helpers.originalEnv.dbPoolMax;
+    process.env.NODE_ENV    = Helpers.originalEnv.nodeEnv;
+});
+
+
+describe('ConnectionConfiguration', () => {
+    describe('ConnectionConfiguration.constructor', () => {
+        it.each([
+            ['database id',     () => ({ test: Helpers.testConfig })],
+            ['environment',     () => ({ [Helpers.databaseId1]: { production: Helpers.productionConfig } })],
+            ['postgres fields', () => ({ [Helpers.databaseId1]: { test: { port: Math.random() } } })],
+        ])('throws when required %s config is missing', (_label, configBuilder) => {
+            Helpers.mockConfigs(configBuilder());
+            expect(() => new ConnectionConfiguration(Helpers.databaseId1)).toThrow();
+        });
+
+        it ('does not require postgres details for sqlite', () => {
+            Helpers.mockConfigs({ [Helpers.databaseId1]: { test: Helpers.sqliteConfig } });
+            expect(() => new ConnectionConfiguration(Helpers.databaseId1)).not.toThrow();
+        });
+    });
+
+
+    describe('resolved properties', () => {
+        it ('maps core fields from the environment config', () => {
+            Helpers.mockConfigs({
+                [Helpers.databaseId1]: { test: Helpers.testConfig, production: Helpers.productionConfig },
+                [Helpers.databaseId2]: { test: {}, production: {} },
+            });
+
+            const config = new ConnectionConfiguration(Helpers.databaseId1);
+
+            expect(config.database).toEqual(Helpers.testConfig.database);
+            expect(config.host).toEqual(Helpers.testConfig.host);
+            expect(config.password).toEqual(Helpers.testConfig.password);
+            expect(config.username).toEqual(Helpers.testConfig.username);
+            expect(config.ssl).toBeFalsy();
+        });
+
+        it ('sets ssl when configured', () => {
+            Helpers.mockConfigs({ [Helpers.databaseId1]: { test: Helpers.buildPostgresConfig({ ssl: true }) } });
+            const config = new ConnectionConfiguration(Helpers.databaseId1);
+            expect(config.ssl).toBeTruthy();
+        });
+    });
+
+
+    describe('ConnectionConfiguration#loggingEnabled', () => {
+        it.each([
+            ['development', true],
+            ['production', false],
+        ])('returns %s logging setting', (environment, expected) => {
+            process.env.NODE_ENV = environment;
+            Helpers.mockConfigs({ [Helpers.databaseId1]: { [environment]: Helpers.testConfig } });
+            const config = new ConnectionConfiguration(Helpers.databaseId1);
+            expect(config.loggingEnabled).toBe(expected);
+        });
+    });
+
+
+    describe('ConnectionConfiguration#pool', () => {
+        it ('uses default pool values when unset', () => {
+            Helpers.mockConfigs({ [Helpers.databaseId1]: { test: Helpers.testConfig } });
+            const config = new ConnectionConfiguration(Helpers.databaseId1);
+            expect(config.pool).toEqual({ min: 0, max: 5 });
+        });
+
+        it ('uses configured pool values', () => {
+            const pool = { min: Math.random(), max: Math.random() };
+            process.env.DB_POOL_MIN = String(Math.random());
+            process.env.DB_POOL_MAX = String(Math.random());
+            Helpers.mockConfigs({ [Helpers.databaseId1]: { test: Helpers.buildPostgresConfig({ pool }) } });
+
+            const config = new ConnectionConfiguration(Helpers.databaseId1);
+
+            expect(config.pool).toEqual(pool);
+        });
+    });
+
+
+    describe('ConnectionConfiguration.configuredDatabaseIds', () => {
+        it ('returns all database ids configured for the current environment', () => {
+            Helpers.mockConfigs({
+                [Helpers.databaseId1]: { production: Helpers.productionConfig, test: Helpers.testConfig },
+                [Helpers.databaseId2]: { production: Helpers.productionConfig, test: Helpers.testConfig },
+            });
+
+            expect(ConnectionConfiguration.configuredDatabaseIds()).toEqual([Helpers.databaseId1, Helpers.databaseId2]);
+        });
+
+        it ('filters out ids missing the current environment', () => {
+            Helpers.mockConfigs({
+                [Helpers.databaseId1]: { production: Helpers.productionConfig },
+                [Helpers.databaseId2]: { production: Helpers.productionConfig, test: Helpers.testConfig },
+            });
+
+            expect(ConnectionConfiguration.configuredDatabaseIds()).toEqual([Helpers.databaseId2]);
+        });
+    });
+
+
+    describe('ConnectionConfiguration#dialect', () => {
+        it.each([
+            ['postgres', { test: Helpers.testConfig },   'postgres'],
+            ['sqlite',   { test: Helpers.sqliteConfig }, 'sqlite'],
+        ])('returns %s dialect', (_label, configByEnv, expectedDialect) => {
+            Helpers.mockConfigs({ [Helpers.databaseId1]: configByEnv });
+            const config = new ConnectionConfiguration(Helpers.databaseId1);
+            expect(config.dialect).toEqual(expectedDialect);
+        });
+    });
+
+
+    describe('ConnectionConfiguration#storage', () => {
+        it ('returns sqlite storage path', () => {
+            Helpers.mockConfigs({ [Helpers.databaseId1]: { test: Helpers.sqliteConfig } });
+            const config = new ConnectionConfiguration(Helpers.databaseId1);
+            expect(config.storage).toEqual(`${process.cwd()}/config/db/database.test.sqlite`);
+        });
+    });
+});

package/test/activeRecord/db/migrator.test.js

@@ -0,0 +1,144 @@
+const Helpers = require('../helpers/migrator');
+
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('Migrator', () => {
+    describe('Migrator#run', () => {
+        it ('runs `up` in a transaction', async () => {
+            await Helpers.migrator.run();
+
+            expect(Helpers.transactionSpy).toHaveBeenCalledTimes(1);
+            expect(Helpers.migrationModule.up).toHaveBeenCalledTimes(1);
+        });
+
+        it ('throws when `up` is missing', async () => {
+            const originalUp = Helpers.migrationModule.up;
+            delete Helpers.migrationModule.up;
+
+            await expect(Helpers.migrator.run()).rejects.toThrow();
+
+            Helpers.migrationModule.up = originalUp;
+        });
+    });
+
+
+    describe('Migrator#down', () => {
+        it ('runs `down` in a transaction', async () => {
+            await Helpers.migrator.rollback();
+
+            expect(Helpers.transactionSpy).toHaveBeenCalledTimes(1);
+            expect(Helpers.migrationModule.down).toHaveBeenCalledTimes(1);
+        });
+
+        it ('does not throw when `down` is missing', async () => {
+            const originalDown = Helpers.migrationModule.down;
+            delete Helpers.migrationModule.down;
+
+            await expect(Helpers.migrator.rollback()).resolves.toBe(undefined);
+
+            Helpers.migrationModule.down = originalDown;
+        });
+    });
+
+
+    describe('Migrator#createTable', () => {
+        const defaultColumns = {
+            id: { allowNull: false, autoIncrement: true, primaryKey: true, type: 'INTEGER' },
+            created_at: { allowNull: false, type: 'DATE' },
+            updated_at: { allowNull: false, type: 'DATE' },
+        };
+
+        it ('creates tables with provided details', async () => {
+            const tableName = Helpers.randomString();
+            const details = { ...defaultColumns, [Helpers.randomString().toLowerCase()]: Helpers.randomNumber() };
+
+            await Helpers.migrator.createTable(tableName, details);
+
+            expect(Helpers.mockQueryInterface.createTable).toHaveBeenCalledWith(tableName, details);
+        });
+
+        it ('snake_cases created table columns', async () => {
+            const tableName = Helpers.randomString();
+            const details = { ...defaultColumns, myColumn: 1 };
+
+            await Helpers.migrator.createTable(tableName, details);
+
+            expect(Helpers.mockQueryInterface.createTable).toHaveBeenCalledWith(tableName, {
+                ...defaultColumns,
+                my_column: 1,
+            });
+        });
+    });
+
+
+    const tableOperations = [
+        ['dropTable', [Helpers.randomString()]],
+        ['addColumn', [Helpers.randomString(), Helpers.randomString(), Helpers.randomColumnDetails()]],
+        ['removeColumn', [Helpers.randomString(), Helpers.randomString()]],
+        ['changeColumn', [Helpers.randomString(), Helpers.randomString(), Helpers.randomColumnDetails()]],
+    ];
+    describe.each(tableOperations)('Migrator#%s', (methodName, args) => {
+        it ('delegates to the query interface', async () => {
+            await Helpers.expectQueryInterfaceCall(methodName, args);
+        });
+    });
+
+
+    describe('Migrator#renameColumn', () => {
+        it ('snake_cases renameColumn target', async () => {
+            const tableName = Helpers.randomString();
+            const oldName = Helpers.randomString();
+
+            await Helpers.migrator.renameColumn(tableName, oldName, 'myColumn');
+
+            expect(Helpers.mockQueryInterface.renameColumn).toHaveBeenCalledWith(tableName, oldName, 'my_column');
+        });
+    });
+
+
+    describe('Migrator#addIndex', () => {
+        it.each([
+            ['all supported options', { concurrently: true, unique: true, where: {}, name: 'foo' }],
+            ['empty options', {}],
+            ['falsey options', { concurrently: false, unique: false, where: null, name: null }],
+        ])('builds addIndex options for %s', async (_label, options) => {
+            const tableName = Helpers.randomString();
+            const fields = [Helpers.randomString(), Helpers.randomString()];
+            const expectedOptions = { fields };
+
+            if (options.concurrently) expectedOptions.concurrently = true;
+            if (options.unique) expectedOptions.unique = true;
+            if (options.where) expectedOptions.where = options.where;
+            if (options.name) expectedOptions.name = options.name;
+
+            await Helpers.migrator.addIndex(tableName, fields, options);
+
+            expect(Helpers.mockQueryInterface.addIndex).toHaveBeenCalledTimes(1);
+            expect(Helpers.mockQueryInterface.addIndex).toHaveBeenCalledWith(tableName, expectedOptions);
+        });
+    });
+
+
+    describe('Migrator#removeIndex', () => {
+        it.each([
+            ['default options', false, {}],
+            ['concurrently', true, { concurrently: true }],
+        ])('passes removeIndex options for %s', async (_label, concurrently, expectedOptions) => {
+            const tableName = Helpers.randomString();
+            const fields = [Helpers.randomString(), Helpers.randomString()];
+
+            await Helpers.migrator.removeIndex(tableName, fields, concurrently);
+
+            expect(Helpers.mockQueryInterface.removeIndex).toHaveBeenCalledTimes(1);
+            expect(Helpers.mockQueryInterface.removeIndex).toHaveBeenCalledWith(
+                tableName,
+                fields,
+                expectedOptions,
+            );
+        });
+    });
+});

package/test/activeRecord/db/queryInterface.test.js

@@ -0,0 +1,48 @@
+const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
+const { Connection }              = require('../../../lib/activeRecord/db/connection');
+const { QueryInterface }          = require('../../../lib/activeRecord/db/queryInterface');
+const { Sequelize }               = require('sequelize');
+const   Helpers                   = require('../helpers/queryInterface');
+
+
+const connection     = new Connection();
+const queryInterface = new QueryInterface(connection);
+
+jest.mock('sequelize', () => {
+    const { MockSequelize } = require('../helpers/fixtures');
+    return { Sequelize: MockSequelize };
+});
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('QueryInterface', () => {
+    describe('QueryInterface#allTables', () => {
+        it('loads all table details from sequelize query interface', async () => {
+            const tables = await queryInterface.allTables();
+
+            expect(Helpers.mockQueryInterface.showAllTables).toHaveBeenCalledTimes(1);
+            expect(Helpers.mockQueryInterface.describeTable).toHaveBeenCalledTimes(2);
+            expect(Helpers.mockQueryInterface.describeTable).toHaveBeenCalledWith(Helpers.tableName1);
+            expect(Helpers.mockQueryInterface.describeTable).toHaveBeenCalledWith(Helpers.tableName2);
+            expect(tables).toEqual({
+                [Helpers.tableName1]: { name: Helpers.tableName1 },
+                [Helpers.tableName2]: { name: Helpers.tableName2 },
+            });
+        });
+    });
+
+
+    describe('QueryInterface#transaction', () => {
+        it('delegates transaction callback to sequelize', async () => {
+            const callback = jest.fn();
+
+            await queryInterface.transaction(callback);
+
+            expect(connection._sequelize.transaction).toHaveBeenCalledTimes(1);
+            expect(connection._sequelize.transaction).toHaveBeenCalledWith(callback);
+        });
+    });
+});

package/test/activeRecord/helpers/baseRecord.js

@@ -0,0 +1,32 @@
+const { Connection}               = require('../../../lib/activeRecord/db/connection');
+const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
+const   Mocks                     = require('./baseRecordMocks');
+const   TestHelpers               = require('@vida-global/test-helpers');
+
+
+/***************************************************************************************************
+* VARIABLES / VARIABLE GENERATION
+***************************************************************************************************/
+const colName = `${TestHelpers.Faker.Text.randomString()}_${TestHelpers.Faker.Text.randomString()}_${TestHelpers.Faker.Text.randomString()}`;
+const schema  = {created_at: {type: Mocks.dataTypeValue1},
+                 updated_at: {type: Mocks.dataTypeValue2},
+                [colName]:  {type: Mocks.dataTypeValue2}
+};
+
+
+/***************************************************************************************************
+* MOCKS
+***************************************************************************************************/
+const connectionConfig = {database: ' ', host: ' ', password: ' ', username: ' '};
+const configSpy        = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
+configSpy.mockImplementation(() => ({default: {test: connectionConfig}}));
+
+const connectionSpy = jest.spyOn(Connection.prototype, '_sequelize', 'get');
+connectionSpy.mockImplementation(() => new Mocks.MockSequelize());
+
+
+module.exports = {
+    colName,
+    ...Mocks,
+    schema,
+}

package/test/activeRecord/helpers/baseRecordMocks.js

@@ -0,0 +1,59 @@
+const TestHelpers = require('@vida-global/test-helpers');
+
+
+/***************************************************************************************************
+* VARIABLES / VARIABLE GENERATION
+***************************************************************************************************/
+const dataTypeKey1   = TestHelpers.Faker.Text.randomString();
+const dataTypeValue1 = TestHelpers.Faker.Text.randomString();
+const dataTypeKey2   = TestHelpers.Faker.Text.randomString();
+const dataTypeValue2 = TestHelpers.Faker.Text.randomString();
+
+
+/***************************************************************************************************
+* MOCKS
+***************************************************************************************************/
+class MockModel {
+    constructor(data, opts={}) {
+        this.dataValues = data || {}
+        this.options    = opts;
+        for (const [k,v] of Object.entries(this.dataValues)) {
+            this[k] = v;
+        }
+    };
+    static addHook             = jest.fn()
+    static init                = jest.fn()
+    static findByPk            = jest.fn();
+    static findAll             = jest.fn();
+    static primaryKeyAttribute = TestHelpers.Faker.Text.randomString();
+    toJSON()                   { return this.dataValues }
+}
+MockModel.findAll.mockImplementation(() => []);
+
+
+class MockSequelize {
+    static DataTypes = {
+        [dataTypeKey1]: {types: {postgres: [dataTypeValue1]}, key: dataTypeKey1},
+        [dataTypeKey2]: {types: {postgres: [dataTypeValue2]}, key: dataTypeKey2},
+        postgres:       {}
+    }
+}
+
+
+const redisClient = {
+    del:  jest.fn(),
+    mGet: jest.fn(),
+    mSet: jest.fn(),
+}
+const mockRedisClientFactory = () => redisClient;
+
+
+module.exports = {
+    dataTypeKey1,
+    dataTypeValue1,
+    dataTypeKey2,
+    dataTypeValue2,
+    MockModel,
+    mockRedisClientFactory,
+    MockSequelize,
+}

package/test/activeRecord/helpers/connection.js

@@ -0,0 +1,28 @@
+const TestHelpers = require('@vida-global/test-helpers');
+const Fixtures    = require('./fixtures');
+
+const defaultConfig   = Fixtures.buildPostgresConfig({ pool: { min: Math.random(), max: Math.random() } });
+const secondaryConfig = Fixtures.buildPostgresConfig();
+const sslConfig       = Fixtures.buildPostgresConfig({ ssl: true });
+const sqliteConfig    = { dialect: 'sqlite' };
+
+const originalNodeEnv = process.env.NODE_ENV;
+
+
+function buildConfigs() {
+    return {
+        default:       { test: defaultConfig, development: defaultConfig, production: defaultConfig },
+        [Fixtures.databaseId1]: { test: secondaryConfig, production: {} },
+        [Fixtures.databaseId2]: { test: sslConfig, production: {} },
+        sqlite:        { test: sqliteConfig },
+    };
+}
+
+
+module.exports = {
+    ...Fixtures,
+    buildConfigs,
+    defaultConfig,
+    originalNodeEnv,
+    secondaryConfig,
+};

package/test/activeRecord/helpers/connectionConfiguration.js

@@ -0,0 +1,32 @@
+const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
+const   Fixtures                  = require('./fixtures');
+
+
+const testConfig       = Fixtures.buildPostgresConfig();
+const productionConfig = Fixtures.buildPostgresConfig();
+const sqliteConfig     = { dialect: 'sqlite' };
+
+
+const originalEnv = {
+    dbPoolMin: process.env.DB_POOL_MIN,
+    dbPoolMax: process.env.DB_POOL_MAX,
+    nodeEnv: process.env.NODE_ENV,
+};
+
+
+const fetchConfigsSpy = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
+function mockConfigs(configs) {
+    fetchConfigsSpy.mockImplementation(() => configs);
+}
+
+
+module.exports = {
+    fetchConfigsSpy,
+    ...Fixtures,
+    mockConfigs,
+    originalEnv,
+    productionConfig,
+    sqliteConfig,
+    testConfig,
+}
+

package/test/activeRecord/helpers/fixtures.js

@@ -0,0 +1,39 @@
+const TestHelpers = require('@vida-global/test-helpers');
+
+/***************************************************************************************************
+* VARIABLES / VARIABLE GENERATION
+***************************************************************************************************/
+function buildPostgresConfig(overrides = {}) {
+    return {
+        database: TestHelpers.Faker.Text.randomString(),
+        host:     TestHelpers.Faker.Text.randomString(),
+        password: TestHelpers.Faker.Text.randomString(),
+        port:     TestHelpers.Faker.Math.randomNumber(),
+        username: TestHelpers.Faker.Text.randomString(),
+        ...overrides,
+    };
+}
+
+const databaseId1 = TestHelpers.Faker.Text.randomString();
+const databaseId2 = TestHelpers.Faker.Text.randomString();
+
+
+/***************************************************************************************************
+* MOCKS
+***************************************************************************************************/
+class MockSequelize {
+    constructor(_db, _user, _pass, options) {
+        this.options = options;
+    }
+
+    transaction = jest.fn(callback => callback());
+    close = jest.fn();
+}
+
+
+module.exports = {
+    buildPostgresConfig,
+    databaseId1,
+    databaseId2,
+    MockSequelize,
+};

package/test/activeRecord/helpers/migrator.js

@@ -0,0 +1,78 @@
+const { Migrator }                = require('../../../lib/activeRecord/db/migrator');
+const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
+const   Fixtures                  = require('./fixtures');
+const { QueryInterface }          = require('../../../lib/activeRecord/db/queryInterface');
+const { Sequelize }               = require('sequelize');
+const   TestHelpers               = require('@vida-global/test-helpers');
+
+
+/***************************************************************************************************
+* VARIABLES / VARIABLE GENERATION
+***************************************************************************************************/
+const connectionConfig   = { database: ' ', host: ' ', password: ' ', username: ' ' };
+const migrationModule    = { up: jest.fn(), down: jest.fn() };
+const randomNumber       = TestHelpers.Faker.Math.randomNumber
+const randomString       = TestHelpers.Faker.Text.randomString;
+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(),
+};
+
+
+function randomColumnDetails() {
+    return { [randomString()]: randomNumber() };
+}
+
+
+/***************************************************************************************************
+* MOCKS
+***************************************************************************************************/
+jest.mock('sequelize', () => {
+    class MockSequelize {
+        static DataTypes = { INTEGER: 'INTEGER', DATE: 'DATE' };
+    }
+    return { Sequelize: MockSequelize };
+});
+Sequelize.prototype.getQueryInterface = () => mockQueryInterface;
+
+
+jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs').mockImplementation(() => ({
+    default: { test: connectionConfig },
+}));
+
+
+const migrator = new Migrator();
+jest.spyOn(migrator, 'migrationModule', 'get').mockImplementation(() => migrationModule);
+
+
+const transactionSpy = jest.spyOn(QueryInterface.prototype, 'transaction');
+transactionSpy.mockImplementation(callback => callback());
+
+
+/***************************************************************************************************
+* ASSERTIONS
+***************************************************************************************************/
+async function expectQueryInterfaceCall(methodName, args) {
+    await migrator[methodName](...args);
+    expect(mockQueryInterface[methodName]).toHaveBeenCalledTimes(1);
+    expect(mockQueryInterface[methodName]).toHaveBeenCalledWith(...args);
+}
+
+
+module.exports = {
+  expectQueryInterfaceCall,
+  ...Fixtures,
+  migrationModule,
+  migrator,
+  mockQueryInterface,
+  randomColumnDetails,
+  randomNumber,
+  randomString,
+  transactionSpy,
+};

package/test/activeRecord/helpers/queryInterface.js

@@ -0,0 +1,29 @@
+const { Connection }              = require('../../../lib/activeRecord/db/connection');
+const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
+const   Fixtures                  = require('../helpers/fixtures');
+const { QueryInterface }          = require('../../../lib/activeRecord/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 })),
+};
+
+
+const connectionConfig = { database: ' ', host: ' ', password: ' ', username: ' ' };
+const configSpy = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
+configSpy.mockImplementation(() => ({ default: { test: connectionConfig } }));
+
+Sequelize.prototype.getQueryInterface = () => mockQueryInterface;
+
+
+module.exports = {
+    ...Fixtures,
+    mockQueryInterface,
+    tableName1,
+    tableName2,
+}