feat(karma): relax consumer/provider requirement in MockService #96

Author: mefellows

src/common/logger.spec.ts

@@ -4,28 +4,35 @@ import * as  proxyquire from 'proxyquire';
 
 describe('Logger#info', () => {
   const consoleLogSpy = sinon.spy(console, 'log');
+  const consoleWarnSpy = sinon.spy(console, 'warn');
 
   context('with logging configuration turned on', () => {
     beforeEach(() => {
       consoleLogSpy.reset();
+      consoleWarnSpy.reset();
       const logger = proxyquire('./logger', { './config': { config: { logging: true } } }).logger;
       logger.info('this will be logged');
+      logger.warn('this will be logged at warn');
     });
 
     it('logs a message', () => {
       expect(consoleLogSpy).to.have.been.calledWith('this will be logged');
+      expect(consoleWarnSpy).to.have.been.calledWith('this will be logged at warn');
     });
   });
 
   context('with logging configuration turned off', () => {
     beforeEach(() => {
       consoleLogSpy.reset();
+      consoleWarnSpy.reset();
       const logger = proxyquire('./logger', { './config': { config: { logging: false } } }).logger;
       logger.info('this will be ignored');
+      logger.warn('this will be ignored at warn');
     });
 
     it('ignores a message to be logged', () => {
       expect(consoleLogSpy).to.not.have.been.called;
+      expect(consoleWarnSpy).to.not.have.been.called;
     });
   });
 });

src/common/logger.ts

@@ -11,6 +11,11 @@ const logger = {
     if (config.logging) {
       console.log(msg);
     }
+  },
+  warn: (msg: any) => {
+    if (config.logging) {
+      console.warn(msg)
+    }
   }
 }
 

src/dsl/mockService.spec.ts

@@ -32,12 +32,12 @@ describe('MockService', () => {
 
     it('does not create a MockService when consumer is not informed', () => {
       expect(() => { new MockService('', 'provider') })
-        .to.throw(Error, 'Please provide the names of the provider and consumer for this Pact.')
+        .not.to.throw(Error);
     })
 
     it('does not create a MockService when provider is not informed', () => {
       expect(() => { new MockService('consumer', '') })
-        .to.throw(Error, 'Please provide the names of the provider and consumer for this Pact.')
+        .not.to.throw(Error);
     })
   })
 
@@ -64,13 +64,12 @@ describe('MockService', () => {
 
     it('when interactions are removed successfully', (done) => {
       nock(mock.baseUrl).delete(/interactions$/).reply(200)
-      expect(mock.removeInteractions()).to.eventually.notify(done)
+      expect(mock.removeInteractions()).to.eventually.be.fulfilled.notify(done)
     })
 
     it('when interactions fail to be removed', (done) => {
       nock(mock.baseUrl).delete(/interactions$/).reply(500)
-      expect(mock.removeInteractions()).to.eventually.be.rejected
-      done()
+      expect(mock.removeInteractions()).to.eventually.be.rejected.notify(done)
     })
   })
 
