wip: initial ts refactor for TS example

examples/typescript/index.ts

@@ -0,0 +1,20 @@
+import axios from "axios";
+
+export class DogService {
+  private url: string;
+  private port: number;
+
+  constructor(endpoint: any) {
+    this.url = endpoint.url;
+    this.port = endpoint.port;
+  }
+
+  public getMeDogs = (): Promise<any> => {
+    return axios.request({
+      baseURL: `${this.url}:${this.port}`,
+      headers: { Accept: "application/json" },
+      method: "GET",
+      url: "/dogs",
+    });
+  }
+}

examples/typescript/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "typescript-pact",
+  "version": "1.0.0",
+  "description": "TypeScript Pact Example",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "nyc --check-coverage --reporter=html --reporter=text-summary mocha"
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/mocha": "^2.2.41",
+    "mocha": "3.x",
+    "nyc": "^11.2.0"
+  },
+  "dependencies": {
+    "axios": "^0.17.1"
+  }
+}

examples/typescript/test/get-dog.spec.ts

@@ -0,0 +1,93 @@
+/* tslint:disable:no-unused-expression object-literal-sort-keys max-classes-per-file no-empty */
+import * as chai from "chai";
+import * as chaiAsPromised from "chai-as-promised";
+import path = require("path");
+import * as sinon from "sinon";
+import * as sinonChai from "sinon-chai";
+import pact = require("../../../dist/pact");
+import { InteractionObject, Interaction } from "../../../dist/pact";
+
+const Pact = pact.Pact;
+const expect = chai.expect;
+const proxyquire = require("proxyquire").noCallThru();
+import { DogService } from "../index";
+
+chai.use(sinonChai);
+chai.use(chaiAsPromised);
+
+describe("The Dog API", () => {
+  const url = "http://localhost";
+  const port = 8989;
+  const dogService = new DogService({ url, port });
+
+  const provider = new Pact({
+    port,
+    log: path.resolve(process.cwd(), "logs", "mockserver-integration.log"),
+    dir: path.resolve(process.cwd(), "pacts"),
+    spec: 2,
+    consumer: "MyConsumer",
+    provider: "MyProvider",
+    pactfileWriteMode: "merge",
+  });
+
+  const EXPECTED_BODY = [{ dog: 1 }, { dog: 2 }];
+
+  before(() => provider.setup());
+
+  after(() => provider.finalize());
+
+  describe("get /dogs", () => {
+    before(() => {
+      const interaction = new Interaction()
+        .given("I have a list of dogs")
+        .uponReceiving("a request for all dogs")
+        .withRequest({
+          method: "GET",
+          path: "/dogs",
+          headers: {
+            Accept: "application/json",
+          },
+        })
+        .willRespondWith({
+          status: 200,
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: EXPECTED_BODY,
+        });
+      return provider.addInteraction(interaction);
+      // before(() => {
+      //   const interaction = {
+      //     state: "i have a list of dogs",
+      //     uponReceiving: "a request for all dogs",
+      //     withRequest: {
+      //       method: "GET",
+      //       path: "/dogs",
+      //       headers: {
+      //         Accept: "application/json",
+      //       },
+      //     },
+      //     willRespondWith: {
+      //       status: 200,
+      //       headers: {
+      //         "Content-Type": "application/json",
+      //       },
+      //       body: EXPECTED_BODY,
+      //     },
+      //   } as InteractionObject;
+      //   return provider.addInteraction(interaction);
+      // });
+
+      it("returns the correct response", (done) => {
+        dogService
+          .getMeDogs()
+          .then((response: any) => {
+            expect(response.data).to.eql(EXPECTED_BODY);
+            done();
+          }, done);
+      });
+
+      // verify with Pact, and reset expectations
+      afterEach(() => provider.verify());
+    });
+  });

examples/typescript/test/helper.ts

@@ -0,0 +1,6 @@
+import wrapper from "@pact-foundation/pact-node";
+
+// used to kill any left over mock server instances
+process.on("SIGINT", () => {
+  wrapper.removeAllServers();
+});

examples/typescript/test/mocha.opts

@@ -0,0 +1,11 @@
+--bail
+--compilers ts:ts-node/register
+--require ./test/helper.ts
+--require ts-node/register
+--require source-map-support/register
+--full-trace
+--reporter spec
+--colors
+--recursive
+--timeout 10000
+test/*.spec.ts

examples/typescript/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "outDir": "./dist",
+    "baseUrl": "src",
+    "sourceMap": true,
+    "noLib": false,
+    "noImplicitReturns": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "moduleResolution": "node",
+    "noEmitOnError": true,
+    "emitDecoratorMetadata": true,
+    "declaration": true,
+    "experimentalDecorators": true,
+    "target": "es5",
+    "lib": [
+      "es2016",
+      "dom"
+    ]
+  },
+  "include": [
+    "./**/*"
+  ],
+  "exclude": [
+    "./node_modules/**/*",
+    "./dist",
+    "./examples",
+    "test/*.spec.ts"
+  ]
+}

examples/typescript/tslint.json

@@ -0,0 +1,12 @@
+{
+  "defaultSeverity": "error",
+  "extends": [
+    "tslint:recommended"
+  ],
+  "jsRules": {},
+  "rules": {
+    "interface-name": [true, "never-prefix"],
+    "no-var-requires": false
+  },
+  "rulesDirectory": []
+}

src/dsl/interaction.ts

@@ -118,6 +118,8 @@ export class Interaction {
       headers: responseOpts.headers || undefined,
       status: responseOpts.status,
     }, isNil) as ResponseOptions;
+
+    return this;
   }
 
   /**

src/pact.ts

@@ -93,17 +93,22 @@ export class Pact {
    * @param {Interaction} interactionObj
    * @returns {Promise}
    */
-  public addInteraction(interactionObj: InteractionObject): Promise<string> {
-    const interaction = new Interaction();
-
-    if (interactionObj.state) {
-      interaction.given(interactionObj.state);
+  public addInteraction(interactionObj: InteractionObject | Interaction): Promise<string> {
+    let interaction: Interaction;
+
+    // tslint:disable:no-angle-bracket-type-assertion
+    if (<InteractionObject>(<any>interactionObj).state) {
+      interaction = new Interaction();
+      if (interactionObj.state) {
+        interaction.given(interactionObj.state);
+      }
+
+      interaction
+        .uponReceiving(interactionObj.uponReceiving)
+        .withRequest(interactionObj.withRequest)
+        .willRespondWith(interactionObj.willRespondWith);
     }
 
-    interaction
-      .uponReceiving(interactionObj.uponReceiving)
-      .withRequest(interactionObj.withRequest)
-      .willRespondWith(interactionObj.willRespondWith);
 
     return this.mockService.addInteraction(interaction);
   }