test(core) unit tests for change-tracking service (EWC-383)

src/services/agent-service.js

@@ -131,7 +131,7 @@ const updateAgentConfig = async function (updateData, fog, transaction) {
 
 const getAgentConfigChanges = async function (fog, transaction) {
 
-  const changeTracking = await ChangeTrackingService.getByFogId(fog.uuid, transaction);
+  const changeTracking = await ChangeTrackingService.getByIoFogUuid(fog.uuid, transaction);
   if (!changeTracking) {
     throw new Errors.NotFoundError(ErrorMessages.INVALID_NODE_ID)
   }

src/services/change-tracking-service.js

@@ -71,26 +71,26 @@ const events = Object.freeze({
   }
 });
 
-async function update(fogId, data, transaction) {
-  await ChangeTrackingManager.update({iofogUuid: fogId}, data, transaction);
+async function create(ioFogUuid, transaction) {
+  await ChangeTrackingManager.create({iofogUuid: ioFogUuid}, transaction);
 }
 
-async function updateIfChanged(fogId, data, transaction) {
-  await ChangeTrackingManager.updateIfChanged({iofogUuid: fogId}, data, transaction);
+async function update(ioFogUuid, data, transaction) {
+  await ChangeTrackingManager.update({iofogUuid: ioFogUuid}, data, transaction);
 }
 
-async function create(fogId, transaction) {
-  await ChangeTrackingManager.create({iofogUuid: fogId}, transaction);
+async function updateIfChanged(ioFogUuid, data, transaction) {
+  await ChangeTrackingManager.updateIfChanged({iofogUuid: ioFogUuid}, data, transaction);
 }
 
-async function getByFogId(fogId, transaction) {
-  return await ChangeTrackingManager.findOne({iofogUuid: fogId}, transaction);
+async function getByIoFogUuid(ioFogUuid, transaction) {
+  return await ChangeTrackingManager.findOne({iofogUuid: ioFogUuid}, transaction);
 }
 
 module.exports = {
   events: events,
   create: create,
   update: update,
   updateIfChanged: updateIfChanged,
-  getByFogId: getByFogId
+  getByIoFogUuid: getByIoFogUuid
 };

src/services/user-service.js

@@ -27,9 +27,6 @@ const EmailActivationCodeService = require('./email-activation-code-service');
 
 const AccessTokenService = require('./access-token-service');
 
-const logger = require('../logger');
-const constants = require('../helpers/constants');
-
 const TransactionDecorator = require('../decorators/transaction-decorator');
 
 const Validator = require('../schemas');

test/src/services/agent-service.test.js

@@ -364,24 +364,24 @@ describe('Agent Service', () => {
     def('updateIfChangedResponse', () => Promise.resolve());
 
     beforeEach(() => {
-      $sandbox.stub(ChangeTrackingService, 'getByFogId').returns($getByFogIdResponse);
+      $sandbox.stub(ChangeTrackingService, 'getByIoFogUuid').returns($getByFogIdResponse);
       $sandbox.stub(ChangeTrackingService, 'updateIfChanged').returns($updateIfChangedResponse);
     });
 
-    it('calls ChangeTrackingService#getByFogId() with correct args', async () => {
+    it('calls ChangeTrackingService#getByIoFogUuid() with correct args', async () => {
       await $subject;
-      expect(ChangeTrackingService.getByFogId).to.have.been.calledWith($uuid, transaction);
+      expect(ChangeTrackingService.getByIoFogUuid).to.have.been.calledWith($uuid, transaction);
     });
 
-    context('when ChangeTrackingService#getByFogId() fails', () => {
+    context('when ChangeTrackingService#getByIoFogUuid() fails', () => {
       def('getByFogIdResponse', () => Promise.reject(error));
 
       it(`fails with ${error}`, () => {
         return expect($subject).to.be.rejectedWith(error);
       })
     });
 
-    context('when ChangeTrackingService#getByFogId() succeeds', () => {
+    context('when ChangeTrackingService#getByIoFogUuid() succeeds', () => {
       it('calls ChangeTrackingService.updateIfChanged with correct args', async () => {
         await $subject;
         expect(ChangeTrackingService.updateIfChanged).to.have.been.calledWith($uuid,

test/src/services/change-tracking-service.test.js

@@ -0,0 +1,159 @@
+const {expect} = require('chai');
+const sinon = require('sinon');
+
+const ChangeTrackingManager = require('../../../src/sequelize/managers/change-tracking-manager');
+const ChangeTrackingService = require('../../../src/services/change-tracking-service');
+
+describe('ChangeTracking Service', () => {
+  def('subject', () => ChangeTrackingService);
+  def('sandbox', () => sinon.createSandbox());
+
+  afterEach(() => $sandbox.restore());
+
+  describe('.create()', () => {
+    const transaction = {};
+    const error = 'Error!';
+
+    const ioFogUuid = 'testUuid';
+
+    def('subject', () => $subject.create(ioFogUuid, transaction));
+    def('createResponse', () => Promise.resolve());
+
+    beforeEach(() => {
+      $sandbox.stub(ChangeTrackingManager, 'create').returns($createResponse);
+    });
+
+    it('calls ChangeTrackingManager#create() with correct args', async () => {
+      await $subject;
+      expect(ChangeTrackingManager.create).to.have.been.calledWith({
+        iofogUuid: ioFogUuid
+      }, transaction);
+    });
+
+    context('when ChangeTrackingManager#create() fails', () => {
+      def('createResponse', () => Promise.reject(error));
+
+      it(`fails with ${error}`, () => {
+        return expect($subject).to.be.rejectedWith(error)
+      })
+    });
+
+    context('when ChangeTrackingManager#create() succeeds', () => {
+      it('fulfills the promise', () => {
+        return expect($subject).to.eventually.equal(undefined)
+      })
+    })
+  });
+
+  describe('.update()', () => {
+    const transaction = {};
+    const error = 'Error!';
+
+    const ioFogUuid = 'testUuid';
+
+    def('subject', () => $subject.update(ioFogUuid, data, transaction));
+    def('updateResponse', () => Promise.resolve());
+
+
+    const data = ChangeTrackingService.events.clean;
+
+    beforeEach(() => {
+      $sandbox.stub(ChangeTrackingManager, 'update').returns($updateResponse);
+    });
+
+    it('calls ChangeTrackingManager#update() with correct args', async () => {
+      await $subject;
+      expect(ChangeTrackingManager.update).to.have.been.calledWith({
+        iofogUuid: ioFogUuid
+      }, data, transaction);
+    });
+
+    context('when ChangeTrackingManager#update() fails', () => {
+      def('updateResponse', () => Promise.reject(error));
+
+      it(`fails with ${error}`, () => {
+        return expect($subject).to.be.rejectedWith(error)
+      })
+    });
+
+    context('when ChangeTrackingManager#update() succeeds', () => {
+      it('fulfills the promise', () => {
+        return expect($subject).to.eventually.equal(undefined)
+      })
+    })
+  });
+
+  describe('.updateIfChanged()', () => {
+    const transaction = {};
+    const error = 'Error!';
+
+    const ioFogUuid = 'testUuid';
+
+    const data = ChangeTrackingService.events.clean;
+
+    def('subject', () => $subject.updateIfChanged(ioFogUuid, data, transaction));
+    def('updateResponse', () => Promise.resolve());
+
+
+    beforeEach(() => {
+      $sandbox.stub(ChangeTrackingManager, 'updateIfChanged').returns($updateResponse);
+    });
+
+    it('calls ChangeTrackingManager#updateIfChanged() with correct args', async () => {
+      await $subject;
+      expect(ChangeTrackingManager.updateIfChanged).to.have.been.calledWith({
+        iofogUuid: ioFogUuid
+      }, data, transaction);
+    });
+
+    context('when ChangeTrackingManager#updateIfChanged() fails', () => {
+      def('updateResponse', () => Promise.reject(error));
+
+      it(`fails with ${error}`, () => {
+        return expect($subject).to.be.rejectedWith(error)
+      })
+    });
+
+    context('when ChangeTrackingManager#updateIfChanged() succeeds', () => {
+      it('fulfills the promise', () => {
+        return expect($subject).to.eventually.equal(undefined)
+      })
+    })
+  });
+
+  describe('.getByIoFogUuid()', () => {
+    const transaction = {};
+    const error = 'Error!';
+
+    const ioFogUuid = 'testUuid';
+
+    def('subject', () => $subject.getByIoFogUuid(ioFogUuid, transaction));
+    def('updateResponse', () => Promise.resolve());
+
+    beforeEach(() => {
+      $sandbox.stub(ChangeTrackingManager, 'findOne').returns($updateResponse);
+    });
+
+    it('calls ChangeTrackingManager#findOne() with correct args', async () => {
+      await $subject;
+      expect(ChangeTrackingManager.findOne).to.have.been.calledWith({
+        iofogUuid: ioFogUuid
+      }, transaction);
+    });
+
+    context('when ChangeTrackingManager#findOne() fails', () => {
+      def('updateResponse', () => Promise.reject(error));
+
+      it(`fails with ${error}`, () => {
+        return expect($subject).to.be.rejectedWith(error)
+      })
+    });
+
+    context('when ChangeTrackingManager#findOne() succeeds', () => {
+      it('fulfills the promise', () => {
+        return expect($subject).to.eventually.equal(undefined)
+      })
+    })
+  });
+
+});