import { V3Interaction } from '@pact_foundation/pact';
import {
  boolean,
  eachLike,
  integer,
  like,
  number,
  string,
  uuid,
} from '@pact_foundation/pact/src/v3/matchers';
import { MockClient } from './mockClient';
import { provider } from './provider';

const timeout: number = 10000;
jest.setTimeout(timeout);
jasmine.DEFAULT_TIMEOUT_INTERVAL = timeout;

/* tslint:disable:object-literal-sort-keys */
/* tslint:disable:no-magic-numbers */
describe('Generate contract example', () => {
  test(
    '',
    async () => {
      const interaction: V3Interaction = {
        uponReceiving: '',
        withRequest: {
          method: 'GET',
          path: '/endpoint',
        },
        willRespondWith: {
          body: {
          },
          headers: {
            'Content-Type': 'application/json; charset=utf-8',
          },
          status: 200,
        },
      };

      provider.addInteraction(interaction);
    },
    timeout
  ),
    test(
      '',
      async () => {
        const interaction: V3Interaction = {
          uponReceiving: '',
          withRequest: {
            method: 'GET',
            path: '/endpoint',
          },
          willRespondWith: {
            body: eachLike({
            }),
            headers: {
              'Content-Type': 'application/json; charset=utf-8',
            },
            status: 200,
          },
        };

        provider.addInteraction(interaction);
      },
      timeout
    ),
    test(
      '',
      async () => {
        const interaction: V3Interaction = {
          uponReceiving: '',
          withRequest: {
            method: 'GET',
            path: '/endpoint',
            query: {
            },
            headers: {
              'Content-Type': 'application/json; charset=utf-8',
            },
            status: 200,
          },
        };

        provider.addInteraction(interaction);
      },
      timeout
    ),
    afterAll(async () => {
      await provider.executeTest(async mockServer => {
        const service: MockClient = new MockClient(mockServer.url, mockServer.port);
        await service.get1();
        await service.get2();
        await service.get3();
      });
    });
});

afterAll

executeTest

afterAll

import { PactV3 } from '@pact-foundation/pact';
import * as path from 'path';

/* tslint:disable:object-literal-sort-keys */
const provider: PactV3 = new PactV3({
  port: 4000,
  dir: path.resolve(process.cwd(), 'pact/pactFiles'),
  logLevel: 'debug',
  consumer: 'Consumer2',
  provider: 'Provider',
  spec: 2,
  cors: true,
});
export { provider };

secondly, I’m not sure what you’re trying to do with the

afterAll

call - the

executeTest

block is supposed to be in the test, not in an

afterAll

(which will only run once)

test

mockClient

Which example is this pattern in? We should correct this, because it’s definitely going to lead to problems

import { pactWith } from 'jest-pact/dist/v3';
import { MatchersV3 } from '@pact-foundation/pact';
import api from 'yourCode';

pactWith({ consumer: 'MyConsumer', provider: 'MyProvider' }, (interaction) => {
  interaction('A request for API health', ({ provider, execute }) => {
    beforeEach(() =>
      provider
        .given('Server is healthy')
        .uponReceiving('A request for API health')
        .withRequest({
          method: 'GET',
          path: '/health',
        })
        .willRespondWith({
          status: 200,
          body: {
            status: MatchersV3.like('up'),
          },
        })
    );

    execute('some api call', (mockserver) =>
      api(mockserver.url)
        .health()
        .then((health) => {
          expect(health).toEqual('up');
        })
    );
  });
});

await

provider.addInteraction(interaction);

provider.executeTest

port

provider.executeTest

import { PactV3 } from "@pact-foundation/pact";
import { ProductApiClient } from "../../clients/product/getProducts_client1";
import { MatchersV3 } from "@pact-foundation/pact";
import { Product2 } from "../../models/product2";
const { eachLike, like } = MatchersV3;
const Pact = PactV3;

// const mockProvider = new Pact({
//   consumer: 'pactflow-example-consumer',
//   provider: process.env.PACT_PROVIDER
//     ? process.env.PACT_PROVIDER
//     : 'pactflow-example-provider'
// });

const mockProvider = new Pact({
  consumer: "products-consumer2",
  provider: "products-provider",
  //cors: true, // needed for katacoda environment
});

describe("API Pact test", () => {
  it("ID 10 exists", async () => {
    // Arrange
    const expectedProduct = { id: 10, type: "pizza", name: "Margharita" };

    // Uncomment to see this fail
    // const expectedProduct = { id: '10', type: 'CREDIT_CARD', name: '28 Degrees', price: 30.0, newField: 22}

    mockProvider
      .given("a product with ID 10 exists")
      .uponReceiving("a request to get a product")
      .withRequest({
        method: "GET",
        path: "/products/10",
      })
      .willRespondWith({
        status: 200,
        headers: {
          "Content-Type": "application/json; charset=utf-8",
        },
        body: like(expectedProduct),
      });
    return mockProvider.executeTest(async (mockserver) => {
      // Act
      const api = new ProductApiClient(mockserver.url);
      const product = await api.getProduct(10);

      // Assert - did we get the expected response
      expect(product).toStrictEqual(new Product2(10, "Margharita", "pizza"));
      return;
    });
  });

  it("product does not exist", async () => {
    // set up Pact interactions

    mockProvider
      .given("a product with ID 11 does not exist")
      .uponReceiving("a request to get a product")
      .withRequest({
        method: "GET",
        path: "/products/11",
        headers: {
          Authorization: like("Bearer 2019-01-14T11:34:18.045Z"),
        },
      })
      .willRespondWith({
        status: 404,
      });
    return mockProvider.executeTest(async (mockserver) => {
      const api = new ProductApiClient(mockserver.url);

      // make request to Pact mock server
      await expect(api.getProduct(11)).rejects.toThrow(
        "Request failed with status code 404"
      );
      return;
    });
  });
});

.uponReceiving("a request to get a product")

npm ls @pact-foundation/pact

module.exports = {

presets: [

['@babel/preset-env', {targets: {node: 'current'}}],

'@babel/preset-typescript',

],

};