@emartech/program-executor 3.11.1 → 3.12.1

package/src/queue-manager/{index.spec.js → index.test.js}

@@ -1,27 +1,26 @@
 'use strict';
 
-const QueueManager = require('./');
+const QueueManager = require('.');
 const RabbitMq = require('@emartech/rabbitmq-client').RabbitMq;
-
+const Logger = require('@emartech/json-logger').Logger;
 const testAmqpUrl = 'amqp://guest:guest@localhost:5672';
 const testChannelName = 'program-executor';
 
 describe('Queue-Manager', function () {
   describe('queueProgram', function () {
     it('should add proper queue item to the given channel', async function () {
-      const rabbitMock = {
-        insert: this.sandbox.stub().resolves(true),
-        waitForConfirms: this.sandbox.stub().resolves(true)
-      };
-
-      this.sandbox.stub(RabbitMq, 'create').resolves(rabbitMock);
+      const insertMock = jest.fn();
+      RabbitMq.create = jest.fn().mockResolvedValue({
+        insert: insertMock,
+        waitForConfirms: jest.fn().mockResolvedValue(true)
+      });
 
       const queueManager = new QueueManager(testAmqpUrl, testChannelName);
       const queueData = { test_data: 123 };
 
       await queueManager.queueProgram(queueData);
 
-      expect(RabbitMq.create).to.have.been.calledWith(
+      expect(RabbitMq.create).toHaveBeenCalledWith(
         { programExecutor: { url: testAmqpUrl, useConfirmChannel: true } },
         testChannelName,
         'programExecutor',
@@ -30,24 +29,22 @@ describe('Queue-Manager', function () {
           deadLetterRoutingKey: `${testChannelName}-retry-1000`
         }
       );
-      expect(rabbitMock.insert).to.have.been.calledWith(queueData);
+      expect(insertMock).toHaveBeenCalledWith(queueData, expect.anything());
     });
 
     it('should log if confirmation fails instead of throwing', async function () {
       const errorToThrow = new Error('Boom!');
-      const rabbitMock = {
-        insert: this.sandbox.stub().resolves(true),
-        waitForConfirms: this.sandbox.stub().rejects(errorToThrow)
-      };
-
-      this.sandbox.stub(RabbitMq, 'create').resolves(rabbitMock);
+      Logger.prototype.fromError = jest.fn();
+      const insertMock = jest.fn();
+      RabbitMq.create = jest.fn().mockResolvedValue({
+        insert: insertMock,
+        waitForConfirms: jest.fn(() => { throw errorToThrow; })
+      });
 
       const queueManager = new QueueManager(testAmqpUrl, testChannelName);
       const queueData = { test_data: 123 };
-
       await queueManager.queueProgram(queueData);
-
-      expect(this.formErrorStub).to.have.been.calledWith('confirm-error', errorToThrow);
+      expect(Logger.prototype.fromError ).toHaveBeenCalledWith('confirm-error', errorToThrow, {queue_data: JSON.stringify(queueData)});
     });
   });
 });

package/src/queue-manager-pubsub/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const PubSubClient = require('@emartech/pubsub-client-js').PubSubClient;
+const logger = require('@emartech/json-logger')('program-executor-queue-manager-pubsub');
+
+class QueueManager {
+  constructor(topicName, projectId, gcpKeyFileName) {
+    this._gcpKeyFileName = gcpKeyFileName;
+    this._projectId = projectId;
+    this._topicName = topicName;
+  }
+
+  async queueProgram(queueData) {
+    try {
+      const pubsub = await PubSubClient.create(
+        this._topicName, this._projectId, this._gcpKeyFileName
+      );
+
+      await pubsub.insert(queueData);
+
+    } catch (error) {
+      logger.fromError('queue-error', error, { queue_data: JSON.stringify(queueData) });
+      PubSubClient.clearPublisherCache();
+      throw error;
+    }
+  }
+
+  static create(topicName, projectId, gcpKeyFileName) {
+    return new QueueManager(topicName, projectId, gcpKeyFileName);
+  }
+}
+
+module.exports = QueueManager;

package/src/queue-manager-pubsub/index.test.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const QueueManager = require('.');
+const PubSubClient = require('@emartech/pubsub-client-js').PubSubClient;
+const Logger = require('@emartech/json-logger').Logger;
+const testProjectId = 'test-project';
+const testGcpKeyFileName = { key: 'test-key-file.json' };
+const testTopicName = 'program-executor';
+
+describe('Queue-Manager', function () {
+  describe('queueProgram', function () {
+    it('should add proper queue item to the given topic', async function () {
+      const insertMock = jest.fn();
+      PubSubClient.create = jest.fn().mockResolvedValue({
+        insert: insertMock
+      });
+
+      const queueManager = new QueueManager(testTopicName, testProjectId, testGcpKeyFileName);
+      const queueData = { test_data: 123 };
+
+      await queueManager.queueProgram(queueData);
+
+      expect(PubSubClient.create).toHaveBeenCalledWith(
+        testTopicName, testProjectId, testGcpKeyFileName
+      );
+      expect(insertMock).toHaveBeenCalledWith(queueData);
+    });
+
+    it('should log if confirmation fails instead of throwing', async function () {
+      const errorToThrow = new Error('Boom!');
+      Logger.prototype.fromError = jest.fn();
+      const insertMock = jest.fn().mockRejectedValue(errorToThrow);
+      PubSubClient.create = jest.fn().mockResolvedValue({
+        insert: insertMock
+      });
+
+      const queueManager = new QueueManager(testTopicName, testProjectId, testGcpKeyFileName);
+      const queueData = { test_data: 123 };
+      await expect(queueManager.queueProgram(queueData)).rejects.toThrow(errorToThrow);
+      expect(Logger.prototype.fromError)
+        .toHaveBeenCalledWith('queue-error', errorToThrow, { queue_data: JSON.stringify(queueData) });
+    });
+  });
+});

package/src/repositories/{programs.spec.js → programs.test.js}

@@ -1,6 +1,9 @@
 'use strict';
 
 const ProgramsRepository = require('./programs');
+const knex = require('knex');
+const DbCleaner = require('../test-helper/db-cleaner');
+const { db } = require('../test-helper/get-test-db-config');
 
 const programData = {
   customerId: 1,
@@ -12,18 +15,31 @@ const runId = '9123434';
 describe('ProgramsRepository', () => {
   let programsRepository;
   let resetUpdatedAt;
+  let dbConnection;
+
+  beforeAll(function () {
+
+    dbConnection = knex({
+      client: 'pg',
+      connection: db.connection.connString
+    });
 
-  before(function () {
     resetUpdatedAt = async (runId) => {
       const oldDate = new Date(0);
-      await this.db('programs').where({ run_id: runId }).update({ updated_at: oldDate });
+      await dbConnection('programs').where({ run_id: runId }).update({ updated_at: oldDate });
 
       return oldDate;
     };
   });
 
-  beforeEach(function () {
-    programsRepository = ProgramsRepository.create(this.db, 'programs');
+  afterAll(async function () {
+    await DbCleaner.create(dbConnection).tearDown();
+    dbConnection.destroy();
+  });
+
+  beforeEach(async function () {
+    await DbCleaner.create(dbConnection).tearDown();
+    programsRepository = ProgramsRepository.create(dbConnection, 'programs');
   });
 
   describe('#save', () => {
@@ -48,7 +64,7 @@ describe('ProgramsRepository', () => {
 
       const result = await programsRepository.getProgramByRunId(runId);
 
-      expect(result).to.containSubset({
+      expect(result).toEqual(expect.objectContaining({
         runId,
         programData,
         jobs,
@@ -58,12 +74,12 @@ describe('ProgramsRepository', () => {
         erroredAt,
         errorMessage,
         stepRetryCount
-      });
+      }));
     });
 
     it('creates table if not exists and saves program', async function () {
       await programsRepository.save({ runId, programData, jobs: ['a'] });
-      await this.db.schema.dropTable('programs');
+      await dbConnection.schema.dropTable('programs');
 
       const jobs = ['a', 'b'];
       const jobData = { product_sync: { page: 40 } };
@@ -71,13 +87,13 @@ describe('ProgramsRepository', () => {
 
       const result = await programsRepository.getProgramByRunId(runId);
 
-      expect(result).to.containSubset({
+      expect(result).toEqual(expect.objectContaining({
         runId,
         jobs,
         jobData,
         programData,
         step: 0
-      });
+      }));
     });
   });
 
@@ -91,9 +107,9 @@ describe('ProgramsRepository', () => {
       await programsRepository.finishProgram(runId);
 
       const result = await programsRepository.getProgramByRunId(runId);
-      expect(result.finishedAt).not.to.eql(null);
-      expect(result.stepRetryCount).to.equal(0);
-      expect(result.updatedAt.toString()).not.to.equal(oldDate.toString());
+      expect(result.finishedAt).not.toEqual(null);
+      expect(result.stepRetryCount).toEqual(0);
+      expect(result.updatedAt.toString()).not.toEqual(oldDate.toString());
     });
   });
 
@@ -106,10 +122,10 @@ describe('ProgramsRepository', () => {
       await programsRepository.setProgramToError(runId, 'Something wrong happened!');
 
       const result = await programsRepository.getProgramByRunId(runId);
-      expect(result.finishedAt).to.eql(null);
-      expect(result.erroredAt).not.to.eql(null);
-      expect(result.errorMessage).to.eql('Something wrong happened!');
-      expect(result.updatedAt.toString()).not.to.equal(oldDate.toString());
+      expect(result.finishedAt).toEqual(null);
+      expect(result.erroredAt).not.toEqual(null);
+      expect(result.errorMessage).toEqual('Something wrong happened!');
+      expect(result.updatedAt.toString()).not.toEqual(oldDate.toString());
     });
 
     it('should set and error_message and updated_at without setting finished_at or errored_at', async function () {
@@ -120,10 +136,10 @@ describe('ProgramsRepository', () => {
       await programsRepository.setProgramToError(runId, 'Something wrong happened!', false);
 
       const result = await programsRepository.getProgramByRunId(runId);
-      expect(result.finishedAt).to.eql(null);
-      expect(result.erroredAt).to.eql(null);
-      expect(result.errorMessage).to.eql('Something wrong happened!');
-      expect(result.updatedAt.toString()).not.to.equal(oldDate.toString());
+      expect(result.finishedAt).toEqual(null);
+      expect(result.erroredAt).toEqual(null);
+      expect(result.errorMessage).toEqual('Something wrong happened!');
+      expect(result.updatedAt.toString()).not.toEqual(oldDate.toString());
     });
 
     it('should trim error message', async function () {
@@ -138,7 +154,7 @@ describe('ProgramsRepository', () => {
         errorThrown = error;
       }
 
-      expect(errorThrown).to.be.undefined;
+      expect(errorThrown).toBe(undefined);
     });
   });
 
@@ -148,14 +164,14 @@ describe('ProgramsRepository', () => {
       await programsRepository.incrementStepRetryCount(runId);
 
       const result = await programsRepository.getProgramByRunId(runId);
-      expect(result.step).to.eql(0);
+      expect(result.step).toEqual(0);
 
       const oldDate = await resetUpdatedAt(runId);
       await programsRepository.incrementStep(runId);
       const incrementedResult = await programsRepository.getProgramByRunId(runId);
-      expect(incrementedResult.step).to.equal(1);
-      expect(incrementedResult.stepRetryCount).to.equal(0);
-      expect(incrementedResult.updatedAt.toString()).not.to.equal(oldDate.toString());
+      expect(incrementedResult.step).toEqual(1);
+      expect(incrementedResult.stepRetryCount).toEqual(0);
+      expect(incrementedResult.updatedAt.toString()).not.toEqual(oldDate.toString());
     });
   });
 
@@ -163,13 +179,13 @@ describe('ProgramsRepository', () => {
     it('should increment step retry counter', async function () {
       await programsRepository.save({ runId, programData, jobs: ['a'] });
       const result = await programsRepository.getProgramByRunId(runId);
-      expect(result.stepRetryCount).to.eql(0);
+      expect(result.stepRetryCount).toBe(0);
 
       const oldDate = await resetUpdatedAt(runId);
       await programsRepository.incrementStepRetryCount(runId);
       const incrementedResult = await programsRepository.getProgramByRunId(runId);
-      expect(incrementedResult.stepRetryCount).to.equal(1);
-      expect(incrementedResult.updatedAt.toString()).not.to.equal(oldDate.toString());
+      expect(incrementedResult.stepRetryCount).toBe(1);
+      expect(incrementedResult.updatedAt.toString()).not.toEqual(oldDate.toString());
     });
   });
 
@@ -180,17 +196,18 @@ describe('ProgramsRepository', () => {
 
       const result = await programsRepository.getProgramByRunId(runId);
 
-      expect(result).to.containSubset({
+      expect(result).toEqual(expect.objectContaining({
         runId,
         jobs,
         step: 0
-      });
+      }));
     });
 
     it('throws an error if program not found', async function () {
       await programsRepository.save({ runId, programData, jobs: [] });
 
-      await expect(programsRepository.getProgramByRunId('NON_EXISTING_RUN_ID')).to.be.rejected;
+      await expect(programsRepository.getProgramByRunId('NON_EXISTING_RUN_ID')).rejects
+        .toThrow('Program not found for NON_EXISTING_RUN_ID.');
     });
   });
 
@@ -203,11 +220,11 @@ describe('ProgramsRepository', () => {
       await programsRepository.setJobDataByRunId(runId, { product_sync: { page: 1 } });
       const result = await programsRepository.getProgramByRunId(runId);
 
-      expect(result).to.containSubset({
+      expect(result).toEqual(expect.objectContaining({
         runId: runId,
         jobData: { product_sync: { page: 1 } }
-      });
-      expect(result.updatedAt.toString()).not.to.equal(oldDate.toString());
+      }));
+      expect(result.updatedAt.toString()).not.toEqual(oldDate.toString());
     });
   });
 
@@ -221,10 +238,10 @@ describe('ProgramsRepository', () => {
 
       const result = await programsRepository.getUnfinishedPrograms();
 
-      expect(result.length).to.equal(1);
-      expect(result[0]).to.containSubset({
+      expect(result.length).toEqual(1);
+      expect(result[0]).toEqual(expect.objectContaining(({
         runId: '2'
-      });
+      })));
     });
   });
 });

package/src/retryable-error/{index.spec.js → index.test.js}

@@ -1,13 +1,13 @@
 'use strict';
 
-const RetryableError = require('./');
+const RetryableError = require('.');
 
 describe('RetryableError', () => {
   it('should have a retryable property set to true', () => {
     try {
       throw new RetryableError();
     } catch (error) {
-      expect(error.retryable).to.be.true;
+      expect(error.retryable).toBe(true);
     }
   });
 
@@ -15,8 +15,8 @@ describe('RetryableError', () => {
     try {
       throw new RetryableError('Something bad happened!', 200);
     } catch (error) {
-      expect(error.message).to.eql('Something bad happened!');
-      expect(error.code).to.eql(200);
+      expect(error.message).toEqual('Something bad happened!');
+      expect(error.code).toEqual(200);
     }
   });
 
@@ -24,7 +24,7 @@ describe('RetryableError', () => {
     try {
       throw new RetryableError('Something bad happened!');
     } catch (error) {
-      expect(RetryableError.isRetryable(error)).to.eql(true);
+      expect(RetryableError.isRetryable(error)).toEqual(true);
     }
   });
 });

package/src/runid-generator/{index.spec.js → index.test.js}

@@ -1,12 +1,12 @@
 'use strict';
 
-const RunIdGenerator = require('./');
+const RunIdGenerator = require('.');
 
 describe('RunId Generator', () => {
   describe('generate', () => {
     it('should return a string', () => {
       const result = RunIdGenerator.generate();
-      expect(result).to.be.a('string');
+      expect(typeof result).toBe('string');
     });
   });
 });

package/src/test-helper/get-test-db-config.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const getDbConfig = function () {
+  let database = process.env.POSTGRES_DATABASE;
+
+  if (process.env.JEST_WORKER_ID) {
+    database = `${database}_${process.env.JEST_WORKER_ID}`;
+  }
+
+  const port = process.env.POSTGRES_PORT;
+
+  return {
+    user: process.env.POSTGRES_USER,
+    host: process.env.POSTGRES_HOST,
+    database,
+    password: process.env.POSTGRES_PASSWORD,
+    port,
+    connString: `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}` +
+    `@${process.env.POSTGRES_HOST}:${port}/${database}`
+  };
+};
+
+module.exports = {
+  db: {
+    connection: {
+      ...getDbConfig(process.env.NODE_ENV)
+    }
+  }
+};

package/src/testSetup.js

@@ -0,0 +1,23 @@
+'use strict';
+
+require('dotenv').config({ silent: true });
+
+const { PubSub } = require('@google-cloud/pubsub');
+const { db } = require('./test-helper/get-test-db-config');
+const knex = require('knex');
+const DbCleaner = require('./test-helper/db-cleaner');
+
+module.exports = async () => {
+  const dbConnection = knex({
+    client: 'pg',
+    connection: db.connection.connString
+  });
+
+  await DbCleaner.create(dbConnection).tearDown();
+
+  dbConnection.destroy();
+
+  const _pubsub = new PubSub();
+  await _pubsub.createTopic('program-executor');
+  await _pubsub.topic('program-executor').createSubscription('program-executor');
+};

package/src/testTeardown.js

@@ -0,0 +1,13 @@
+'use strict';
+
+require('dotenv').config({ silent: true });
+const { PubSub } = require('@google-cloud/pubsub');
+
+
+module.exports = async () => {
+  console.log('global teardown');
+
+  const _pubsub = new PubSub();
+  await _pubsub.topic('program-executor').delete();
+  await _pubsub.subscription('program-executor').delete();
+};

package/src/setup.spec.js

@@ -1,50 +0,0 @@
-'use strict';
-
-require('dotenv').config({ silent: true });
-
-const knex = require('knex');
-const sinon = require('sinon');
-const chai = require('chai');
-const sinonChai = require('sinon-chai');
-const chaiSubset = require('chai-subset');
-const chaiString = require('chai-string');
-const chaiAsPromised = require('chai-as-promised');
-const Logger = require('@emartech/json-logger').Logger;
-
-const DbCleaner = require('./test-helper/db-cleaner');
-
-chai.use(chaiSubset);
-chai.use(sinonChai);
-chai.use(chaiString);
-chai.use(chaiAsPromised);
-
-global.expect = chai.expect;
-
-before(function () {
-  this.db = knex({
-    client: 'pg',
-    connection: process.env.DATABASE_URL || process.env.DATABASE_TEST_URL
-  });
-});
-
-beforeEach(async function () {
-  this.sinon = sinon;
-  this.sandbox = sinon.createSandbox();
-
-  this.loggerLog = this.sandbox.stub(Logger.prototype, 'error');
-
-  this.sandbox.stub(Logger.prototype, 'trace');
-  this.sandbox.stub(Logger.prototype, 'debug');
-  this.infoStub = this.sandbox.stub(Logger.prototype, 'info');
-  this.warnStub = this.sandbox.stub(Logger.prototype, 'warn');
-  this.formErrorStub = this.sandbox.stub(Logger.prototype, 'fromError');
-  this.sandbox.stub(Logger.prototype, 'warnFromError');
-  this.sandbox.stub(Logger.prototype, 'fatal');
-
-  await DbCleaner.create(this.db).tearDown();
-});
-
-afterEach(async function () {
-  this.sandbox.restore();
-  await DbCleaner.create(this.db).tearDown();
-});