@vida-global/core 1.2.5 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vida-global/core",
-    "version": "1.2.5",
+    "version": "1.3.0",
     "description": "Core libraries for supporting Vida development",
     "author": "",
     "license": "ISC",

package/scripts/{active_record → activeRecord}/migrate.js

@@ -1,4 +1,4 @@
-const   migration = require('../../lib/active_record/db/migration');
+const   migration = require('../../lib/activeRecord/db/migration');
 const { Command } = require('commander');
 
 

package/test/{active_record → activeRecord}/baseRecord.test.js

@@ -1,80 +1,30 @@
-const { BaseRecord }              = require('../../lib/active_record/baseRecord');
-const { Connection}               = require('../../lib/active_record/db/connection');
-const { ConnectionConfiguration } = require('../../lib/active_record/db/connectionConfiguration');
-const { getActiveRecordSchema }   = require('../../lib/active_record/db/schema');
-const   importSchema              = require('../../lib/active_record/db/importSchema');
-const { Model, Sequelize }        = require('sequelize');
-const { redisClientFactory }      = require('../../lib/redis');
-const   TestHelpers               = require('@vida-global/test-helpers');
-const { camelize }                = require('inflection');
-
-
-const connectionConfig = {database: ' ', host: ' ', password: ' ', username: ' '};
-const configSpy        = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
-configSpy.mockImplementation(() => ({default: {test: connectionConfig}}));
-
-const mockSequelize = new (class MockSequelize {})();
-const connectionSpy = jest.spyOn(Connection.prototype, '_sequelize', 'get');
-connectionSpy.mockImplementation(() => mockSequelize);
+const { BaseRecord }            = require('../../lib/activeRecord/baseRecord');
+const { getActiveRecordSchema } = require('../../lib/activeRecord/db/schema');
+const   importSchema            = require('../../lib/activeRecord/db/importSchema');
+const { Model, Sequelize }      = require('sequelize');
+const { redisClientFactory }    = require('../../lib/redis');
+const   TestHelpers             = require('@vida-global/test-helpers');
+const { camelize }              = require('inflection');
+const   Helpers                 = require('./helpers/baseRecord');
 
 
 jest.mock('sequelize', () => {
-    const TestHelpers    = require('@vida-global/test-helpers');
-    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(() => []);
-
-    const dataTypeKey1   = TestHelpers.Faker.Text.randomString();
-    const dataTypeValue1 = TestHelpers.Faker.Text.randomString();
-    const dataTypeKey2   = TestHelpers.Faker.Text.randomString();
-    const dataTypeValue2 = TestHelpers.Faker.Text.randomString();
-    const Sequelize = {DataTypes: {
-        [dataTypeKey1]: {types: {postgres: [dataTypeValue1]}, key: dataTypeKey1},
-        [dataTypeKey2]: {types: {postgres: [dataTypeValue2]}, key: dataTypeKey2},
-        postgres:       {}
-    }};
-    return { Model: MockModel, Sequelize } ;
+    const  { MockModel, MockSequelize } = require('./helpers/baseRecordMocks');
+    return { Model: MockModel, Sequelize: MockSequelize } ;
 });
 
-const dataTypeKey1   = Object.keys(Sequelize.DataTypes)[0];
-const dataTypeKey2   = Object.keys(Sequelize.DataTypes)[1];
-const dataTypeValue1 = Sequelize.DataTypes[dataTypeKey1].types.postgres[0];
-const dataTypeValue2 = Sequelize.DataTypes[dataTypeKey2].types.postgres[0];
-const col1Name       = `${TestHelpers.Faker.Text.randomString()}_${TestHelpers.Faker.Text.randomString()}_${TestHelpers.Faker.Text.randomString()}`;
-
-
 jest.mock('../../lib/redis', () => {
-    const client = {
-        del:  jest.fn(),
-        mGet: jest.fn(),
-        mSet: jest.fn(),
-    }
-    const redisClientFactory = () => client;
-
-    return { redisClientFactory };
+    const { mockRedisClientFactory } = require('./helpers/baseRecordMocks');
+    return { redisClientFactory: mockRedisClientFactory };
 });
 
