fix: adding more test cases according to the feedback provided, cs improvements

Author: ivanproskuryakov

src/ActionParameterHandler.ts

@@ -96,10 +96,8 @@ export class ActionParameterHandler<T extends BaseDriver> {
   protected async normalizeParamValue(value: any, param: ParamMetadata): Promise<any> {
     if (value === null || value === undefined) return value;
 
-    const isNormalisationNeeded =
-      typeof value === 'object' &&
-      ['queries', 'headers', 'params', 'cookies'].some(paramType => paramType === param.type);
-    const isTargetPrimitive = ['number', 'string', 'boolean'].indexOf(param.targetName) > -1;
+    const isNormalisationNeeded = typeof value === 'object' && ['queries', 'headers', 'params', 'cookies'].includes(param.type);
+    const isTargetPrimitive = ['number', 'string', 'boolean'].includes(param.targetName);
     const isTransformationNeeded = (param.parse || param.isTargetObject) && param.type !== 'param';
 
     // if param value is an object and param type match, normalize its string properties

test/ActionParameterHandler.spec.ts

@@ -1,63 +1,127 @@
-import { ActionParameterHandler } from '../src/ActionParameterHandler';
-import { ActionMetadata, ControllerMetadata, ExpressDriver, ParamMetadata } from '../src';
-import { ActionMetadataArgs } from '../src/metadata/args/ActionMetadataArgs';
-import { ControllerMetadataArgs } from '../src/metadata/args/ControllerMetadataArgs';
+import {ActionParameterHandler} from "../src/ActionParameterHandler";
+import {ActionMetadata, ControllerMetadata, ExpressDriver, ParamMetadata} from "../src";
+import {ActionMetadataArgs} from "../src/metadata/args/ActionMetadataArgs";
+import {ControllerMetadataArgs} from "../src/metadata/args/ControllerMetadataArgs";
 
-const expect = require('chakram').expect;
+const expect = require("chakram").expect;
 
-describe('ActionParameterHandler', () => {
-  it('handle', async () => {
-    const driver = new ExpressDriver();
-    const actionParameterHandler = new ActionParameterHandler(driver);
-
-    const action = {
-      request: {
-        params: {
-          id: '0b5ec98f-e26d-4414-b798-dcd35a5ef859',
-        },
-      },
-      response: {},
-    };
+describe("ActionParameterHandler", () => {
+  const buildParamMetadata = (): ParamMetadata => {
     const controllerMetadataArgs: ControllerMetadataArgs = {
-      target: function () {},
-      route: '',
-      type: 'json',
+      target: function () {
+      },
+      route: "",
+      type: "json",
       options: {},
     };
     const controllerMetadata = new ControllerMetadata(controllerMetadataArgs);
     const args: ActionMetadataArgs = {
-      route: '',
-      method: 'getProduct',
+      route: "",
+      method: "getProduct",
       options: {},
-      target: function () {},
-      type: 'get',
+      target: function () {
+      },
+      type: "get",
       appendParams: undefined,
     };
     const actionMetadata = new ActionMetadata(controllerMetadata, args, {});
 
-    const param: ParamMetadata = {
-      targetName: 'product',
+    return {
+      targetName: "product",
       isTargetObject: true,
       actionMetadata,
-      target: () => {},
-      method: 'getProduct',
-      object: 'getProduct',
+      target: () => {
+      },
+      method: "getProduct",
+      object: "getProduct",
       extraOptions: undefined,
       index: 0,
-      type: 'param',
-      name: 'id',
+      type: "param",
+      name: "id",
       parse: undefined,
       required: false,
       transform: function (action, value) {
         return value;
       },
       classTransform: undefined,
       validate: undefined,
-      targetType: function () {},
+      targetType: function () {
+      },
+    };
+  };
+
+  it("handle - should process string parameters", async () => {
+    const driver = new ExpressDriver();
+    const actionParameterHandler = new ActionParameterHandler(driver);
+    const param = buildParamMetadata();
+
+    const action = {
+      request: {
+        params: {
+          id: "0b5ec98f-e26d-4414-b798-dcd35a5ef859",
+        },
+      },
+      response: {},
     };
 
     const processedValue = await actionParameterHandler.handle(action, param);
 
     expect(processedValue).to.be.eq(action.request.params.id);
   });
+
+  it("handle - should process string parameters, returns empty if a given string is empty", async () => {
+    const driver = new ExpressDriver();
+    const actionParameterHandler = new ActionParameterHandler(driver);
+    const param = buildParamMetadata();
+
+    const action = {
+      request: {
+        params: {
+          id: "",
+        },
+      },
+      response: {},
+    };
+
+    const processedValue = await actionParameterHandler.handle(action, param);
+
+    expect(processedValue).to.be.eq(action.request.params.id);
+  });
+
+  it("handle - should process number parameters", async () => {
+    const driver = new ExpressDriver();
+    const actionParameterHandler = new ActionParameterHandler(driver);
+    const param = buildParamMetadata();
+
+    const action = {
+      request: {
+        params: {
+          id: 10000,
+        },
+      },
+      response: {},
+    };
+
+    const processedValue = await actionParameterHandler.handle(action, param);
+
+    expect(processedValue).to.be.eq(action.request.params.id);
+  });
+
+  it("handle - undefined on empty object provided", async () => {
+    const driver = new ExpressDriver();
+    const actionParameterHandler = new ActionParameterHandler(driver);
+    const param = buildParamMetadata();
+
+    const action = {
+      request: {
+        params: {},
+      },
+      response: {},
+    };
+
+    const processedValue = await actionParameterHandler.handle(action, param);
+
+    expect(processedValue).to.be.eq(undefined);
+  });
+
 });