@vida-global/core 1.4.6 → 2.0.1

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

@@ -1,12 +1,18 @@
 const { ConnectionConfiguration } = require('../../../lib/activeRecord/db/connectionConfiguration');
 const   Helpers                   = require('../helpers/connectionConfiguration');
+const { snapshotEnv }             = require('../../helpers/env');
+
+
+let restoreEnv;
+
+beforeEach(() => {
+    restoreEnv = snapshotEnv(['DB_POOL_MIN', 'DB_POOL_MAX', 'NODE_ENV']);
+});
 
 
 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;
+    restoreEnv();
 });
 
 

package/test/activeRecord/helpers/baseRecordMocks.js

@@ -35,15 +35,17 @@ class MockSequelize {
     static DataTypes = {
         [dataTypeKey1]: {types: {postgres: [dataTypeValue1]}, key: dataTypeKey1},
         [dataTypeKey2]: {types: {postgres: [dataTypeValue2]}, key: dataTypeKey2},
-        postgres:       {}
+        postgres:       {},
+        VIRTUAL:        {key: 'VIRTUAL'},
     }
 }
 
 
 const redisClient = {
-    del:  jest.fn(),
-    mGet: jest.fn(),
-    mSet: jest.fn(),
+    del:     jest.fn(),
+    mGet:    jest.fn(),
+    mSet:    jest.fn(),
+    connect: jest.fn(),
 }
 const mockRedisClientFactory = () => redisClient;
 

package/test/activeRecord/helpers/connection.js

@@ -6,8 +6,6 @@ const secondaryConfig = Fixtures.buildPostgresConfig();
 const sslConfig       = Fixtures.buildPostgresConfig({ ssl: true });
 const sqliteConfig    = { dialect: 'sqlite' };
 
-const originalNodeEnv = process.env.NODE_ENV;
-
 
 function buildConfigs() {
     return {
@@ -23,6 +21,5 @@ module.exports = {
     ...Fixtures,
     buildConfigs,
     defaultConfig,
-    originalNodeEnv,
     secondaryConfig,
 };

package/test/activeRecord/helpers/connectionConfiguration.js

@@ -7,13 +7,6 @@ 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);
@@ -24,7 +17,6 @@ module.exports = {
     fetchConfigsSpy,
     ...Fixtures,
     mockConfigs,
-    originalEnv,
     productionConfig,
     sqliteConfig,
     testConfig,

package/test/apm/agent.test.js

@@ -0,0 +1,56 @@
+const ORIGINAL_ENV = process.env;
+
+
+beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...ORIGINAL_ENV, NODE_ENV: 'test' };
+    delete process.env.NEW_RELIC_LICENSE_KEY;
+});
+
+
+afterEach(() => {
+    process.env = ORIGINAL_ENV;
+});
+
+
+describe('apm/agent', () => {
+    describe('stub client (NEW_RELIC_LICENSE_KEY unset)', () => {
+        it ('reports enabled=false', () => {
+            const { enabled } = require('../../lib/apm/agent');
+
+            expect(enabled).toEqual(false);
+        });
+
+        it ('exposes no-op stubs that accept any arguments', () => {
+            const { client } = require('../../lib/apm/agent');
+
+            expect(() => client.addCustomAttribute('k', 'v')).not.toThrow();
+            expect(() => client.noticeError(new Error('x'), {})).not.toThrow();
+            expect(() => client.recordCustomEvent('Type', { a: 1 })).not.toThrow();
+            expect(() => client.recordMetric('name', 1)).not.toThrow();
+            expect(() => client.setControllerName('C', 'a')).not.toThrow();
+            expect(() => client.setUserID(1)).not.toThrow();
+            expect(() => client.instrumentLoadedModule('pkg', {})).not.toThrow();
+        });
+
+        it ('startBackgroundTransaction invokes the handler and returns its result', () => {
+            const { client } = require('../../lib/apm/agent');
+            const handler    = jest.fn(() => 'bg-result');
+
+            const result = client.startBackgroundTransaction('Job', 'queue', handler);
+
+            expect(handler).toHaveBeenCalledTimes(1);
+            expect(result).toEqual('bg-result');
+        });
+
+        it ('startSegment invokes the handler and returns its result', () => {
+            const { client } = require('../../lib/apm/agent');
+            const handler    = jest.fn(() => 'seg-result');
+
+            const result = client.startSegment('seg', true, handler);
+
+            expect(handler).toHaveBeenCalledTimes(1);
+            expect(result).toEqual('seg-result');
+        });
+    });
+});