@@ -79,29 +78,51 @@ describe('MockService', () => {
 
     it('when verification is successful', (done) => {
       nock(mock.baseUrl).get(/interactions\/verification$/).reply(200)
-      expect(mock.verify()).to.eventually.notify(done)
+      expect(mock.verify()).to.eventually.be.fulfilled.notify(done)
     })
 
     it('when verification fails', (done) => {
       nock(mock.baseUrl).get(/interactions\/verification$/).reply(500)
-      expect(mock.verify()).to.eventually.be.rejected
-      done()
+      expect(mock.verify()).to.eventually.be.rejected.notify(done)
     })
   })
 
   describe('#writePact', () => {
-    const mock = new MockService('consumer', 'provider', 1234)
-
-    it('when writing is successful', (done) => {
-      nock(mock.baseUrl).post(/pact$/).reply(200)
-      expect(mock.writePact()).to.eventually.notify(done)
+    describe('when consumer and provider details provided', () => {
+      const mock = new MockService('aconsumer', 'aprovider', 1234)
+
+      describe('and writing is successful', () => {
+        it('should write the consumer and provider details into the pact', (done) => {
+          nock(mock.baseUrl)
+            .post(/pact$/, {
+              pactfile_write_mode: 'overwrite',
+              consumer: { name: 'aconsumer' },
+              provider: { name: 'aprovider' }
+            })
+            .reply(200)
+          expect(mock.writePact()).to.eventually.be.fulfilled.notify(done)
+        })
+      })
+
+      describe('and writing fails', () => {
+        it('should return a rejected promise', (done) => {
+          nock(mock.baseUrl)
+            .post(/pact$/).reply(500)
+          expect(mock.writePact()).to.eventually.be.rejected.notify(done)
+        })
+      })
     })
-
-    it('when writing fails', (done) => {
-      nock(mock.baseUrl).post(/pact$/).reply(500)
-      expect(mock.writePact()).to.eventually.be.rejected
-      done()
+    describe('when consumer and provider details are not provided', () => {
+      const mock = new MockService(undefined, undefined, 1234)
+      it('should not write the consumer and provider details into the pact', (done) => {
+        nock(mock.baseUrl)
+          .post(/pact$/, {
+            pactfile_write_mode: 'overwrite',
+            consumer: undefined,
+            provider: undefined
+          }).reply(200)
+        expect(mock.writePact()).to.eventually.be.fulfilled.notify(done)
+      })
     })
   })
-
 })

src/dsl/mockService.ts

@@ -7,12 +7,16 @@
 import { isEmpty } from 'lodash';
 import { Request } from '../common/request';
 import { Interaction } from './interaction';
+import { logger } from '../common/logger';
 
 export type PactfileWriteMode = 'overwrite' | 'update' | 'none';
 
+export interface Pacticipant {
+  name: string
+}
 export interface PactDetails {
-  consumer: { name: string };
-  provider: { name: string };
+  consumer?: Pacticipant;
+  provider?: Pacticipant;
   pactfile_write_mode: PactfileWriteMode;
 }
 
@@ -29,22 +33,23 @@ export class MockService {
    * @param {boolean} ssl - which protocol to use, defaults to false (HTTP)
    * @param {string} pactfileWriteMode - 'overwrite' | 'update' | 'none', defaults to 'overwrite'
    */
-  constructor(private consumer: string,
-    private provider: string,
+  constructor(private consumer?: string,
+    private provider?: string,
     private port = 1234,
     private host = '127.0.0.1',
     private ssl = false,
     private pactfileWriteMode: PactfileWriteMode = 'overwrite') {
 
     if (isEmpty(consumer) || isEmpty(provider)) {
-      throw new Error('Please provide the names of the provider and consumer for this Pact.')
+      logger.warn('Warning: Consumer\Provider details not provided, ensure ' +
+        'that the mock service has been started with this information')
     }
 
     this.request = new Request();
     this.baseUrl = `${ssl ? 'https' : 'http'}://${host}:${port}`;
     this.pactDetails = {
-      consumer: { name: consumer },
-      provider: { name: provider },
+      consumer: (consumer) ? { name: consumer } : undefined,
+      provider: (provider) ? { name: provider } : undefined,
       pactfile_write_mode: pactfileWriteMode
     };
   }

src/pact-web.ts

@@ -52,12 +52,10 @@ export class PactWeb {
 
     this.opts = { ...defaults, ...config } as PactOptionsComplete;
 
-    if (isEmpty(this.opts.consumer)) {
-      throw new Error('You must specify a Consumer for this pact.');
-    }
-
-    if (isEmpty(this.opts.provider)) {
-      throw new Error('You must specify a Provider for this pact.');
+    if (isEmpty(this.opts.consumer) || isEmpty(this.opts.provider)) {
+      logger.info(`Setting up Pact using mock service on port: "${this.opts.port}"`)
+    } else {
+      logger.info(`Setting up Pact with Consumer "${this.opts.consumer}" and Provider "${this.opts.provider}" using mock service on port: "${this.opts.port}"`)
     }
 
     logger.info(`Setting up Pact with Consumer "${this.opts.consumer}" and Provider "${this.opts.provider}"
@@ -140,8 +138,8 @@ export class PactWeb {
  * @param {string} pactfileWriteMode - 'overwrite' | 'update', 'none', defaults to 'overwrite'
  */
 export interface PactOptions {
-  consumer: string;
-  provider: string;
+  consumer?: string;
+  provider?: string;
   port?: number;
   host?: string;
   ssl?: boolean;