refactor: harmonize diff function parameters

ybonnefond · Oct 23, 2024 · 28c970c · 28c970c
1 parent 7cd4a01
commit 28c970c
Show file tree

Hide file tree

Showing 14 changed files with 161 additions and 113 deletions.
diff --git a/src/@types/index.ts b/src/@types/index.ts
@@ -77,10 +77,11 @@ export type RequestInfo = {
   method: RequestMethod;
 };
 
-export type Request = IncomingMessage &
-  RequestInfo & {
-    searchParams?: URLSearchParams;
-  };
+export type RequestInfoWithSearchParam = RequestInfo & {
+  searchParams: URLSearchParams;
+};
+
+export type Request = IncomingMessage & RequestInfoWithSearchParam;
 
 export type Response = ServerResponse;
 export type NextFunction = (err?: any) => void;

diff --git a/src/diff/bodyDiff.test.ts b/src/diff/bodyDiff.test.ts
@@ -1,7 +1,8 @@
-import { BodyDefinition, JsonValue, RequestBody } from '../@types';
-import { DIFF_SUBJECTS, DIFF_TYPES, WILDCARD } from '../constants';
+import { BodyDefinition, JsonValue } from '../@types';
+import { DIFF_SUBJECTS, DIFF_TYPES, METHODS, WILDCARD } from '../constants';
 import { bodyDiff } from './bodyDiff';