-jest.mock('../../lib/active_record/db/importSchema', () => jest.fn());
-const schema = {created_at: {type: dataTypeValue1},
-                updated_at: {type: dataTypeValue2},
-                [col1Name]: {type: dataTypeValue2}
-};
-importSchema.mockImplementation(() => structuredClone(schema));
-beforeEach(() => importSchema.mockImplementation(() => structuredClone(schema)));
+jest.mock('../../lib/activeRecord/db/importSchema', () => jest.fn());
+importSchema.mockImplementation(() => structuredClone(Helpers.schema));
+
+
+beforeEach(() => {
+    importSchema.mockImplementation(() => structuredClone(Helpers.schema));
+})
 
 
 afterEach(() => {
@@ -94,9 +44,9 @@ describe('BaseRecord', () => {
         it ('calls `getBaseRecordSchema` and passes the response to init', () => {
             class User extends BaseRecord {}
             User.initialize();
-            const tableDetails = {created_at: {type: Sequelize.DataTypes[dataTypeKey1]},
-                                  updated_at: {type: Sequelize.DataTypes[dataTypeKey2]},
-                                  [col1Name]: {type: Sequelize.DataTypes[dataTypeKey2]}
+            const tableDetails = {created_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey1]},
+                                  updated_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey2]},
+                                  [Helpers.colName]: {type: Sequelize.DataTypes[Helpers.dataTypeKey2]}
             };
             expect(importSchema).toHaveBeenCalledTimes(1);
             expect(Model.init).toHaveBeenCalledTimes(1);
@@ -105,7 +55,7 @@ describe('BaseRecord', () => {
                                                       createdAt: 'created_at',
                                                       deletedAt: 'deleted_at',
                                                       modelName: 'User',
-                                                      sequelize: mockSequelize,
+                                                      sequelize: new Helpers.MockSequelize(),
                                                       tableName: 'users',
                                                       updatedAt: 'updated_at'
                                                     });
@@ -120,7 +70,7 @@ describe('BaseRecord', () => {
                                                       createdAt: 'created_at',
                                                       deletedAt: 'deleted_at',
                                                       modelName: 'User',
-                                                      sequelize: mockSequelize,
+                                                      sequelize: new Helpers.MockSequelize(),
                                                       tableName: 'users',
                                                       timestamps: false,
                                                       updatedAt: 'updated_at'
@@ -148,17 +98,17 @@ describe('BaseRecord', () => {
 
         it ('allows for overriding getters and setters', () => {
             class User extends BaseRecord {}
-            const getterMethodName = `_get${camelize(col1Name)}`;
-            const setterMethodName = `_set${camelize(col1Name)}`;
+            const getterMethodName = `_get${camelize(Helpers.colName)}`;
+            const setterMethodName = `_set${camelize(Helpers.colName)}`;
             const getter = jest.fn();
             const setter = jest.fn();
             User.prototype[getterMethodName] = getter;
             User.prototype[setterMethodName] = setter;
             User.initialize();
-            const tableDetails = {created_at: {type: Sequelize.DataTypes[dataTypeKey1]},
-                                  updated_at: {type: Sequelize.DataTypes[dataTypeKey2]},
-                                  [col1Name]: {
-                                      type: Sequelize.DataTypes[dataTypeKey2],
+            const tableDetails = {created_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey1]},
+                                  updated_at: {type: Sequelize.DataTypes[Helpers.dataTypeKey2]},
+                                  [Helpers.colName]: {
+                                      type: Sequelize.DataTypes[Helpers.dataTypeKey2],
                                       get: getter,
                                       set: setter,
                                   }};
@@ -167,7 +117,7 @@ describe('BaseRecord', () => {
                                                       createdAt: 'created_at',
                                                       deletedAt: 'deleted_at',
                                                       modelName: 'User',
-                                                      sequelize: mockSequelize,
+                                                      sequelize: new Helpers.MockSequelize(),
                                                       tableName: 'users',
                                                       updatedAt: 'updated_at'
                                                     });
@@ -535,27 +485,33 @@ describe('BaseRecord', () => {
         });
 
 
-        describe('BaseRecord._afterSaveCacheHook', () => {
-            it ('is called as an after save hook for cached models', () => {
-                expect(Person.addHook).toHaveBeenCalledTimes(0);
-                Person.initialize();
-                expect(Person.addHook).toHaveBeenCalledTimes(1);
-                expect(Person.addHook).toHaveBeenCalledWith('afterSave', Person._afterSaveCacheHook);
+        const hooks = ['Save', 'Destroy'];
+        describe.each(hooks)('BaseRecord._after%sCacheHook', (hook) => {
+            class Cacheable extends BaseRecord {
+                static get isCacheable() { return true; }
+            }
+            const hookMethod = `_after${hook}CacheHook`;
+
+            it (`is called as an after ${hook.toLowerCase()} hook for cached models`, () => {
+                expect(Cacheable.addHook).toHaveBeenCalledTimes(0);
+                Cacheable.initialize();
+                expect(Cacheable.addHook).toHaveBeenCalledTimes(2);
+                expect(Cacheable.addHook).toHaveBeenCalledWith(`after${hook}`, Cacheable[hookMethod]);
             });
 
             it ('is not called as an after save hook for non cached models', () => {
                 class Foo extends BaseRecord {}
                 Foo.initialize();
-                expect(Person.addHook).toHaveBeenCalledTimes(0);
+                expect(Cacheable.addHook).toHaveBeenCalledTimes(0);
             });
 
             it ('calls BaseRecord#clearSelfCache and BaseRecord#updateCache', async () => {
-                const person    = new Person();
+                const person    = new Cacheable();
                 const clearSpy  = jest.spyOn(person, 'clearSelfCache');
                 const updateSpy = jest.spyOn(person, 'updateCache');
                 const options   = {};
 
-                await Person._afterSaveCacheHook(person,options);
+                await Cacheable[hookMethod](person,options);
 
                 expect(clearSpy).toHaveBeenCalledTimes(1);
                 expect(updateSpy).toHaveBeenCalledTimes(1);

package/test/activeRecord/db/connection.test.js

@@ -0,0 +1,149 @@
+const { Connection }              = require('../../../lib/activeRecord/db/connection');
+const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
+const   Helpers                   = require('../helpers/connection');
+
+
+let fetchConfigsSpy;
+
+jest.mock('sequelize', () => {
+    const { MockSequelize } = require('../helpers/fixtures');
+    return { Sequelize: MockSequelize };
+});
+
+beforeEach(() => {
+    fetchConfigsSpy = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
+    fetchConfigsSpy.mockImplementation(Helpers.buildConfigs);
+});
+
+afterEach(() => {
+    fetchConfigsSpy.mockRestore();
+    Connection.clearConnectionsCache();
+    process.env.NODE_ENV = Helpers.originalNodeEnv;
+});
+
+
+describe('Connection', () => {
+    describe('Connection#_sequelize', () => {
+        it ('caches connections per database id', () => {
+            const conn1 = new Connection();
+            const conn2 = new Connection();
+            const conn3 = new Connection(Helpers.databaseId1);
+
+            expect(conn1._sequelize).toBe(conn2._sequelize);
+            expect(conn1._sequelize).not.toBe(conn3._sequelize);
+        });
+
+
+        describe('settings (postgres)', () => {
+            it.each([
+                ['default',   () => new Connection(), Helpers.defaultConfig],
+                ['secondary', () => new Connection(Helpers.databaseId1), Helpers.secondaryConfig],
+            ])('maps %s postgres config into sequelize options', (_label, connectionFactory, expectedConfig) => {
+                const connection = connectionFactory();
+                const options = connection._sequelize.options;
+
+                expect(options.database).toEqual(expectedConfig.database);
+                expect(options.dialect).toEqual('postgres');
+                expect(options.host).toEqual(expectedConfig.host);
+                expect(options.password).toEqual(expectedConfig.password);
+                expect(options.port).toEqual(expectedConfig.port);
+                expect(options.username).toEqual(expectedConfig.username);
+            });
+
+            it ('requires ssl when configured', () => {
+                const conn = new Connection(Helpers.databaseId2);
+
+                expect(conn._sequelize.options.dialectOptions).toEqual({ ssl: { require: true } });
+            });
+
+            it.each([
+                ['development', undefined],
+                ['production', false],
+            ])('sets logging for %s', (environment, expectedLogging) => {
+                process.env.NODE_ENV = environment;
+                const conn = new Connection();
+
+                expect(conn._sequelize.options.logging).toBe(expectedLogging);
+            });
+
+            it ('sets the configured pool or defaults', () => {
+                const conn1 = new Connection();
+                const conn2 = new Connection(Helpers.databaseId1);
+
+                expect(conn1._sequelize.options.pool).toEqual(Helpers.defaultConfig.pool);
+                expect(conn2._sequelize.options.pool).toEqual({ min: 0, max: 5 });
+            });
+
+            it ('configures underscored naming', () => {
+                const conn = new Connection();
+
+                expect(conn._sequelize.options.define.underscored).toBeTruthy();
+            });
+
+            it ('configures replication when readers are present', () => {
+                const replicatedConfig = Helpers.buildPostgresConfig({
+                    readers: [Helpers.buildPostgresConfig(), Helpers.buildPostgresConfig()],
+                });
+                fetchConfigsSpy.mockImplementation(() => ({ default: { test: replicatedConfig } }));
+
+                const conn = new Connection();
+                const options = conn._sequelize.options;
+
+                expect(options.database).toBe(undefined);
+                expect(options.host).toBe(undefined);
+                expect(options.port).toBe(undefined);
+                expect(options.username).toBe(undefined);
+                expect(options.password).toBe(undefined);
+                expect(options.replication).toEqual({
+                    write: {
+                        database: replicatedConfig.database,
+                        host:     replicatedConfig.host,
+                        password: replicatedConfig.password,
+                        port:     replicatedConfig.port,
+                        username: replicatedConfig.username,
+                    },
+                    read: replicatedConfig.readers,
+                });
+            });
+        });
+
+
+        describe('settings (sqlite)', () => {
+            it ('maps sqlite options', () => {
+                const conn = new Connection('sqlite');
+
+                expect(conn._sequelize.options.dialect).toEqual('sqlite');
+                expect(conn._sequelize.options.storage).toEqual(
+                    `${process.cwd()}/config/db/database.test.sqlite`,
+                );
+            });
+        });
+    });
+
+
+    describe('Connection#close', () => {
+        it ('closes a single connection', () => {
+            const conn = new Connection();
+            conn._sequelize; // reference it to initiate the connection
+
+            conn.close();
+
+            expect(conn._sequelize.close).toHaveBeenCalledTimes(1);
+        });
+    });
+
+
+    describe('Connection.closeAll', () => {
+        it ('closes all cached connections', () => {
+            const defaultConnection   = new Connection();
+            const secondaryConnection = new Connection(Helpers.databaseId1);
+            defaultConnection._sequelize;   // reference it to initiate the connection
+            secondaryConnection._sequelize; // reference it to initiate the connection
+
+            Connection.closeAll();
+
+            expect(defaultConnection._sequelize.close).toHaveBeenCalledTimes(1);
+            expect(secondaryConnection._sequelize.close).toHaveBeenCalledTimes(1);
+        });
+    });
+});

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,
+            );
+        });
+    });
+});