@vida-global/core 2.0.5 → 2.0.7

package/test/activeRecord/baseRecord.test.js

@@ -1,8 +1,9 @@
 const { BaseRecord }            = require('../../lib/activeRecord/baseRecord');
+const { Connection }            = require('../../lib/activeRecord/db/connection');
 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 { mockRedisClientFactory } = require('./helpers/baseRecordMocks');
 const   TestHelpers             = require('@vida-global/test-helpers');
 const { camelize }              = require('inflection');
 const   Helpers                 = require('./helpers/baseRecord');
@@ -13,11 +14,6 @@ jest.mock('sequelize', () => {
     return { Model: MockModel, Sequelize: MockSequelize } ;
 });
 
-jest.mock('../../lib/redis', () => {
-    const { mockRedisClientFactory } = require('./helpers/baseRecordMocks');
-    return { redisClientFactory: mockRedisClientFactory };
-});
-
 jest.mock('../../lib/activeRecord/db/importSchema', () => jest.fn());
 importSchema.mockImplementation(() => structuredClone(Helpers.schema));
 
@@ -40,6 +36,50 @@ describe('BaseRecord', () => {
     });
 
 
+    describe('BaseRecord.buildConnection', () => {
+        it ('builds an instance of the connectionClass', () => {
+            class FakeConnection {}
+            class User extends BaseRecord {
+                static get connectionClass() { return FakeConnection; }
+            }
+            expect(User.buildConnection()).toBeInstanceOf(FakeConnection);
+        });
+
+        it ('passes the model databaseId to the connection', () => {
+            const databaseId = TestHelpers.Faker.Text.randomString();
+            let   receivedId;
+            class FakeConnection {
+                constructor(id) { receivedId = id; }
+            }
+            class User extends BaseRecord {
+                static get connectionClass() { return FakeConnection; }
+                static get databaseId()      { return databaseId; }
+            }
+
+            User.buildConnection();
+
+            expect(receivedId).toEqual(databaseId);
+        });
+    });
+
+
+    describe('BaseRecord.connection', () => {
+        it ('memoizes the connection built by buildConnection', () => {
+            class FakeConnection {}
+            class User extends BaseRecord {
+                static get connectionClass() { return FakeConnection; }
+            }
+            const buildSpy = jest.spyOn(User, 'buildConnection');
+
+            const first  = User.connection;
+            const second = User.connection;
+
+            expect(first).toBe(second);
+            expect(buildSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+
+
     describe('BaseRecord.initialize', () => {
         it ('calls `getBaseRecordSchema` and passes the response to init', () => {
             class User extends BaseRecord {}
@@ -331,11 +371,12 @@ describe('BaseRecord', () => {
 
     describe('Caching', () => {
         class Person extends BaseRecord {
-            static get isCacheable() { return true; }
+            static get isCacheable()       { return true; }
+            static get redisClientFactory() { return mockRedisClientFactory; }
         }
         let redisClient
-        beforeEach(async () => {
-            redisClient = await redisClientFactory();
+        beforeEach(() => {
+            redisClient = mockRedisClientFactory();
             redisClient.mGet.mockImplementation(keys => new Array(keys.length));
         });
 
@@ -617,7 +658,8 @@ describe('BaseRecord', () => {
         const hooks = ['Save', 'Destroy'];
         describe.each(hooks)('BaseRecord._after%sCacheHook', (hook) => {
             class Cacheable extends BaseRecord {
-                static get isCacheable() { return true; }
+                static get isCacheable()       { return true; }
+                static get redisClientFactory() { return mockRedisClientFactory; }
             }
             const hookMethod = `_after${hook}CacheHook`;
 

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

@@ -1,16 +1,13 @@
 const { Connection }              = require('../../../lib/activeRecord/db/connection');
 const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
 const   Helpers                   = require('../helpers/connection');
+const { MockConnection }          = require('../helpers/fixtures');
 const { snapshotEnv }             = require('../../helpers/env');
 
 
 let fetchConfigsSpy;
 let restoreEnv;
 
-jest.mock('sequelize', () => {
-    const { MockSequelize } = require('../helpers/fixtures');
-    return { Sequelize: MockSequelize };
-});
 
 beforeEach(() => {
     restoreEnv = snapshotEnv(['NODE_ENV']);
@@ -28,9 +25,9 @@ afterEach(() => {
 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);
+            const conn1 = new MockConnection();
+            const conn2 = new MockConnection();
+            const conn3 = new MockConnection(Helpers.databaseId1);
 
             expect(conn1._sequelize).toBe(conn2._sequelize);
             expect(conn1._sequelize).not.toBe(conn3._sequelize);
@@ -39,8 +36,8 @@ describe('Connection', () => {
 
         describe('settings (postgres)', () => {
             it.each([
-                ['default',   () => new Connection(), Helpers.defaultConfig],
-                ['secondary', () => new Connection(Helpers.databaseId1), Helpers.secondaryConfig],
+                ['default',   () => new MockConnection(), Helpers.defaultConfig],
+                ['secondary', () => new MockConnection(Helpers.databaseId1), Helpers.secondaryConfig],
             ])('maps %s postgres config into sequelize options', (_label, connectionFactory, expectedConfig) => {
                 const connection = connectionFactory();
                 const options = connection._sequelize.options;
@@ -54,7 +51,7 @@ describe('Connection', () => {
             });
 
             it ('requires ssl when configured', () => {
-                const conn = new Connection(Helpers.databaseId2);
+                const conn = new MockConnection(Helpers.databaseId2);
 
                 expect(conn._sequelize.options.dialectOptions).toEqual({ ssl: { require: true } });
             });
@@ -64,21 +61,21 @@ describe('Connection', () => {
                 ['production', false],
             ])('sets logging for %s', (environment, expectedLogging) => {
                 process.env.NODE_ENV = environment;
-                const conn = new Connection();
+                const conn = new MockConnection();
 
                 expect(conn._sequelize.options.logging).toBe(expectedLogging);
             });
 
             it ('sets the configured pool or defaults', () => {
-                const conn1 = new Connection();
-                const conn2 = new Connection(Helpers.databaseId1);
+                const conn1 = new MockConnection();
+                const conn2 = new MockConnection(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();
+                const conn = new MockConnection();
 
                 expect(conn._sequelize.options.define.underscored).toBeTruthy();
             });
@@ -89,7 +86,7 @@ describe('Connection', () => {
                 });
                 fetchConfigsSpy.mockImplementation(() => ({ default: { test: replicatedConfig } }));
 
-                const conn = new Connection();
+                const conn = new MockConnection();
                 const options = conn._sequelize.options;
 
                 expect(options.database).toBe(undefined);
@@ -113,7 +110,7 @@ describe('Connection', () => {
 
         describe('settings (sqlite)', () => {
             it ('maps sqlite options', () => {
-                const conn = new Connection('sqlite');
+                const conn = new MockConnection('sqlite');
 
                 expect(conn._sequelize.options.dialect).toEqual('sqlite');
                 expect(conn._sequelize.options.storage).toEqual(
@@ -126,7 +123,7 @@ describe('Connection', () => {
 
     describe('Connection#close', () => {
         it ('closes a single connection', () => {
-            const conn = new Connection();
+            const conn = new MockConnection();
             conn._sequelize; // reference it to initiate the connection
 
             conn.close();
@@ -138,8 +135,8 @@ describe('Connection', () => {
 
     describe('Connection.closeAll', () => {
         it ('closes all cached connections', () => {
-            const defaultConnection   = new Connection();
-            const secondaryConnection = new Connection(Helpers.databaseId1);
+            const defaultConnection   = new MockConnection();
+            const secondaryConnection = new MockConnection(Helpers.databaseId1);
             defaultConnection._sequelize;   // reference it to initiate the connection
             secondaryConnection._sequelize; // reference it to initiate the connection
 

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

@@ -1,18 +1,10 @@
-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 connection     = new Helpers.MockConnection();
 const queryInterface = new QueryInterface(connection);
 
-jest.mock('sequelize', () => {
-    const { MockSequelize } = require('../helpers/fixtures');
-    return { Sequelize: MockSequelize };
-});
-
 afterEach(() => {
     jest.clearAllMocks();
 });

package/test/activeRecord/db/schema.test.js

@@ -1,32 +1,32 @@
 jest.mock('../../../lib/activeRecord/db/importSchema', () => jest.fn());
 
-jest.mock('../../../lib/activeRecord/db/connection', () => {
-    const clearConnectionsCache = jest.fn();
-    const allTables             = jest.fn();
-    function Connection() {
-        this.queryInterface = { allTables };
-    }
-    Connection.clearConnectionsCache = clearConnectionsCache;
-    Connection.__allTables           = allTables;
-    return { Connection };
-});
-
-jest.mock('../../../lib/activeRecord/db/connectionConfiguration', () => ({
-    ConnectionConfiguration: { configuredDatabaseIds: jest.fn() }
-}));
-
 jest.mock('../../../lib/activeRecord/utils', () => {
     const actual = jest.requireActual('../../../lib/activeRecord/utils');
     return { ...actual, ensureSchemasDirectory: jest.fn() };
 });
 
-const   fs                                                   = require('node:fs');
-const   importSchema                                         = require('../../../lib/activeRecord/db/importSchema');
-const { Connection }                                         = require('../../../lib/activeRecord/db/connection');
-const { ConnectionConfiguration }                            = require('../../../lib/activeRecord/db/connectionConfiguration');
-const   utils                                                = require('../../../lib/activeRecord/utils');
-const { generateActiveRecordSchemaFiles, getActiveRecordSchema } = require('../../../lib/activeRecord/db/schema');
-const { Sequelize }                                          = require('sequelize');
+const   fs                        = require('node:fs');
+const   importSchema              = require('../../../lib/activeRecord/db/importSchema');
+const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
+const   utils                     = require('../../../lib/activeRecord/utils');
+const { SchemaFileGenerator, generateActiveRecordSchemaFiles, getActiveRecordSchema } = require('../../../lib/activeRecord/db/schema');
+const { Sequelize }               = require('sequelize');
+
+
+const allTables             = jest.fn();
+const clearConnectionsCache = jest.fn();
+
+
+class FakeConnection {
+    static clearConnectionsCache = clearConnectionsCache;
+    get queryInterface() { return { allTables }; }
+}
+
+
+class TestSchemaFileGenerator extends SchemaFileGenerator {
+    get connectionClass() { return FakeConnection; }
+}
+
 
 afterEach(() => {
     jest.clearAllMocks();
@@ -157,61 +157,79 @@ describe('activeRecord/db/schema', () => {
     });
 
 
-    describe('.generateActiveRecordSchemaFiles', () => {
+    describe('SchemaFileGenerator', () => {
         let writeFileSpy;
+        let databaseIdsSpy;
 
         beforeEach(() => {
-            writeFileSpy = jest.spyOn(fs, 'writeFile').mockImplementation((p, c, cb) => cb && cb(null));
+            writeFileSpy   = jest.spyOn(fs, 'writeFile').mockImplementation((p, c, cb) => cb && cb(null));
+            databaseIdsSpy = jest.spyOn(ConnectionConfiguration, 'configuredDatabaseIds');
         });
 
         afterEach(() => {
             writeFileSpy.mockRestore();
+            databaseIdsSpy.mockRestore();
         });
 
-        it ('ensures the schemas directory exists before writing', async () => {
-            ConnectionConfiguration.configuredDatabaseIds.mockReturnValue([]);
-            await generateActiveRecordSchemaFiles();
-            expect(utils.ensureSchemasDirectory).toHaveBeenCalledTimes(1);
-        });
 
-        it ('writes one schema file per configured database id', async () => {
-            ConnectionConfiguration.configuredDatabaseIds.mockReturnValue(['main', 'analytics']);
-            Connection.__allTables.mockResolvedValue({ users: { id: { type: 'INTEGER' } } });
+        describe('#run', () => {
+            it ('ensures the schemas directory exists before writing', async () => {
+                databaseIdsSpy.mockReturnValue([]);
+                await new TestSchemaFileGenerator().run();
+                expect(utils.ensureSchemasDirectory).toHaveBeenCalledTimes(1);
+            });
 
-            await generateActiveRecordSchemaFiles();
-            expect(Connection.clearConnectionsCache).toHaveBeenCalledTimes(2);
-            expect(writeFileSpy).toHaveBeenCalledTimes(2);
+            it ('writes one schema file per configured database id', async () => {
+                databaseIdsSpy.mockReturnValue(['main', 'analytics']);
+                allTables.mockResolvedValue({ users: { id: { type: 'INTEGER' } } });
 
-            const writtenPaths = writeFileSpy.mock.calls.map(c => c[0]);
-            expect(writtenPaths[0]).toEqual(`${utils.schemasDirectory}/main.js`);
-            expect(writtenPaths[1]).toEqual(`${utils.schemasDirectory}/analytics.js`);
+                await new TestSchemaFileGenerator().run();
+                expect(clearConnectionsCache).toHaveBeenCalledTimes(2);
+                expect(writeFileSpy).toHaveBeenCalledTimes(2);
 
-            const writtenBody = writeFileSpy.mock.calls[0][1];
-            expect(writtenBody).toContain('module.exports = ');
-            expect(writtenBody).toContain('"users"');
-        });
+                const writtenPaths = writeFileSpy.mock.calls.map(c => c[0]);
+                expect(writtenPaths[0]).toEqual(`${utils.schemasDirectory}/main.js`);
+                expect(writtenPaths[1]).toEqual(`${utils.schemasDirectory}/analytics.js`);
 
-        it ('logs an error when fs.writeFile fails (does not reject)', async () => {
-            const { logger } = require('../../../lib/logger');
-            const errSpy     = jest.spyOn(logger, 'error').mockImplementation(() => {});
-            ConnectionConfiguration.configuredDatabaseIds.mockReturnValue(['main']);
-            Connection.__allTables.mockResolvedValue({});
-            writeFileSpy.mockImplementation((p, c, cb) => cb(new Error('disk full')));
+                const writtenBody = writeFileSpy.mock.calls[0][1];
+                expect(writtenBody).toContain('module.exports = ');
+                expect(writtenBody).toContain('"users"');
+            });
 
-            await generateActiveRecordSchemaFiles();
-            expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Unable to write new schema file'));
-            errSpy.mockRestore();
+            it ('logs an error when fs.writeFile fails (does not reject)', async () => {
+                const { logger } = require('../../../lib/logger');
+                const errSpy     = jest.spyOn(logger, 'error').mockImplementation(() => {});
+                databaseIdsSpy.mockReturnValue(['main']);
+                allTables.mockResolvedValue({});
+                writeFileSpy.mockImplementation((p, c, cb) => cb(new Error('disk full')));
+
+                await new TestSchemaFileGenerator().run();
+                expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Unable to write new schema file'));
+                errSpy.mockRestore();
+            });
+
+            it ('logs success when fs.writeFile succeeds', async () => {
+                const { logger } = require('../../../lib/logger');
+                const infoSpy    = jest.spyOn(logger, 'info').mockImplementation(() => {});
+                databaseIdsSpy.mockReturnValue(['main']);
+                allTables.mockResolvedValue({});
+
+                await new TestSchemaFileGenerator().run();
+                expect(infoSpy).toHaveBeenCalledWith(expect.stringContaining('New schemas file written'));
+                infoSpy.mockRestore();
+            });
         });
+    });
 
-        it ('logs success when fs.writeFile succeeds', async () => {
-            const { logger } = require('../../../lib/logger');
-            const infoSpy    = jest.spyOn(logger, 'info').mockImplementation(() => {});
-            ConnectionConfiguration.configuredDatabaseIds.mockReturnValue(['main']);
-            Connection.__allTables.mockResolvedValue({});
+
+    describe('.generateActiveRecordSchemaFiles', () => {
+        it ('runs a SchemaFileGenerator', async () => {
+            const runSpy = jest.spyOn(SchemaFileGenerator.prototype, 'run').mockResolvedValue();
 
             await generateActiveRecordSchemaFiles();
-            expect(infoSpy).toHaveBeenCalledWith(expect.stringContaining('New schemas file written'));
-            infoSpy.mockRestore();
+
+            expect(runSpy).toHaveBeenCalledTimes(1);
+            runSpy.mockRestore();
         });
     });
 });

package/test/activeRecord/helpers/fixtures.js

@@ -1,4 +1,5 @@
-const TestHelpers = require('@vida-global/test-helpers');
+const { Connection } = require('../../../lib/activeRecord/db/connection');
+const   TestHelpers  = require('@vida-global/test-helpers');
 
 /***************************************************************************************************
 * VARIABLES / VARIABLE GENERATION
@@ -31,9 +32,17 @@ class MockSequelize {
 }
 
 
+class MockConnection extends Connection {
+    get ormEngineClass() {
+        return MockSequelize;
+    }
+}
+
+
 module.exports = {
     buildPostgresConfig,
     databaseId1,
     databaseId2,
+    MockConnection,
     MockSequelize,
 };

package/test/activeRecord/helpers/queryInterface.js

@@ -1,8 +1,6 @@
 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');
 
 
@@ -18,11 +16,24 @@ const connectionConfig = { database: ' ', host: ' ', password: ' ', username: '
 const configSpy = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
 configSpy.mockImplementation(() => ({ default: { test: connectionConfig } }));
 
-Sequelize.prototype.getQueryInterface = () => mockQueryInterface;
+
+/***************************************************************************************************
+* MOCKS
+***************************************************************************************************/
+class MockSequelize extends Fixtures.MockSequelize {
+    getQueryInterface() { return mockQueryInterface; }
+}
+
+
+class MockConnection extends Connection {
+    get ormEngineClass() { return MockSequelize; }
+}
 
 
 module.exports = {
     ...Fixtures,
+    MockConnection,
+    MockSequelize,
     mockQueryInterface,
     tableName1,
     tableName2,

package/test/jobQueue/abstractJob.test.js

@@ -1,34 +1,6 @@
-const TestHelpers              = require('@vida-global/test-helpers');
-const { defineJobSubclass }    = require('./helpers/abstractJob');
-
-
-jest.mock('../../lib/jobQueue/queue', () => ({
-    getQueue: jest.fn(),
-}));
-
-jest.mock('../../lib/logger', () => {
-    const { buildLoggerMock } = require('./helpers/loggerMock');
-    return { logger: buildLoggerMock() };
-});
-
-jest.mock('../../lib/apm', () => {
-    const { buildApmMock } = require('./helpers/apmMock');
-    return buildApmMock();
-});
-
-
-let AbstractJob;
-let getQueue;
-let logger;
-let APM;
-
-beforeEach(() => {
-    jest.resetModules();
-    ({ AbstractJob } = require('../../lib/jobQueue/abstractJob'));
-    ({ getQueue }    = require('../../lib/jobQueue/queue'));
-    ({ logger }      = require('../../lib/logger'));
-    APM              = require('../../lib/apm');
-});
+const TestHelpers           = require('@vida-global/test-helpers');
+const { defineJobSubclass } = require('./helpers/abstractJob');
+const { AbstractJob }       = require('../../lib/jobQueue/abstractJob');
 
 
 afterEach(() => {
@@ -71,12 +43,12 @@ describe('AbstractJob', () => {
             const name        = TestHelpers.Faker.Text.randomString();
             const Subclass    = defineJobSubclass(AbstractJob, { queueName: name });
             const stubQueue   = { queueJob: jest.fn() };
-            getQueue.mockReturnValue(stubQueue);
+            Subclass.queueResolver.mockReturnValue(stubQueue);
 
             const result = Subclass.queue('arg1', 'arg2');
 
-            expect(getQueue).toHaveBeenCalledTimes(1);
-            expect(getQueue).toHaveBeenCalledWith(name);
+            expect(Subclass.queueResolver).toHaveBeenCalledTimes(1);
+            expect(Subclass.queueResolver).toHaveBeenCalledWith(name);
             expect(result).toBe(stubQueue);
         });
 
@@ -85,12 +57,12 @@ describe('AbstractJob', () => {
             const arg2          = TestHelpers.Faker.Math.randomNumber();
             const queueNameSpy  = jest.fn(() => 'dynamic-queue');
             const Subclass      = defineJobSubclass(AbstractJob, { queueNameFn: queueNameSpy });
-            getQueue.mockReturnValue({ queueJob: jest.fn() });
+            Subclass.queueResolver.mockReturnValue({ queueJob: jest.fn() });
 
             Subclass.queue(arg1, arg2);
 
             expect(queueNameSpy).toHaveBeenCalledWith(arg1, arg2);
-            expect(getQueue).toHaveBeenCalledWith('dynamic-queue');
+            expect(Subclass.queueResolver).toHaveBeenCalledWith('dynamic-queue');
         });
     });
 
@@ -100,7 +72,7 @@ describe('AbstractJob', () => {
             const name      = TestHelpers.Faker.Text.randomString();
             const Subclass  = defineJobSubclass(AbstractJob, { queueName: name });
             const stubQueue = { queueJob: jest.fn().mockResolvedValue(undefined) };
-            getQueue.mockReturnValue(stubQueue);
+            Subclass.queueResolver.mockReturnValue(stubQueue);
             const arg1 = TestHelpers.Faker.Text.randomString();
             const arg2 = TestHelpers.Faker.Math.randomNumber();
 
@@ -118,7 +90,7 @@ describe('AbstractJob', () => {
             const Subclass = defineJobSubclass(AbstractJob);
             let resolveQueueJob;
             const queueJobPromise = new Promise((resolve) => { resolveQueueJob = resolve; });
-            getQueue.mockReturnValue({ queueJob: jest.fn().mockReturnValue(queueJobPromise) });
+            Subclass.queueResolver.mockReturnValue({ queueJob: jest.fn().mockReturnValue(queueJobPromise) });
 
             const callPromise = Subclass.queueJob();
             let resolved      = false;
@@ -267,8 +239,8 @@ describe('AbstractJob', () => {
 
             job.addApmAttribute(key, value);
 
-            expect(APM.addCustomAttribute).toHaveBeenCalledTimes(1);
-            expect(APM.addCustomAttribute).toHaveBeenCalledWith(key, value);
+            expect(job.apm.addCustomAttribute).toHaveBeenCalledTimes(1);
+            expect(job.apm.addCustomAttribute).toHaveBeenCalledWith(key, value);
         });
     });
 
@@ -283,8 +255,8 @@ describe('AbstractJob', () => {
 
             const result = job.startApmSegment(name, true, handler);
 
-            expect(APM.startSegment).toHaveBeenCalledTimes(1);
-            expect(APM.startSegment).toHaveBeenCalledWith(name, true, handler);
+            expect(job.apm.startSegment).toHaveBeenCalledTimes(1);
+            expect(job.apm.startSegment).toHaveBeenCalledWith(name, true, handler);
             expect(result).toEqual(sentinel);
         });
     });
@@ -297,7 +269,7 @@ describe('AbstractJob', () => {
             const id       = TestHelpers.Faker.Text.randomString();
             await job._run(id, [], jest.fn());
 
-            const scope = logger[Subclass.name];
+            const scope = job.loggerLibrary[Subclass.name];
             const child = job.logger;
 
             expect(scope.child).toHaveBeenCalledWith(id);

package/test/jobQueue/helpers/abstractJob.js

@@ -1,14 +1,25 @@
-const TestHelpers = require('@vida-global/test-helpers');
+const TestHelpers         = require('@vida-global/test-helpers');
+const { buildLoggerMock } = require('./loggerMock');
+const { buildApmMock }    = require('./apmMock');
 
 
 /***************************************************************************************************
 * SUBCLASS FACTORY
+* Each subclass injects the queueResolver/logger/apm seams so tests assert on the injected doubles
+* (Subclass.queueResolver, job.loggerLibrary, job.apm) instead of mocking the modules.
 ***************************************************************************************************/
 function defineJobSubclass(AbstractJob, { queueName, queueNameFn, run, ...overrides } = {}) {
-    const resolvedName = queueName || TestHelpers.Faker.Text.randomString();
-    const nameFunction = queueNameFn || (() => resolvedName);
+    const resolvedName  = queueName || TestHelpers.Faker.Text.randomString();
+    const nameFunction  = queueNameFn || (() => resolvedName);
+    const loggerMock    = buildLoggerMock();
+    const apmMock       = buildApmMock();
+    const queueResolver = jest.fn();
+
     const Subclass = class extends AbstractJob {
         static queueName(...jobArgs) { return nameFunction(...jobArgs); }
+        static get queueResolver()   { return queueResolver; }
+        get loggerLibrary()          { return loggerMock; }
+        get apm()                    { return apmMock; }
         async run(...args) {
             if (run) return await run(...args);
         }

package/test/jobQueue/helpers/queue.js

@@ -0,0 +1,26 @@
+/***************************************************************************************************
+* QUEUE FACTORY
+* bullmqMock/loggerMock are required lazily so the mock instances align with whatever the test
+* re-requires after jest.resetModules(). MockQueue injects the BullMQ, crypto, and logger seams.
+***************************************************************************************************/
+function buildQueue(queueName) {
+    const { Queue }           = require('../../../lib/jobQueue/queue');
+    const bullmqMock          = require('./bullmqMock');
+    const { buildLoggerMock } = require('./loggerMock');
+
+    const loggerMock  = buildLoggerMock();
+    const idGenerator = jest.fn();
+
+    class MockQueue extends Queue {
+        get queueClass()    { return bullmqMock.Queue; }
+        get idGenerator()   { return idGenerator; }
+        get loggerLibrary() { return loggerMock; }
+    }
+
+    return new MockQueue(queueName);
+}
+
+
+module.exports = {
+    buildQueue,
+}