JUG-11 Add custom response definition

src/adapters/express/AppEnv.ts

@@ -20,5 +20,6 @@ export const makeAppEnv = (config: Config): TE.TaskEither<Error, AppEnv> =>
       mock,
       requestResponseReader: requestResponseStore,
       requestResponseWriter: requestResponseStore,
+      listCustomResponseDefinition: () => [],
     }))
   );

src/adapters/express/getRequestResponseRouter.ts

@@ -20,9 +20,9 @@ const makeAPIRequestResponse = (
     body: input.request.body || {},
   },
   response: {
-    status: input.response.status,
+    status: input.response.statusCode,
     headers: input.response.headers || {},
-    body: input.response.data || {},
+    body: input.response.body || {},
   },
 });
 

src/adapters/express/mockHandler.ts

@@ -6,14 +6,14 @@ import { pipe } from 'fp-ts/lib/function';
 import * as O from 'fp-ts/lib/Option';
 import * as RTE from 'fp-ts/lib/ReaderTaskEither';
 import * as RR from 'fp-ts/lib/ReadonlyRecord';
-import { MockRequest } from '../../domain/Mock';
+import { HttpRequest } from '../../domain/RequestResponse';
 import { processRequest } from '../../useCases/processRequest';
 import { AppEnv } from './AppEnv';
 import { problemDetail500 } from './errors';
 
 export const makeMethod = (
   method: express.Request['method']
-): MockRequest['method'] => {
+): HttpRequest['method'] => {
   switch (method) {
     case 'DELETE':
       return 'delete';
@@ -36,7 +36,7 @@ export const makeMethod = (
 
 const makeHeaders = (
   headers: express.Request['headers']
-): MockRequest['headers'] =>
+): HttpRequest['headers'] =>
   pipe(
     headers,
     RR.filterMap(O.fromNullable),
@@ -49,7 +49,7 @@ const makeHeaders = (
  */
 export const makeMockRequestFromExpressRequest = (
   request: express.Request
-): MockRequest => ({
+): HttpRequest => ({
   url: {
     path: request.path,
   },
@@ -68,8 +68,8 @@ export const makeMockHandler =
       processRequest(makeMockRequestFromExpressRequest(req)),
       RTE.fold(
         (_) => RTE.of(res.status(500).json(problemDetail500)),
-        ({ status, headers, data }) =>
-          RTE.of(res.status(status).header(headers).send(data))
+        ({ statusCode, headers, body }) =>
+          RTE.of(res.status(statusCode).header(headers).send(body))
       ),
       RTE.toUnion
     )(env)();

src/adapters/prism/makeMock.ts

@@ -36,7 +36,14 @@ const makePrismHttp = (openapi: string): TE.TaskEither<Error, PrismHttp> =>
  */
 export const makeMockFromPrismHttp = (prismHttp: PrismHttp): Mock => ({
   generateResponse: (req) =>
-    TE.tryCatch(() => prismHttp.request(req.url.path, req), E.toError),
+    pipe(
+      TE.tryCatch(() => prismHttp.request(req.url.path, req), E.toError),
+      TE.map(({ status, headers, data }) => ({
+        statusCode: status,
+        headers,
+        body: data,
+      }))
+    ),
 });
 
 /**

src/domain/Capabilities.ts

@@ -2,6 +2,7 @@
  * This file is a capabilities mapper, maps a capability to a given key.
  */
 
+import { ListCustomResponseDefinition } from './CustomResponseDefinition';
 import { Mock } from './Mock';
 import {
   RequestResponseReader,
@@ -18,4 +19,5 @@ export type Capabilities = {
   mock: Mock;
   requestResponseReader: RequestResponseReader;
   requestResponseWriter: RequestResponseWriter;
+  listCustomResponseDefinition: ListCustomResponseDefinition;
 };

src/domain/CustomResponseDefinition.ts

@@ -0,0 +1,13 @@
+import { HttpRequest, HttpResponse } from './RequestResponse';
+
+export type CustomResponseDefinition = {
+  match: HttpRequest;
+  response: HttpResponse;
+};
+
+// Return true if match matches request
+export const matches = (match: HttpRequest, request: HttpRequest): boolean =>
+  match.method === request.method && match.url.path === request.url.path;
+
+export type ListCustomResponseDefinition =
+  () => ReadonlyArray<CustomResponseDefinition>;

src/domain/Mock.ts

@@ -1,13 +1,5 @@
 import * as TE from 'fp-ts/lib/TaskEither';
-import { IHttpRequest } from '@stoplight/prism-http';
-import { PrismHttp } from '@stoplight/prism-http/dist/client';
-
-// For now use the types of prism
-export type MockRequest = IHttpRequest;
-export type MockOutput = Omit<
-  Awaited<ReturnType<PrismHttp['request']>>,
-  'config'
->;
+import { HttpRequest, HttpResponse } from './RequestResponse';
 
 /**
  * This type exposes the capability to create fake responses
@@ -16,5 +8,5 @@ export type Mock = {
   /**
    * Given a request, produce a fake response.
    */
-  generateResponse: (req: MockRequest) => TE.TaskEither<Error, MockOutput>;
+  generateResponse: (req: HttpRequest) => TE.TaskEither<Error, HttpResponse>;
 };

src/domain/RequestResponse.ts

@@ -1,14 +1,18 @@
 import * as TE from 'fp-ts/TaskEither';
-import { MockRequest, MockOutput } from './Mock';
+import { IHttpRequest, IHttpResponse } from '@stoplight/prism-http';
+
+// For now use the types of prism
+export type HttpRequest = IHttpRequest;
+export type HttpResponse = IHttpResponse;
 
 /**
  * Represents the request-response pair provided by the Mock.
  */
 export type RequestResponse = {
   // I didn't found a better term from the RFC 2616.
   // https://www.rfc-editor.org/rfc/rfc2616.html#section-4
-  request: MockRequest;
-  response: MockOutput;
+  request: HttpRequest;
+  response: HttpResponse;
 };
 
 /**

src/domain/__tests__/CustomResponseDefinition.test.ts

@@ -0,0 +1,24 @@
+import { matches } from '../CustomResponseDefinition';
+import { data } from './data';
+
+const request = data.requestResponse.aRequestResponse.request;
+
+describe('matches', () => {
+  it('should match requests without error', () => {
+    expect(matches(request, request)).toBeTruthy();
+    expect(matches({ ...request, method: 'post' }, request)).toBeFalsy();
+    // ignore body during match
+    expect(
+      matches(
+        {
+          ...request,
+          body: { a: 'a' },
+        },
+        {
+          ...request,
+          body: { b: 'b' },
+        }
+      )
+    ).toBeTruthy();
+  });
+});

src/domain/__tests__/data.ts

@@ -1,48 +1,70 @@
 import * as TE from 'fp-ts/TaskEither';
 import { mock } from 'jest-mock-extended';
 import { Capabilities } from '../Capabilities';
-import { MockOutput, MockRequest } from '../Mock';
+import { CustomResponseDefinition } from '../CustomResponseDefinition';
+import { HttpRequest, HttpResponse } from '../RequestResponse';
 
-const aMockRequest: MockRequest = {
+const anHttpRequest: HttpRequest = {
   method: 'get',
   url: { path: 'http://localhost:8080/hello?name=Rupert' },
 };
 
-const aMockOutput: MockOutput = {
-  status: 200,
+const anHttpResponse: HttpResponse = {
+  statusCode: 200,
   headers: {},
-  data: {},
-  request: aMockRequest,
-  violations: { input: [], output: [] },
+  body: {},
+};
+
+const customResponseDefinition: CustomResponseDefinition = {
+  match: {
+    method: 'post',
+    url: { path: 'http://localhost:8080/hello?name=Rupert' },
+  },
+  response: {
+    statusCode: 200,
+    headers: {
+      'x-custom': 'custom-response-definition',
+    },
+    body: {},
+  },
 };
 
 export const data = {
   mock: {
-    aMockRequest,
-    aMockOutput,
+    anHttpRequest,
+    anHttpResponse,
   },
   requestResponse: {
     aRequestResponse: {
-      request: aMockRequest,
-      response: aMockOutput,
+      request: anHttpRequest,
+      response: anHttpResponse,
     },
   },
+  customResponseDefinition: {
+    anHttpRequest: customResponseDefinition.match,
+    anHttpResponse: customResponseDefinition.response,
+  },
 };
 
 export const makeFakeCapabilities = (defaultData: typeof data = data) => {
   const mocked = {
     mock: mock<Capabilities['mock']>(),
     requestResponseReader: mock<Capabilities['requestResponseReader']>(),
     requestResponseWriter: mock<Capabilities['requestResponseWriter']>(),
+    listCustomResponseDefinition:
+      mock<Capabilities>().listCustomResponseDefinition,
   };
   // default behavior
   mocked.mock.generateResponse.mockReturnValue(
-    TE.right(defaultData.mock.aMockOutput)
+    TE.right(defaultData.mock.anHttpResponse)
   );
   mocked.requestResponseWriter.record.mockImplementation(TE.of);
   mocked.requestResponseReader.list.mockReturnValue(
     TE.of([defaultData.requestResponse.aRequestResponse])
   );
+  mocked.listCustomResponseDefinition.mockReturnValue([
+    customResponseDefinition,
+  ]);
 
   // return within data
   return { env: mocked, envData: defaultData };

src/useCases/__tests__/processRequest.test.ts

@@ -6,15 +6,25 @@ describe('processRequest', () => {
   it('should return mock response', async () => {
     const { env, envData } = makeFakeCapabilities();
 
-    const actual = await processRequest(envData.mock.aMockRequest)(env)();
+    const actual = await processRequest(envData.mock.anHttpRequest)(env)();
     const expected = envData.requestResponse.aRequestResponse.response;
     expect(actual).toStrictEqual(E.right(expected));
   });
   it('should record the request-response pair', async () => {
     const { env, envData } = makeFakeCapabilities();
 
-    await processRequest(envData.mock.aMockRequest)(env)();
+    await processRequest(envData.mock.anHttpRequest)(env)();
     const expected = envData.requestResponse.aRequestResponse;
     expect(env.requestResponseWriter.record).nthCalledWith(1, expected);
   });
+  it('should return the response defined by user if any', async () => {
+    const { env, envData } = makeFakeCapabilities();
+
+    const actual = await processRequest({
+      ...envData.customResponseDefinition.anHttpRequest,
+    })(env)();
+    const expected = envData.customResponseDefinition.anHttpResponse;
+    expect(env.mock.generateResponse).toBeCalledTimes(0);
+    expect(actual).toStrictEqual(E.right(expected));
+  });
 });

src/useCases/processRequest.ts

@@ -3,20 +3,34 @@
  */
 import { pipe } from 'fp-ts/lib/function';
 import * as TE from 'fp-ts/TaskEither';
+import * as RA from 'fp-ts/ReadonlyArray';
+import * as O from 'fp-ts/Option';
 import * as R from 'fp-ts/Reader';
 import { Capabilities } from '../domain/Capabilities';
-import { MockRequest } from '../domain/Mock';
+import { HttpRequest } from '../domain/RequestResponse';
+import { matches } from '../domain/CustomResponseDefinition';
 
 /**
- * Process the given request
+ * This function is the entry point for processing an HTTP request. Its goal is
+ * to deliver a dummy answer to the specified HTTP request.
  */
-export const processRequest = (mockRequest: MockRequest) =>
+export const processRequest = (request: HttpRequest) =>
   pipe(
-    R.ask<Pick<Capabilities, 'mock' | 'requestResponseWriter'>>(),
-    R.map(({ mock, requestResponseWriter }) =>
+    R.ask<
+      Pick<
+        Capabilities,
+        'mock' | 'requestResponseWriter' | 'listCustomResponseDefinition'
+      >
+    >(),
+    R.map(({ mock, requestResponseWriter, listCustomResponseDefinition }) =>
       pipe(
-        mock.generateResponse(mockRequest),
-        TE.map((response) => ({ request: mockRequest, response })),
+        listCustomResponseDefinition(),
+        RA.findFirst(({ match }) => matches(match, request)),
+        O.fold(
+          () => mock.generateResponse(request),
+          ({ response }) => TE.of(response)
+        ),
+        TE.map((response) => ({ request, response })),
         TE.chain(requestResponseWriter.record),
         TE.map(({ response }) => response)
       )