test: add node fetch injector url test

Co-authored-by: imdudu1 <[email protected]>

Author: jbl428

lib/decorators/http-exchange.decorator.ts

@@ -14,7 +14,7 @@ export interface HttpExchangeMetadata {
   url: string;
 }
 
-type AsyncFunction = (...args: unknown[]) => Promise<unknown>;
+type AsyncFunction = (...args: any[]) => Promise<unknown>;
 
 export function HttpExchange(method: HttpMethod, url: string) {
   return function <P extends string>(

lib/decorators/http-interface.decorator.spec.ts

@@ -9,7 +9,10 @@ describe("HttpInterface", () => {
     class TestService {}
 
     // when
-    const result = Reflect.getMetadata(HTTP_INTERFACE_METADATA, TestService);
+    const result = Reflect.getMetadata(
+      HTTP_INTERFACE_METADATA,
+      TestService.prototype
+    );
 
     // then
     expect(result).toBe("");
@@ -21,7 +24,10 @@ describe("HttpInterface", () => {
     class TestService {}
 
     // when
-    const result = Reflect.getMetadata(HTTP_INTERFACE_METADATA, TestService);
+    const result = Reflect.getMetadata(
+      HTTP_INTERFACE_METADATA,
+      TestService.prototype
+    );
 
     // then
     expect(result).toBe("/api/v1/sample");

lib/decorators/http-interface.decorator.ts

@@ -3,7 +3,7 @@ import { HTTP_INTERFACE_METADATA } from "./constants";
 
 export function HttpInterface(url = ""): ClassDecorator {
   const decorator: ClassDecorator = (target) => {
-    Reflect.defineMetadata(HTTP_INTERFACE_METADATA, url, target);
+    Reflect.defineMetadata(HTTP_INTERFACE_METADATA, url, target.prototype);
   };
 
   return applyDecorators(Injectable, decorator);

lib/fixture/stub-discovery.service.ts

@@ -0,0 +1,37 @@
+import {
+  type DiscoveryOptions,
+  DiscoveryService,
+  ModulesContainer,
+} from "@nestjs/core";
+import { type InstanceWrapper } from "@nestjs/core/injector/instance-wrapper";
+import { type Module } from "@nestjs/core/injector/module";
+
+export class StubDiscoveryService extends DiscoveryService {
+  #providers: InstanceWrapper[] = [];
+
+  constructor() {
+    super(new ModulesContainer());
+  }
+
+  addProvider<T>(Provide: new (...args: unknown[]) => T): T {
+    const instance = new Provide();
+    const instanceWrapper = {
+      instance,
+      metatype: { prototype: Provide.prototype },
+    };
+    this.#providers.push(instanceWrapper as any);
+
+    return instance;
+  }
+
+  clear(): void {
+    this.#providers = [];
+  }
+
+  override getProviders(
+    options?: DiscoveryOptions,
+    modules?: Module[]
+  ): InstanceWrapper[] {
+    return this.#providers;
+  }
+}

lib/fixture/stub-http-client.ts

@@ -0,0 +1,32 @@
+import { type HttpClient } from "../types/http-client.interface";
+
+export class StubHttpClient implements HttpClient {
+  #requestInfo: Request[] = [];
+  #responses: Response[] = [];
+
+  async request(request: Request): Promise<Response> {
+    this.#requestInfo.push(request);
+
+    const response = this.#responses.shift();
+
+    if (typeof response === "undefined") {
+      throw new Error("empty response array");
+    }
+
+    return response;
+  }
+
+  get requestInfo(): Request[] {
+    return this.#requestInfo;
+  }
+
+  addResponse(body: Record<string, unknown> | string): void {
+    const response = new Response(JSON.stringify(body));
+    this.#responses.push(response);
+  }
+
+  clear(): void {
+    this.#requestInfo = [];
+    this.#responses = [];
+  }
+}

lib/node-fetch.injector.spec.ts

@@ -0,0 +1,114 @@
+import { MetadataScanner } from "@nestjs/core";
+import { beforeEach, describe, test, expect } from "vitest";
+import { GetExchange, HttpInterface, PathVariable } from "./decorators";
+import { StubDiscoveryService } from "./fixture/stub-discovery.service";
+import { StubHttpClient } from "./fixture/stub-http-client";
+import { NodeFetchInjector } from "./node-fetch.injector";
+
+describe("NodeFetchInjector", () => {
+  const metadataScanner = new MetadataScanner();
+  const httpClient = new StubHttpClient();
+  const discoveryService = new StubDiscoveryService();
+  const nodeFetchInjector = new NodeFetchInjector(
+    metadataScanner,
+    discoveryService,
+    httpClient
+  );
+
+  beforeEach(() => {
+    httpClient.clear();
+    discoveryService.clear();
+  });
+
+  test("should not wrap method if there is no http exchange", async () => {
+    // given
+    @HttpInterface()
+    class SampleClient {
+      async request(): Promise<string> {
+        return "request";
+      }
+    }
+    const instance = discoveryService.addProvider(SampleClient);
+    nodeFetchInjector.onModuleInit();
+
+    // when
+    const actual = await instance.request();
+
+    // then
+    expect(actual).toBe("request");
+    expect(httpClient.requestInfo).toHaveLength(0);
+  });
+
+  test("should request to given url", async () => {
+    // given
+    @HttpInterface("https://example.com")
+    class SampleClient {
+      @GetExchange("/api")
+      async request(): Promise<string> {
+        return "request";
+      }
+    }
+    const instance = discoveryService.addProvider(SampleClient);
+    httpClient.addResponse({ status: "ok" });
+    nodeFetchInjector.onModuleInit();
+
+    // when
+    const actual = await instance.request();
+
+    // then
+    expect(actual).toEqual({ status: "ok" });
+    expect(httpClient.requestInfo).toHaveLength(1);
+    expect(httpClient.requestInfo[0].url).toBe("https://example.com/api");
+  });
+
+  test("should request to path parm replaced url", async () => {
+    // given
+    @HttpInterface("https://example.com")
+    class SampleClient {
+      @GetExchange("/api/users/{id}/{id}")
+      async request(@PathVariable("id") id: string): Promise<string> {
+        return "request";
+      }
+    }
+    const instance = discoveryService.addProvider(SampleClient);
+    httpClient.addResponse({ status: "ok" });
+    nodeFetchInjector.onModuleInit();
+
+    // when
+    const actual = await instance.request("1");
+
+    // then
+    expect(actual).toEqual({ status: "ok" });
+    expect(httpClient.requestInfo).toHaveLength(1);
+    expect(httpClient.requestInfo[0].url).toBe(
+      "https://example.com/api/users/1/1"
+    );
+  });
+
+  test("should request to multiple path parm replaced url", async () => {
+    // given
+    @HttpInterface("https://example.com")
+    class SampleClient {
+      @GetExchange("/api/users/{id}/{status}")
+      async request(
+        @PathVariable("id") id: string,
+        @PathVariable("status") status: string
+      ): Promise<string> {
+        return "request";
+      }
+    }
+    const instance = discoveryService.addProvider(SampleClient);
+    httpClient.addResponse({ status: "ok" });
+    nodeFetchInjector.onModuleInit();
+
+    // when
+    const actual = await instance.request("123", "active");
+
+    // then
+    expect(actual).toEqual({ status: "ok" });
+    expect(httpClient.requestInfo).toHaveLength(1);
+    expect(httpClient.requestInfo[0].url).toBe(
+      "https://example.com/api/users/123/active"
+    );
+  });
+});

lib/node-fetch.injector.ts

@@ -8,12 +8,14 @@ import {
   PATH_VARIABLE_METADATA,
   type PathVariableMetadata,
 } from "./decorators";
+import { HttpClient } from "./types/http-client.interface";
 
 @Injectable()
 export class NodeFetchInjector implements OnModuleInit {
   constructor(
     private readonly metadataScanner: MetadataScanner,
-    private readonly discoveryService: DiscoveryService
+    private readonly discoveryService: DiscoveryService,
+    private readonly httpClient: HttpClient
   ) {}
 
   onModuleInit(): void {
@@ -43,14 +45,15 @@ export class NodeFetchInjector implements OnModuleInit {
 
         wrapper.instance[methodName] = async (...args: any[]) => {
           const url = [...(pathMetadata?.entries() ?? [])].reduce(
-            (url, [index, value]) => url.replace(value, args[index]),
+            (url, [index, value]) =>
+              url.replace(new RegExp(`{${value}}`, "g"), args[index]),
             `${baseUrl}${httpExchangeMetadata.url}`
           );
           const request = new Request(url);
 
-          return await fetch(request).then(
-            async (response) => await response.json()
-          );
+          return await this.httpClient
+            .request(request)
+            .then(async (response) => await response.json());
         };
       });
     });

lib/types/http-client.interface.ts

@@ -0,0 +1,3 @@
+export interface HttpClient {
+  request: (request: Request) => Promise<Response>;
+}