@emartech/program-executor 3.11.1 → 3.12.0

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();
-});