109 lines
3.6 KiB
JavaScript
109 lines
3.6 KiB
JavaScript
import Docker from 'dockerode';
|
|
import getStream from 'get-stream';
|
|
import got from 'got';
|
|
import pRetry from 'p-retry';
|
|
import {mockServerClient} from 'mockserver-client';
|
|
|
|
const MOCK_SERVER_PORT = 1080;
|
|
const MOCK_SERVER_HOST = 'localhost';
|
|
const docker = new Docker();
|
|
let container;
|
|
|
|
async function checkStatus() {
|
|
const response = await got.put(`http://${MOCK_SERVER_HOST}:${MOCK_SERVER_PORT}/status`, {cache: false});
|
|
if (response.status === 200) {
|
|
// If the registry returns a 200 status, it's ready. Abort the retry.
|
|
throw new pRetry.AbortError();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Download the `mockserver` Docker image, create a new container and start it.
|
|
*
|
|
* @return {Promise} Promise that resolves when the container is started.
|
|
*/
|
|
async function start() {
|
|
await getStream(await docker.pull('jamesdbloom/mockserver:latest'));
|
|
|
|
container = await docker.createContainer({
|
|
Image: 'jamesdbloom/mockserver',
|
|
PortBindings: {[`${MOCK_SERVER_PORT}/tcp`]: [{HostPort: `${MOCK_SERVER_PORT}`}]},
|
|
});
|
|
await container.start();
|
|
|
|
try {
|
|
// Wait for the mock server to be ready
|
|
await pRetry(checkStatus, {retries: 5, minTimeout: 1000, factor: 2});
|
|
} catch (err) {
|
|
throw new Error(`Couldn't start mock-server after 30s`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stop the `mockserver` Docker container.
|
|
*
|
|
* @return {Promise} Promise that resolves when the container is stopped.
|
|
*/
|
|
async function stop() {
|
|
return container.stop();
|
|
}
|
|
|
|
/**
|
|
* @type {Object} A `mockserver` client configured to connect to the current instance.
|
|
*/
|
|
const client = mockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT);
|
|
/**
|
|
* @type {string} the url of the `mockserver` instance
|
|
*/
|
|
const url = `http://${MOCK_SERVER_HOST}:${MOCK_SERVER_PORT}`;
|
|
|
|
/**
|
|
* Set up the `mockserver` instance response for a specific request.
|
|
*
|
|
* @param {string} path URI for which to respond.
|
|
* @param {Object} request Request expectation. The http request made on `path` has to match those criteria in order to be valid.
|
|
* @param {Object} request.body The JSON body the expected request must match.
|
|
* @param {Object} request.headers The headers the expected request must match.
|
|
* @param {Object} response The http response to return when receiving a request on `path`.
|
|
* @param {String} [response.method='POST'] The http method for which to respond.
|
|
* @param {number} [response.statusCode=200] The status code to respond.
|
|
* @param {Object} response.body The JSON object to respond in the response body.
|
|
* @return {Object} An object representation the expectation. Pass to the `verify` function to validate the `mockserver` has been called with a `request` matching the expectations.
|
|
*/
|
|
async function mock(
|
|
path,
|
|
{body: requestBody, headers: requestHeaders},
|
|
{method = 'POST', statusCode = 200, body: responseBody}
|
|
) {
|
|
await client.mockAnyResponse({
|
|
httpRequest: {path, method},
|
|
httpResponse: {
|
|
statusCode,
|
|
headers: [{name: 'Content-Type', values: ['application/json; charset=utf-8']}],
|
|
body: JSON.stringify(responseBody),
|
|
},
|
|
times: {remainingTimes: 1, unlimited: false},
|
|
});
|
|
|
|
return {
|
|
method,
|
|
path,
|
|
headers: requestHeaders,
|
|
body: requestBody
|
|
? {type: 'JSON', json: JSON.stringify(requestBody), matchType: 'ONLY_MATCHING_FIELDS'}
|
|
: undefined,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Verify the `mockserver` has been called with a requestion matching expectations. The `expectation` is created with the `mock` function.
|
|
*
|
|
* @param {Object} expectation The expectation created with `mock` function.
|
|
* @return {Promise} A Promise that resolves if the expectation is met or reject otherwise.
|
|
*/
|
|
async function verify(expectation) {
|
|
return client.verify(expectation);
|
|
}
|
|
|
|
export default {start, stop, mock, verify, url};
|