-import { makeExpectDiffError } from '../../test';
+import { makeExpectDiffError, makeRequestInfo } from '../../test';
+import { Route } from '../Route';
 
 describe('bodyDiff', () => {
   const LC_STRING = /^[a-z]+$/;
@@ -79,7 +80,11 @@ describe('bodyDiff', () => {
     [{ a: { b: { c: END_WITH_LO } } }, { a: { b: { c: 'hello' } } }],
   ])('should pass with def %p and value %p', (...args) => {
     const [def, val] = args;
-    const result = bodyDiff(def as BodyDefinition, val);
+
+    const route = new Route(METHODS.GET, '/').setBody(def as BodyDefinition);
+    const request = makeRequestInfo({ body: val });
+    const result = bodyDiff(route, request);
+
     expectErrors(result, []);
   });
 
@@ -92,7 +97,11 @@ describe('bodyDiff', () => {
       const val = {
         a: 'a',
       };
-      const result = bodyDiff(def, val);
+
+      const route = new Route(METHODS.GET, '/').setBody(def);
+      const request = makeRequestInfo({ body: val });
+      const result = bodyDiff(route, request);
+
       expectErrors(result, [
         {
           type: DIFF_TYPES.MISSING,
@@ -123,7 +132,11 @@ describe('bodyDiff', () => {
           },
         },
       };
-      const result = bodyDiff(def, val);
+
+      const route = new Route(METHODS.GET, '/').setBody(def);
+      const request = makeRequestInfo({ body: val });
+      const result = bodyDiff(route, request);
+
       expectErrors(result, [
         {
           type: DIFF_TYPES.MISSING,
@@ -144,7 +157,11 @@ describe('bodyDiff', () => {
         a: 'a',
         b: 'b',
       };
-      const result = bodyDiff(def, val);
+
+      const route = new Route(METHODS.GET, '/').setBody(def);
+      const request = makeRequestInfo({ body: val });
+      const result = bodyDiff(route, request);
+
       expectErrors(result, [
         {
           type: DIFF_TYPES.EXTRA,
@@ -175,7 +192,11 @@ describe('bodyDiff', () => {
           },
         },
       };
-      const result = bodyDiff(def, val);
+
+      const route = new Route(METHODS.GET, '/').setBody(def);
+      const request = makeRequestInfo({ body: val });
+      const result = bodyDiff(route, request);
+
       expectErrors(result, [
         {
           type: DIFF_TYPES.EXTRA,
@@ -243,7 +264,9 @@ describe('bodyDiff', () => {
     ],
     )('should fail if def %p not equal val %p', (...args) => {
       const [def, val, error] = args;
-      const result = bodyDiff(def as BodyDefinition, val as RequestBody);
+      const route = new Route(METHODS.GET, '/').setBody(def);
+      const request = makeRequestInfo({ body: val });
+      const result = bodyDiff(route, request);
       expectErrors(result, [error]);
     });
   });

diff --git a/src/diff/bodyDiff.ts b/src/diff/bodyDiff.ts
@@ -1,14 +1,14 @@
-import { BodyDefinition, DiffError, RequestBody } from '../@types';
+import { BodyDefinition, DiffError, RequestInfo, RequestBody } from '../@types';
 import { checkValue, findErrors } from './utils';
 import { DIFF_SUBJECTS } from '../constants';
+import { Route } from '../Route';
 
 const subject = DIFF_SUBJECTS.BODY;
 
-export function bodyDiff(
-  definition: BodyDefinition,
-  value: RequestBody,
-): DiffError[] {
-  return rec({ definition, value, path: '' });
+export function bodyDiff(route: Route, request: RequestInfo): DiffError[] {
+  const value =
+    request.body instanceof Buffer ? String(request.body) : request.body;
+  return rec({ definition: route.getBody(), value, path: '' });
 }
 
 function rec({

diff --git a/src/diff/headersDiff.test.ts b/src/diff/headersDiff.test.ts
@@ -1,12 +1,13 @@
-import { JsonValue } from '../@types';
-import { DIFF_SUBJECTS, DIFF_TYPES, WILDCARD } from '../constants';
+import { HeadersDefinition, JsonValue, RequestHeaders } from '../@types';
+import { DIFF_SUBJECTS, DIFF_TYPES, METHODS, WILDCARD } from '../constants';
 import { headersDiff } from './headersDiff';
-import { makeExpectDiffError } from '../../test';
+import { makeExpectDiffError, makeRequestInfo } from '../../test';
+import { Route } from '../Route';
 
 describe('headersDiff', () => {
   describe('with extra or missing headers', () => {
     it('should fail if header is missing', () => {
-      const errors = headersDiff({ authorization: /^Bearer/ }, {});
+      const errors = run({ authorization: /^Bearer/ }, {});
       expectErrors(errors, [
         {
           definition: '/^Bearer/',
@@ -18,7 +19,7 @@ describe('headersDiff', () => {
     });
 
     it('should fail if header is extra', () => {
-      const errors = headersDiff({}, { authorization: 'Bearer 123' });
+      const errors = run({}, { authorization: 'Bearer 123' });
       expectErrors(errors, [
         {
           definition: 'undefined',
@@ -30,7 +31,7 @@ describe('headersDiff', () => {
     });
 
     it('should fail with both missing and extra headers', () => {
-      const errors = headersDiff(
+      const errors = run(
         { accept: 'application/json' },
         { authorization: 'Bearer 456' },
       );
@@ -53,35 +54,35 @@ describe('headersDiff', () => {
 
   describe('using wildcard', () => {
     it('should pass if headers are wildcarded', () => {
-      const errors = headersDiff(WILDCARD, { authorization: 'basic 123' });
+      const errors = run(WILDCARD, { authorization: 'basic 123' });
       expectErrors(errors, []);
     });
 
     it('should pass if a header is wildcarded', () => {
-      const errors = headersDiff(
+      const errors = run(
         { authorization: WILDCARD },
         { authorization: 'basic 123' },
       );
       expectErrors(errors, []);
     });
 
     it('should pass if a header is wildcarded and case is different', () => {
-      const errors = headersDiff(
+      const errors = run(
         { authorization: WILDCARD },
         { AUTHORIZATION: 'basic 123' },
       );
       expectErrors(errors, []);
     });
 
     it('should pass if a header is wildcarded and NOT in request', () => {
-      const errors = headersDiff({ authorization: WILDCARD }, {});
+      const errors = run({ authorization: WILDCARD }, {});
       expectErrors(errors, []);
     });
   });
 
   describe('with string definition', () => {
     it('should fail if value is not equal to definition', () => {
-      const errors = headersDiff(
+      const errors = run(
         { accept: 'application/json' },
         { accept: 'application/text' },
       );
@@ -96,15 +97,15 @@ describe('headersDiff', () => {
     });
 
     it('should pass if value is equal to definition', () => {
-      const errors = headersDiff(
+      const errors = run(
         { accept: 'application/json' },
         { accept: 'application/json' },
       );
       expectErrors(errors, []);
     });
 
     it('should pass if value is equal to definition and header case is different', () => {
-      const errors = headersDiff(
+      const errors = run(
         { accept: 'application/json' },
         { Accept: 'application/json' },
       );
@@ -114,10 +115,7 @@ describe('headersDiff', () => {
 
   describe('with RexExp definition', () => {
     it('should fail if value does not match definition', () => {
-      const errors = headersDiff(
-        { accept: /json/ },
-        { accept: 'application/text' },
-      );
+      const errors = run({ accept: /json/ }, { accept: 'application/text' });
       expectErrors(errors, [
         {
           definition: '/json/',
@@ -129,10 +127,7 @@ describe('headersDiff', () => {
     });
 
     it('should pass if value matches definition', () => {
-      const errors = headersDiff(
-        { accept: /json/ },
-        { accept: 'application/json' },
-      );
+      const errors = run({ accept: /json/ }, { accept: 'application/json' });
       expectErrors(errors, []);
     });
   });
@@ -142,10 +137,7 @@ describe('headersDiff', () => {
       const fn = (val: JsonValue) => (val as string).endsWith('json');
       const fnString = String(fn);
 
-      const errors = headersDiff(
-        { accept: fn },
-        { accept: 'application/text' },
-      );
+      const errors = run({ accept: fn }, { accept: 'application/text' });
       expectErrors(errors, [
         {
           definition: fnString,
@@ -157,13 +149,19 @@ describe('headersDiff', () => {
     });
 
     it('should pass if value passes function definition', () => {
-      const errors = headersDiff(
+      const errors = run(
         { accept: (val: JsonValue) => (val as string).endsWith('json') },
         { accept: 'application/json' },
       );
       expectErrors(errors, []);
     });
   });
 
+  function run(def: HeadersDefinition, val: RequestHeaders) {
+    const route = new Route(METHODS.GET, '/').setHeaders(def);
+    const request = makeRequestInfo({ headers: val });
+    return headersDiff(route, request);
+  }
+
   const expectErrors = makeExpectDiffError(DIFF_SUBJECTS.HEADERS);
 });
diff --git a/src/diff/headersDiff.ts b/src/diff/headersDiff.ts
@@ -1,14 +1,17 @@
-import { DiffError, HeadersDefinition, RequestHeaders } from '../@types';
+import { DiffError, RequestInfo } from '../@types';
 import { DIFF_SUBJECTS, WILDCARD } from '../constants';
 import { checkValue, findErrors } from './utils';
+import { Route } from '../Route';
+
+export function headersDiff(route: Route, request: RequestInfo): DiffError[] {
+  const headersDefinitions = route.getHeaders();
+  const headersValues = request.headers;
 
-export function headersDiff(
-  _definitions: HeadersDefinition,
-  _values: RequestHeaders,
-): DiffError[] {
   const definition =
-    WILDCARD === _definitions ? WILDCARD : keysToLowerCase(_definitions);
-  const value = keysToLowerCase(_values);
+    WILDCARD === headersDefinitions
+      ? WILDCARD
+      : keysToLowerCase(headersDefinitions);
+  const value = keysToLowerCase(headersValues);
 
   return findErrors({
     subject: DIFF_SUBJECTS.HEADERS,

diff --git a/src/diff/methodDiff.test.ts b/src/diff/methodDiff.test.ts
@@ -1,9 +1,13 @@
-import { DIFF_SUBJECTS, DIFF_TYPES } from '../constants';
+import { DIFF_SUBJECTS, DIFF_TYPES, METHODS } from '../constants';
 import { methodDiff } from './methodDiff';
+import { Route } from '../Route';
+import { makeRequestInfo } from '../../test';
 
 describe('methodDiff', () => {
   function run(def: any, value: any) {
-    return methodDiff(def, value);
+    const route = new Route(METHODS.GET, '/').setHeaders(def);
+    const request = makeRequestInfo({ method: value });
+    return methodDiff(route, request);
   }
 
   function expectNoErrors(def: any, value: any) {

diff --git a/src/diff/methodDiff.ts b/src/diff/methodDiff.ts
@@ -1,12 +1,14 @@
 import { DiffError } from '../@types';
 import { checkValue } from './utils';
 import { DIFF_SUBJECTS } from '../constants';
+import { RequestInfo } from '../@types';
+import { Route } from '../Route';
 
-export function methodDiff(definition: string, value: string): DiffError[] {
+export function methodDiff(route: Route, request: RequestInfo): DiffError[] {
   return checkValue({
     subject: DIFF_SUBJECTS.METHOD,
-    definition: definition.toLowerCase(),
-    value: value.toLowerCase(),
+    definition: route.getMethod().toLowerCase(),
+    value: request.method.toLowerCase(),
     path: '',
   });
 }
diff --git a/src/diff/pathDiff.test.ts b/src/diff/pathDiff.test.ts
@@ -1,10 +1,14 @@
 import { JsonValue } from '../@types';
-import { DIFF_SUBJECTS, DIFF_TYPES } from '../constants';
+import { DIFF_SUBJECTS, DIFF_TYPES, METHODS } from '../constants';
 import { pathDiff } from './pathDiff';
+import { Route } from '../Route';
+import { makeRequestInfo } from '../../test';
 
 describe('pathDiff', () => {
   function run(def: any, value: any) {
-    return pathDiff(def, value);
+    const route = new Route(METHODS.GET, def);
+    const request = makeRequestInfo({ path: value });
+    return pathDiff(route, request);
   }
 
   function expectNoErrors(def: any, value: any) {

diff --git a/src/diff/pathDiff.ts b/src/diff/pathDiff.ts
@@ -1,15 +1,13 @@
-import { DiffError, PathDefinition } from '../@types';
+import { DiffError, RequestInfo } from '../@types';
 import { checkValue } from './utils';
 import { DIFF_SUBJECTS } from '../constants';
+import { Route } from '../Route';
 
-export function pathDiff(
-  definition: PathDefinition,
-  value: string,
-): DiffError[] {
+export function pathDiff(route: Route, request: RequestInfo): DiffError[] {
   return checkValue({
     subject: DIFF_SUBJECTS.PATH,
-    definition,
-    value,
+    definition: route.getPath(),
+    value: request.path,
     path: '',
   });
 }