package/test/apm/utils.test.js

@@ -0,0 +1,121 @@
+jest.mock('../../lib/apm/agent', () => ({
+    enabled: false,
+    client:  {
+        addCustomAttribute:         jest.fn(),
+        noticeError:                jest.fn(),
+        recordCustomEvent:          jest.fn(),
+        recordMetric:               jest.fn(),
+        setControllerName:          jest.fn(),
+        setUserID:                  jest.fn(),
+        startBackgroundTransaction: jest.fn((name, group, handler) => handler()),
+        startSegment:               jest.fn((name, record, handler) => handler()),
+    },
+}));
+
+
+let utils;
+let agent;
+
+beforeEach(() => {
+    jest.resetModules();
+    utils = require('../../lib/apm/utils');
+    agent = require('../../lib/apm/agent');
+});
+
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('apm/utils', () => {
+    describe('addCustomAttribute', () => {
+        it ('forwards key and value to the client', () => {
+            utils.addCustomAttribute('foo', 'bar');
+
+            expect(agent.client.addCustomAttribute).toHaveBeenCalledWith('foo', 'bar');
+        });
+    });
+
+
+    describe('reportError', () => {
+        it ('forwards the error and details to noticeError', () => {
+            const err     = new Error('boom');
+            const details = { a: 1 };
+
+            utils.reportError(err, details);
+
+            expect(agent.client.noticeError).toHaveBeenCalledWith(err, details);
+        });
+
+        it ('defaults details to an empty object', () => {
+            const err = new Error('boom');
+
+            utils.reportError(err);
+
+            expect(agent.client.noticeError).toHaveBeenCalledWith(err, {});
+        });
+    });
+
+
+    describe('recordCustomEvent', () => {
+        it ('forwards eventType and attributes to the client', () => {
+            const attrs = { jobName: 'X' };
+
+            utils.recordCustomEvent('JobCompleted', attrs);
+
+            expect(agent.client.recordCustomEvent).toHaveBeenCalledWith('JobCompleted', attrs);
+        });
+    });
+
+
+    describe('recordMetric', () => {
+        it ('forwards name and value to the client', () => {
+            utils.recordMetric('Custom/Worker/foo', 42);
+
+            expect(agent.client.recordMetric).toHaveBeenCalledWith('Custom/Worker/foo', 42);
+        });
+    });
+
+
+    describe('setControllerName', () => {
+        it ('forwards controller and action to the client', () => {
+            utils.setControllerName('Users', 'getIndex');
+
+            expect(agent.client.setControllerName).toHaveBeenCalledWith('Users', 'getIndex');
+        });
+    });
+
+
+    describe('setUserId', () => {
+        it ('forwards id to the client (note the casing difference)', () => {
+            utils.setUserId(123);
+
+            expect(agent.client.setUserID).toHaveBeenCalledWith(123);
+        });
+    });
+
+
+    describe('startBackgroundTransaction', () => {
+        it ('forwards name, group, and handler to the client and returns its result', () => {
+            const handler = jest.fn(() => 'result');
+
+            const result = utils.startBackgroundTransaction('Job', 'queue', handler);
+
+            expect(agent.client.startBackgroundTransaction).toHaveBeenCalledWith('Job', 'queue', handler);
+            expect(result).toEqual('result');
+        });
+    });
+
+
+    describe('startSegment', () => {
+        it ('forwards name, record flag, and handler to the client and returns its result', () => {
+            const handler = jest.fn(() => 'segment-result');
+
+            const result = utils.startSegment('seg', true, handler);
+
+            expect(agent.client.startSegment).toHaveBeenCalledWith('seg', true, handler);
+            expect(result).toEqual('segment-result');
+        });
+    });
+});

