Migrated remaining tests to jest + removed mocha, chai and other old

dependencies

refs #26

package.json

@@ -31,18 +31,11 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@types/chai": "^4.1.4",
-    "@types/chai-http": "^3.0.5",
     "@types/config": "^0.0.34",
     "@types/express": "^4.16.0",
     "@types/jest": "^23.3.9",
-    "@types/mocha": "^5.2.5",
     "@types/node": "^10.5.2",
-    "chai": "^4.1.2",
-    "chai-as-promised": "^7.1.1",
-    "chai-http": "^3.0.0",
     "jest": "^23.6.0",
-    "mocha": "^5.2.0",
     "superagent": "^4.0.0-beta.5",
     "supertest": "^3.3.0",
     "ts-jest": "^23.10.4",
@@ -65,7 +58,6 @@
     "object-transformer": "0.0.5",
     "rabbot": "^2.1.0",
     "schema-object": "^4.0.11",
-    "sinon": "^7.1.1",
     "storm-react-diagrams": "^5.2.1",
     "winston": "^2.4.0"
   },

src/amqp/Topology.spec.ts

@@ -1,50 +1,44 @@
 const topologyExampleConf = require('./test/configurationFixtures.json')
-import { expect } from 'chai'
 import Topology from './Topology'
 
 describe('Topology', () => {
   const topology = new Topology(topologyExampleConf)
   const renderedTopology = topology.getTopology()
 
-  it('should crete a rabbot topology with provided events and tasks', (done) => {
-    expect(renderedTopology).to.be.a('object')
-    expect(renderedTopology.connection).to.be.a('object')
-    expect(renderedTopology.connection.server).to.equals('127.0.0.1')
-    expect(renderedTopology.connection.port).to.equals(5672)
-    done()
+  it('should crete a rabbot topology with provided events and tasks', () => {
+    expect(typeof renderedTopology).toBe('object')
+    expect(typeof renderedTopology.connection).toBe('object')
+    expect(renderedTopology.connection.server).toEqual('127.0.0.1')
+    expect(renderedTopology.connection.port).toEqual(5672)
   })
 
-  it('should generate exchanges', (done) => {
-    expect(renderedTopology.exchanges).to.be.a('array')
-    expect(renderedTopology.exchanges[0]).to.be.a('object')
-    expect(renderedTopology.exchanges[0].name).to.exist
-    expect(renderedTopology.exchanges[0].type).to.exist
-    expect(renderedTopology.exchanges[1].name).to.exist
-    expect(renderedTopology.exchanges[1].type).to.exist
-    done()
+  it('should generate exchanges', () => {
+    expect(Array.isArray(renderedTopology.exchanges)).toBeTruthy()
+    expect(typeof renderedTopology.exchanges[0]).toBe('object')
+    expect(renderedTopology.exchanges[0].name).toBeDefined()
+    expect(renderedTopology.exchanges[0].type).toBeDefined()
+    expect(renderedTopology.exchanges[1].name).toBeDefined()
+    expect(renderedTopology.exchanges[1].type).toBeDefined()
   })
 
-  it('should generate queues', (done) => {
-    expect(renderedTopology.queues).to.be.a('array')
-    expect(renderedTopology.queues[0]).to.be.a('object')
-    expect(renderedTopology.queues[0].name).to.exist
-    done()
+  it('should generate queues', () => {
+    expect(Array.isArray(renderedTopology.queues)).toBeTruthy()
+    expect(typeof renderedTopology.queues[0]).toBe('object')
+    expect(renderedTopology.queues[0].name).toBeDefined()
   })
 
-  it('should generate bindings', (done) => {
-    expect(renderedTopology.bindings).to.be.a('array')
-    expect(renderedTopology.bindings[0]).to.be.a('object')
-    expect(renderedTopology.bindings[0].exchange).to.exist
-    expect(renderedTopology.bindings[0].target).to.exist
-    done()
+  it('should generate bindings', () => {
+    expect(Array.isArray(renderedTopology.bindings)).toBeTruthy()
+    expect(typeof renderedTopology.bindings[0]).toBe('object')
+    expect(renderedTopology.bindings[0].exchange).toBeDefined()
+    expect(renderedTopology.bindings[0].target).toBeDefined()
   })
 
   describe('getEventByName', () => {
-    it('should return an event by its name', (done) => {
+    it('should return an event by its name', () => {
       const event = topology.getEventByName('members')
-      expect(event).to.be.an('object')
-      expect(event.eventName).to.equals('members')
-      done()
+      expect(typeof event).toBe('object')
+      expect(event.eventName).toEqual('members')
     })
   })
 })

src/model/Action.spec.ts

@@ -1,8 +1,5 @@
 import Action from './Action'
 
-import { expect } from 'chai'
-import 'mocha'
-
 describe('Action', () => {
   const params = {
     name: 'testAction',
@@ -12,11 +9,11 @@ describe('Action', () => {
   }
   const testAction = new Action(params)
   it('should must be a model instance', () => {
-    expect(testAction instanceof Action).to.be.true
+    expect(testAction instanceof Action).toBeTruthy()
   })
   it('should be set the params passed by', () => {
-    expect(testAction.name).to.equals('testAction')
-    expect(testAction.type).to.equals('some-type')
-    expect(testAction.options).to.be.a('object')
+    expect(testAction.name).toEqual('testAction')
+    expect(testAction.type).toEqual('some-type')
+    expect(typeof testAction.options).toBe('object')
   })
 })

src/model/Event.spec.ts

@@ -1,8 +1,5 @@
 import Event from './Event'
 
-import { expect } from 'chai'
-import 'mocha'
-
 describe('Event', () => {
   const params = {
     name: 'testEvent',
@@ -17,39 +14,38 @@ describe('Event', () => {
     actions: []
   }
   const testEvent = new Event(params)
+
   it('should must be a model instance', () => {
-    expect(testEvent instanceof Event).to.be.true
+    expect(testEvent instanceof Event).toBeTruthy()
   })
 
-  it('should has event queue properties', (done) => {
+  it('should have event queue properties', () => {
     const event = new Event({
       name: 'testing',
       eventName: 'testing',
       route: 'created',
       actions: []
     })
 
-    expect(event.eventName).to.equals('testing')
-    expect(event.route).to.equals('created')
+    expect(event.eventName).toEqual('testing')
+    expect(event.route).toEqual('created')
 
     // Converting event to exchange
     const generatedExchange = event.toExchange()
-    expect(generatedExchange).to.be.a('object')
-    expect(generatedExchange.name).to.equals('testing')
-    expect(generatedExchange.type).to.equals('direct')
+    expect(typeof generatedExchange).toBe('object')
+    expect(generatedExchange.name).toEqual('testing')
+    expect(generatedExchange.type).toEqual('direct')
 
     // Getting event queue
     const generatedQueue = event.toQueue()
-    expect(generatedQueue).to.be.a('object')
-    expect(generatedQueue.name).to.be.a('string')
+    expect(typeof generatedQueue).toBe('object')
+    expect(typeof generatedQueue.name).toBe('string')
 
     // Getting event binding
     const generatedBinding = event.toBinding()
-    expect(generatedBinding).to.be.a('object')
-    expect(generatedBinding.exchange).to.equals('testing')
-    expect(generatedBinding.target).to.equals('sbo-ms.testing.testing.created')
-    expect(generatedBinding.keys).to.equals('created')
-
-    done()
+    expect(typeof generatedBinding).toBe('object')
+    expect(generatedBinding.exchange).toEqual('testing')
+    expect(generatedBinding.target).toEqual('sbo-ms.testing.testing.created')
+    expect(generatedBinding.keys).toEqual('created')
   })
 })

src/model/Operator.spec.ts

@@ -1,14 +1,11 @@
 import Operator from './Operator'
 
-import { expect } from 'chai'
-import 'mocha'
-
 describe('Operator', () => {
   const testOperator = new Operator()
   it('should must be a model instance', () => {
-    expect(testOperator instanceof Operator).to.be.true
+    expect(testOperator instanceof Operator).toBeTruthy()
   })
   it('should have enabled property set default to true', () => {
-    expect(testOperator.enabled).to.be.true
+    expect(testOperator.enabled).toBeTruthy()
   })
 })

src/model/Task.spec.ts

@@ -1,5 +1,3 @@
-import { expect } from 'chai'
-
 import Task from "./Task"
 
 describe('Task', () => {
@@ -10,9 +8,9 @@ describe('Task', () => {
       route: 'testRoute'
     })
 
-    expect(task.name).to.equals('testing')
-    expect(task.eventName).to.equals('testTarget')
-    expect(task.route).to.equals('testRoute')
+    expect(task.name).toEqual('testing')
+    expect(task.eventName).toEqual('testTarget')
+    expect(task.route).toEqual('testRoute')
 
     done()
   })

src/worker/ActionCreator.spec.ts

@@ -1,13 +1,11 @@
-import chai = require('chai')
-const expect = chai.expect
-const rabbit = require('rabbot')
+import rabbit from 'rabbot'
 
 import Event from '../model/Event'
 import Action from '../model/Action'
 import ActionCreator from './ActionCreator'
 
 describe('ActionCreator', () => {
-  it('should fail if one of the steps fails', (done) => {
+  it('should fail if one of the steps fails', () => {
     const msg = {
       content: {
         toString: function () {
@@ -27,14 +25,10 @@ describe('ActionCreator', () => {
     const actionCreator = new ActionCreator(rabbit, event)
     actionCreator.createHandler()
 
-    actionCreator.executeActions(msg).then((err) => {
-      expect(err).to.not.be.null
-      done()
-    })
+    expect(actionCreator.executeActions(msg)).resolves.toBeFalsy()
   })
 
-  it('should handle coming events', (done) => {
-
+  it('should handle coming events', () => {
     const options = {
       fields: {
         name: 'vars.nom',
@@ -68,9 +62,10 @@ describe('ActionCreator', () => {
     actionCreator.createHandler()
 
     const handler = actionCreator.getHandler()
-    expect(handler).to.be.an('object')
+    expect.assertions(3)
 
-    expect(handler.topic).to.equals('sbo-ms-test-memberships-created.#')
+    expect(typeof handler).toBe('object')
+    expect(handler.topic).toEqual('sbo-ms-test-memberships-created.#')
 
     const msg = {
       content: {
@@ -81,14 +76,9 @@ describe('ActionCreator', () => {
       ack: function () {}
     }
 
-    actionCreator.executeActions(msg)
+    return actionCreator.executeActions(msg)
       .then((results) => {
-        expect(results).to.be.an('object')
-        done()
-      })
-      .catch((err) => {
-        done(err)
+        return expect(typeof results).toBe('object')
       })
   })
-
 })