Is it possible to run pact mock server without running a test?

[dormeiri]

Hi all :)

Currently, we are running our services locally in isolation by binding the application interfaces to mocks using IoC.

For example:

interface OrdersServiceClient {
    getOrder(id: string): Promise<Order>;
}

// Mocked concrete implementation
class OrdersServiceClientMock implements OrdersServiceClient {
    private mockData: Order[] = [
        {
            id: 1,
            name: 'a'
        }, 
        {
            id: 2,
            name: 'b'
        }
    ];

    getOrder(id: string): Promise<Order> {
        return Promise.resolve(this.mockData.find((order) => order.id === id);
    }
}

// Live concrete implementation
class OrdersServiceClientImpl implements OrdersServiceClient {
    getOrder(id: string): Promise<Order> {
        return axios.get(`${ordersServiceSettings.baseUrl}/orders/${id}`);
    }
}

// IoC binding
container.bind(TYPE.ORDERS_SERVICE_CLIENT).to(ordersServiceSettings.useMock ? OrdersServiceClientMock : OrdersServiceClientImpl);

Now, if we want to start using Pact we will have two mock systems, one for tests, and one for an isolated local run.

I want to be able to configure and run the Pact mock server locally when running the application.
--or--
Use the existing mocked implementations to configure the expected interactions in the tests.

Is that possible? Do you have any idea on how to do that correctly?

--P.S

I thought that maybe we can implement a third concrete implementation that will implement each function as follows:

// Pact concrete implementation
class OrdersServiceClientPact implements OrdersServiceClient {
    private mockClient = new OrdersServiceClientMock();
    private liveClient = new OrdersServiceClientImpl();

    async getOrder(id: string): Promise<Order> {
        const expected = await this.mockClient.getOrder(id);
        // Add interaction, the response should be like `expected`
        return await this.liveClient.getOrder(id);
    }
}

// IoC binding
container.bind(TYPE.ORDERS_SERVICE_CLIENT).to(ordersServiceSettings.usePact ? OrdersServiceClientPact : (ordersServiceSetting.useMock ? OrdersServiceClientMock : OrdersServiceClientImpl));

This "Pact" concrete implementation will be bounded to the interface only while running tests. While I can still use the mocked concrete implementation while running the application locally.

This feels a bit complicated. Do you have a better suggestion?