chore(api): update API to be consistent with Pact Go

examples/messages/consumer/message-consumer.spec.ts

@@ -6,14 +6,14 @@ import * as sinon from "sinon";
 import { like, term } from "../../../src/dsl/matchers";
 import { dogApiHandler } from "./dog-handler";
 
-const { MessageConsumer, Message, synchronousBodyHandler } = require("../../../src/pact");
+const { MessageConsumerPact, Message, synchronousBodyHandler } = require("../../../src/pact");
 const path = require("path");
 const expect = chai.expect;
 
 chai.use(chaiAsPromised);
 
 describe("Message consumer tests", () => {
-  const messagePact = new MessageConsumer({
+  const messagePact = new MessageConsumerPact({
     consumer: "MyJSMessageConsumer",
     dir: path.resolve(process.cwd(), "pacts"),
     pactfileWriteMode: "update",

src/dsl/message.ts

@@ -21,7 +21,8 @@ export interface Message {
   contents: any;
 }
 
-// Consumer message handler
-export type MessageHandler = (m: Message) => Promise<any>;
-export interface MessageHandlers { [name: string]: MessageHandler; }
+// Message producer/handlers
+export type MessageConsumer = (m: Message) => Promise<any>;
+export type MessageProvider = (m: Message) => Promise<any>;
+export interface MessageProviders { [name: string]: MessageProvider; }
 export interface StateHandlers { [name: string]: (state: string) => Promise<any>; }

src/dsl/options.ts

@@ -3,7 +3,7 @@
  * @module PactOptions
  */
 import { PactfileWriteMode } from "./mockService";
-import { MessageHandlers, StateHandlers } from "pact";
+import { MessageProviders, StateHandlers } from "pact";
 
 export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
 
@@ -57,8 +57,6 @@ export interface MandatoryPactOptions {
 }
 
 export type PactOptionsComplete = PactOptions & MandatoryPactOptions;
-// export interface MessageHandlers { [name: string]: (m: Message) => Promise<any>; }
-// export interface StateHandlers { [name: string]: (m: Message) => Promise<any>; }
 
 export interface MessageProviderOptions {
   // The name of the consumer
@@ -80,7 +78,7 @@ export interface MessageProviderOptions {
   logLevel?: LogLevel;
 
   // Message providers
-  handlers: MessageHandlers;
+  messageProviders: MessageProviders;
 
   // Prepare any provider states
   stateHandlers?: StateHandlers;

src/messageConsumer.spec.ts → src/messageConsumerPact.spec.ts

@@ -1,7 +1,7 @@
 /* tslint:disable:no-unused-expression no-empty */
 import * as chai from "chai";
 import * as chaiAsPromised from "chai-as-promised";
-import { MessageConsumer, synchronousBodyHandler, asynchronousBodyHandler } from "./messageConsumer";
+import { MessageConsumerPact, synchronousBodyHandler, asynchronousBodyHandler } from "./messageConsumerPact";
 import { fail } from "assert";
 import { Message } from "./dsl/message";
 import * as sinon from "sinon";
@@ -13,10 +13,10 @@ chai.use(chaiAsPromised);
 const expect = chai.expect;
 
 describe("MessageConsumer", () => {
-  let consumer: MessageConsumer;
+  let consumer: MessageConsumerPact;
 
   beforeEach(() => {
-    consumer = new MessageConsumer({
+    consumer = new MessageConsumerPact({
       consumer: "myconsumer",
       provider: "myprovider",
     });
@@ -56,7 +56,9 @@ describe("MessageConsumer", () => {
           .withMetadata({ baz: "bat" });
 
         expect(consumer.json().providerStates).to.be.a("array");
-        expect(consumer.json().providerStates).to.deep.eq([{ name: "some state" }]);
+        expect(consumer.json().providerStates).to.deep.eq([
+          { name: "some state" },
+        ]);
       });
     });
     describe("when a valid Message has not been constructed", () => {
@@ -72,24 +74,21 @@ describe("MessageConsumer", () => {
     describe("when an empty description has been given", () => {
       it("it should throw an error", () => {
         expect(() => {
-          consumer
-            .expectsToReceive("");
+          consumer.expectsToReceive("");
         }).to.throw(Error);
       });
     });
     describe("when an empty content object has been given", () => {
       it("it should throw an error", () => {
         expect(() => {
-          consumer
-            .withContent({});
+          consumer.withContent({});
         }).to.throw(Error);
       });
     });
     describe("when an empty metadata object has been given", () => {
       it("it should throw an error", () => {
         expect(() => {
-          consumer
-            .withMetadata({});
+          consumer.withMetadata({});
         }).to.throw(Error);
       });
     });
@@ -98,14 +97,16 @@ describe("MessageConsumer", () => {
   describe("#verify", () => {
     describe("when given a valid handler and message", () => {
       it("should successfully verify the consumer message", () => {
-        const stubbedConsumer = new MessageConsumer({
+        const stubbedConsumer = new MessageConsumerPact({
           consumer: "myconsumer",
           provider: "myprovider",
         });
 
         // Stub out service factory
         (stubbedConsumer as any).getServiceFactory = () => {
-          return { createMessage: (opts: any) => Promise.resolve("message created") };
+          return {
+            createMessage: (opts: any) => Promise.resolve("message created"),
+          };
         };
 
         stubbedConsumer
@@ -114,7 +115,9 @@ describe("MessageConsumer", () => {
           .withContent({ foo: "bar" })
           .withMetadata({ baz: "bat" });
 
-        return expect(stubbedConsumer.verify((m: Message) => Promise.resolve("yay!"))).to.eventually.be.fulfilled;
+        return expect(
+          stubbedConsumer.verify((m: Message) => Promise.resolve("yay!")),
+        ).to.eventually.be.fulfilled;
       });
     });
   });
@@ -137,7 +140,6 @@ describe("MessageConsumer", () => {
   });
 
   describe("handler transformers", () => {
-
     describe("#asynchronousbodyHandler", () => {
       describe("when given a function that succeeds", () => {
         it("should return a Handler object that returns a completed promise", () => {
@@ -160,7 +162,9 @@ describe("MessageConsumer", () => {
     describe("#synchronousbodyHandler", () => {
       describe("when given a function that succeeds", () => {
         it("should return a Handler object that returns a completed promise", () => {
-          const failFn = (obj: any) => { /* do nothing! */ };
+          const failFn = (obj: any) => {
+            /* do nothing! */
+          };
           const hFn = synchronousBodyHandler(failFn);
 
           return expect(hFn(testMessage)).to.eventually.be.fulfilled;
@@ -169,13 +173,14 @@ describe("MessageConsumer", () => {
 
       describe("when given a function that throws an Exception", () => {
         it("should return a Handler object that returns a rejected promise", () => {
-          const failFn = (obj: any) => { throw new Error("fail"); };
+          const failFn = (obj: any) => {
+            throw new Error("fail");
+          };
           const hFn = synchronousBodyHandler(failFn);
 
           return expect(hFn(testMessage)).to.eventually.be.rejected;
         });
       });
-
     });
   });
 });

src/messageConsumer.ts → src/messageConsumerPact.ts

@@ -5,7 +5,12 @@
 import { isEmpty, cloneDeep } from "lodash";
 import { MatcherResult, extractPayload } from "./dsl/matchers";
 import { qToPromise } from "./common/utils";
-import { Metadata, Message, MessageHandler } from "./dsl/message";
+import {
+  Metadata,
+  Message,
+  MessageProvider,
+  MessageConsumer,
+} from "./dsl/message";
 import logger from "./common/logger";
 import serviceFactory from "@pact-foundation/pact-node";
 import { MessageConsumerOptions } from "./dsl/options";
@@ -18,7 +23,7 @@ interface PactNodeFactory {
  * It is the receiver of an interaction, and needs to be able to handle whatever
  * request was provided.
  */
-export class MessageConsumer {
+export class MessageConsumerPact {
   // Build up a valid Message object
   private state: any = {};
 
@@ -39,9 +44,11 @@ export class MessageConsumer {
       // Currently only supports a single state
       // but the format needs to be v3 compatible for
       // basic interoperability
-      this.state.providerStates = [{
-        name: providerState,
-      }];
+      this.state.providerStates = [
+        {
+          name: providerState,
+        },
+      ];
     }
 
     return this;
@@ -72,7 +79,9 @@ export class MessageConsumer {
    */
   public withContent(content: any) {
     if (isEmpty(content)) {
-      throw new Error("You must provide a valid JSON document or primitive for the Message.");
+      throw new Error(
+        "You must provide a valid JSON document or primitive for the Message.",
+      );
     }
     this.state.contents = content;
 
@@ -87,7 +96,9 @@ export class MessageConsumer {
    */
   public withMetadata(metadata: Metadata) {
     if (isEmpty(metadata)) {
-      throw new Error("You must provide valid metadata for the Message, or none at all");
+      throw new Error(
+        "You must provide valid metadata for the Message, or none at all",
+      );
     }
     this.state.metadata = metadata;
 
@@ -109,19 +120,23 @@ export class MessageConsumer {
    * @param handler A message handler, that must be able to consume the given Message
    * @returns {Promise}
    */
-  public verify(handler: MessageHandler): Promise<any> {
+  public verify(handler: MessageConsumer): Promise<any> {
     logger.info("Verifying message");
 
     return this.validate()
       .then(() => handler(extractPayload(cloneDeep(this.state))))
-      .then(() => qToPromise<string>(this.getServiceFactory().createMessage({
-        consumer: this.config.consumer,
-        content: JSON.stringify(this.state),
-        dir: this.config.dir,
-        pactFileWriteMode: this.config.pactfileWriteMode,
-        provider: this.config.provider,
-        spec: 3,
-      })));
+      .then(() =>
+        qToPromise<string>(
+          this.getServiceFactory().createMessage({
+            consumer: this.config.consumer,
+            content: JSON.stringify(this.state),
+            dir: this.config.dir,
+            pactFileWriteMode: this.config.pactfileWriteMode,
+            provider: this.config.provider,
+            spec: 3,
+          }),
+        ),
+    );
   }
 
   /**
@@ -139,7 +154,6 @@ export class MessageConsumer {
   private getServiceFactory(): PactNodeFactory {
     return serviceFactory;
   }
-
 }
 
 const isMessage = (x: Message | any): x is Message => {
@@ -150,7 +164,7 @@ const isMessage = (x: Message | any): x is Message => {
 
 // bodyHandler takes a synchronous function and returns
 // a wrapped function that accepts a Message and returns a Promise
-export function synchronousBodyHandler(handler: (body: any) => any): MessageHandler {
+export function synchronousBodyHandler(handler: (body: any) => any): MessageProvider {
   return (m: Message): Promise<any> => {
     const body = m.contents;
 
@@ -168,6 +182,6 @@ export function synchronousBodyHandler(handler: (body: any) => any): MessageHand
 // bodyHandler takes an asynchronous (promisified) function and returns
 // a wrapped function that accepts a Message and returns a Promise
 // TODO: move this into its own package and re-export?
-export function asynchronousBodyHandler(handler: (body: any) => Promise<any>): MessageHandler {
+export function asynchronousBodyHandler(handler: (body: any) => Promise<any>): MessageProvider {
   return (m: Message) => handler(m.contents);
 }