package/test/helpers/env.js

@@ -0,0 +1,33 @@
+/***************************************************************************************************
+* ENV SNAPSHOT
+*
+* Captures the current value of the given process.env keys and returns a restore() function that
+* puts them back to their original state. Use in beforeEach/afterEach pairs whenever a test needs
+* to mutate environment variables without leaking changes to other tests.
+*
+*   const restoreEnv = snapshotEnv(['NODE_ENV', 'REDIS_BULL_HOST']);
+*   process.env.NODE_ENV = 'production';
+*   // ...test body...
+*   restoreEnv();
+***************************************************************************************************/
+function snapshotEnv(keys) {
+    const original = {};
+    for (const key of keys) {
+        original[key] = process.env[key];
+    }
+
+    return function restore() {
+        for (const key of keys) {
+            if (original[key] === undefined) {
+                delete process.env[key];
+            } else {
+                process.env[key] = original[key];
+            }
+        }
+    }
+}
+
+
+module.exports = {
+    snapshotEnv,
+}

package/test/http/client.test.js

@@ -10,7 +10,7 @@ afterEach(() => {
 
 beforeEach(() => {
     Helpers.mockFetchSuccess();
-    logger.info = jest.fn();
+    logger.http.debug = jest.fn();
 });
 
 
@@ -60,8 +60,8 @@ describe('HttpClient', () => {
         it ('logs API requests', async () => {
             await client[methodName](Helpers.apiUrl);
 
-            expect(logger.info).toHaveBeenCalledTimes(1);
-            expect(logger.info).toHaveBeenCalledWith(`API CALL: ${httpMethod} ${Helpers.apiUrl}`);
+            expect(logger.http.debug).toHaveBeenCalledTimes(1);
+            expect(logger.http.debug).toHaveBeenCalledWith(`API CALL: ${httpMethod} ${Helpers.apiUrl}`);
         });
 
         if (behavior.supportsBody) {

package/test/jobQueue/abstractJob.test.js

@@ -0,0 +1,307 @@
+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');
+});
+
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('AbstractJob', () => {
+    describe('constructor', () => {
+        it ('throws when AbstractJob is instantiated directly', () => {
+            expect(() => new AbstractJob()).toThrow('Cannot create an instance of AbstractJob');
+        });
+
+        it ('throws when the subclass does not define a queueName', () => {
+            class NoQueueJob extends AbstractJob {
+                async run() {}
+            }
+
+            expect(() => new NoQueueJob()).toThrow('No queue defined');
+        });
+
+        it ('throws when the subclass does not define a run method', () => {
+            class NoRunJob extends AbstractJob {
+                static queueName() { return 'q'; }
+            }
+
+            expect(() => new NoRunJob()).toThrow('No run method defined');
+        });
+
+        it ('succeeds when the subclass defines both queueName and run', () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+
+            expect(() => new Subclass()).not.toThrow();
+        });
+    });
+
+
+    describe('.queue', () => {
+        it ('returns the queue from getQueue invoked with the resolved queue name', () => {
+            const name        = TestHelpers.Faker.Text.randomString();
+            const Subclass    = defineJobSubclass(AbstractJob, { queueName: name });
+            const stubQueue   = { queueJob: jest.fn() };
+            getQueue.mockReturnValue(stubQueue);
+
+            const result = Subclass.queue('arg1', 'arg2');
+
+            expect(getQueue).toHaveBeenCalledTimes(1);
+            expect(getQueue).toHaveBeenCalledWith(name);
+            expect(result).toBe(stubQueue);
+        });
+
+        it ('passes job args through to a dynamic queueName method', () => {
+            const arg1          = TestHelpers.Faker.Text.randomString();
+            const arg2          = TestHelpers.Faker.Math.randomNumber();
+            const queueNameSpy  = jest.fn(() => 'dynamic-queue');
+            const Subclass      = defineJobSubclass(AbstractJob, { queueNameFn: queueNameSpy });
+            getQueue.mockReturnValue({ queueJob: jest.fn() });
+
+            Subclass.queue(arg1, arg2);
+
+            expect(queueNameSpy).toHaveBeenCalledWith(arg1, arg2);
+            expect(getQueue).toHaveBeenCalledWith('dynamic-queue');
+        });
+    });
+
+
+    describe('.queueJob', () => {
+        it ('enqueues the job on the resolved queue with the args and settings', async () => {
+            const name      = TestHelpers.Faker.Text.randomString();
+            const Subclass  = defineJobSubclass(AbstractJob, { queueName: name });
+            const stubQueue = { queueJob: jest.fn().mockResolvedValue(undefined) };
+            getQueue.mockReturnValue(stubQueue);
+            const arg1 = TestHelpers.Faker.Text.randomString();
+            const arg2 = TestHelpers.Faker.Math.randomNumber();
+
+            await Subclass.queueJob(arg1, arg2);
+
+            expect(stubQueue.queueJob).toHaveBeenCalledTimes(1);
+            expect(stubQueue.queueJob).toHaveBeenCalledWith(
+                Subclass,
+                [arg1, arg2],
+                Subclass.queueSettings(arg1, arg2),
+            );
+        });
+
+        it ('awaits the underlying queueJob call', async () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+            let resolveQueueJob;
+            const queueJobPromise = new Promise((resolve) => { resolveQueueJob = resolve; });
+            getQueue.mockReturnValue({ queueJob: jest.fn().mockReturnValue(queueJobPromise) });
+
+            const callPromise = Subclass.queueJob();
+            let resolved      = false;
+            callPromise.then(() => { resolved = true; });
+            await Promise.resolve();
+            expect(resolved).toBe(false);
+
+            resolveQueueJob();
+            await callPromise;
+            expect(resolved).toBe(true);
+        });
+    });
+
+
+    describe('.queueSettings', () => {
+        it ('returns default retry settings', () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+
+            expect(Subclass.queueSettings()).toEqual({
+                attempts: 3,
+                backoff:  { type: 'exponential', delay: 2000 },
+            });
+        });
+
+        it ('reflects subclass overrides for retry settings', () => {
+            const numRetries        = TestHelpers.Faker.Math.randomNumber(20);
+            const retryBackoffType  = TestHelpers.Faker.Text.randomString();
+            const retryBackoffDelay = TestHelpers.Faker.Math.randomNumber(10000);
+            const Subclass          = defineJobSubclass(AbstractJob, {
+                numRetries,
+                retryBackoffType,
+                retryBackoffDelay,
+            });
+
+            expect(Subclass.queueSettings()).toEqual({
+                attempts: numRetries,
+                backoff:  { type: retryBackoffType, delay: retryBackoffDelay },
+            });
+        });
+    });
+
+
+    describe('default static getters', () => {
+        it ('.numRetries defaults to 3',                       () => expect(AbstractJob.numRetries).toEqual(3));
+        it ('.retryBackoffType defaults to "exponential"',     () => expect(AbstractJob.retryBackoffType).toEqual('exponential'));
+        it ('.retryBackoffDelay defaults to 2000',             () => expect(AbstractJob.retryBackoffDelay).toEqual(2000));
+    });
+
+
+    describe('#_run', () => {
+        it ('stores the id and exposes it via #id', async () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+            const job      = new Subclass();
+            const id       = TestHelpers.Faker.Text.randomString();
+
+            await job._run(id, [], jest.fn());
+
+            expect(job.id).toEqual(id);
+        });
+
+        it ('calls run with the spread args', async () => {
+            const runSpy   = jest.fn().mockResolvedValue(undefined);
+            const Subclass = defineJobSubclass(AbstractJob, { run: runSpy });
+            const job      = new Subclass();
+            const args     = [TestHelpers.Faker.Text.randomString(), TestHelpers.Faker.Math.randomNumber()];
+
+            await job._run('id', args, jest.fn());
+
+            expect(runSpy).toHaveBeenCalledTimes(1);
+            expect(runSpy).toHaveBeenCalledWith(...args);
+        });
+
+        it ('propagates rejections from run', async () => {
+            const error    = new Error(TestHelpers.Faker.Text.randomString());
+            const Subclass = defineJobSubclass(AbstractJob, { run: jest.fn().mockRejectedValue(error) });
+            const job      = new Subclass();
+
+            await expect(job._run('id', [], jest.fn())).rejects.toBe(error);
+        });
+
+        it ('stores the updateProgress callback for later use', async () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+            const job      = new Subclass();
+            const callback = jest.fn().mockResolvedValue(undefined);
+
+            await job._run('id', [], callback);
+            const payload = TestHelpers.Faker.Text.randomString();
+            await job.updateProgress(payload);
+
+            expect(callback).toHaveBeenCalledTimes(1);
+            expect(callback).toHaveBeenCalledWith(payload);
+        });
+    });
+
+
+    describe('#id', () => {
+        it ('returns undefined before _run has been invoked', () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+            const job      = new Subclass();
+
+            expect(job.id).toBeUndefined();
+        });
+    });
+
+
+    describe('#updateProgress', () => {
+        it ('forwards all arguments to the stored callback', async () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+            const job      = new Subclass();
+            const callback = jest.fn().mockResolvedValue(undefined);
+            await job._run('id', [], callback);
+
+            const arg1 = TestHelpers.Faker.Math.randomNumber();
+            const arg2 = TestHelpers.Faker.Text.randomString();
+            await job.updateProgress(arg1, arg2);
+
+            expect(callback).toHaveBeenCalledWith(arg1, arg2);
+        });
+
+        it ('awaits the callback', async () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+            const job      = new Subclass();
+            let resolveCallback;
+            const callback = jest.fn(() => new Promise((res) => { resolveCallback = res; }));
+            await job._run('id', [], callback);
+
+            const callPromise = job.updateProgress();
+            let resolved      = false;
+            callPromise.then(() => { resolved = true; });
+            await Promise.resolve();
+            expect(resolved).toBe(false);
+
+            resolveCallback();
+            await callPromise;
+            expect(resolved).toBe(true);
+        });
+    });
+
+
+    describe('#addApmAttribute', () => {
+        it ('delegates to APM.addCustomAttribute', () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+            const job      = new Subclass();
+            const key      = TestHelpers.Faker.Text.randomString();
+            const value    = TestHelpers.Faker.Text.randomString();
+
+            job.addApmAttribute(key, value);
+
+            expect(APM.addCustomAttribute).toHaveBeenCalledTimes(1);
+            expect(APM.addCustomAttribute).toHaveBeenCalledWith(key, value);
+        });
+    });
+
+
+    describe('#startApmSegment', () => {
+        it ('delegates to APM.startSegment and returns its result', () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+            const job      = new Subclass();
+            const name     = TestHelpers.Faker.Text.randomString();
+            const sentinel = TestHelpers.Faker.Text.randomString();
+            const handler  = jest.fn(() => sentinel);
+
+            const result = job.startApmSegment(name, true, handler);
+
+            expect(APM.startSegment).toHaveBeenCalledTimes(1);
+            expect(APM.startSegment).toHaveBeenCalledWith(name, true, handler);
+            expect(result).toEqual(sentinel);
+        });
+    });
+
+
+    describe('#logger', () => {
+        it ('returns a child of the constructor-named scope keyed by job id', async () => {
+            const Subclass = defineJobSubclass(AbstractJob);
+            const job      = new Subclass();
+            const id       = TestHelpers.Faker.Text.randomString();
+            await job._run(id, [], jest.fn());
+
+            const scope = logger[Subclass.name];
+            const child = job.logger;
+
+            expect(scope.child).toHaveBeenCalledWith(id);
+            expect(child).toBe(scope.child.mock.results[0].value);
+        });
+    });
+});