Merge pull request #2 from Coreoz/feature/fix-return-type-of-rest-request

Feature/fix return type of rest request

Author: amanteaux

src/lib/promise/HttpPromise.ts

@@ -151,10 +151,10 @@ export class HttpPromise<T> {
    *
    * @param thenFunction The code that will be executed after the `Promise` has been resolved.
    */
-  then<R = void>(thenFunction: PromiseFunction<T, R>): HttpPromise<R> {
+  then<R = void>(thenFunction: PromiseFunction<T, R>): HttpPromise<Awaited<R>> {
     this.isThenAttached = true;
     this.promise = this.promise.then(safeThen(thenFunction, this.debugContext));
-    return this as unknown as HttpPromise<R>;
+    return this as unknown as HttpPromise<Awaited<R>>;
   }
 
   /**
@@ -174,10 +174,10 @@ export class HttpPromise<T> {
    * @param catchFunction The code that will do something with the {@link HttpError}
    * and possibility recover the `Promise`.
    */
-  catch<R = void>(catchFunction: PromiseFunction<HttpError, R>): HttpPromise<R | T> {
+  catch<R = void>(catchFunction: PromiseFunction<HttpError, R>): HttpPromise<Awaited<R>> {
     this.isCaughtAttached = true;
     this.promise = this.promise.catch(safeCatch(catchFunction, this.debugContext));
-    return this as unknown as HttpPromise<R>;
+    return this as unknown as HttpPromise<Awaited<R>>;
   }
 
   /**

src/tests/FetchClient.test.ts

@@ -1,8 +1,15 @@
-import { HttpRequest, HttpMethod } from 'simple-http-request-builder';
-import ApiHttpClient from './ApiHttpClient';
-import { genericError, networkError, timeoutError } from '../lib/client/HttpResponse';
+import { HttpMethod, HttpRequest } from 'simple-http-request-builder';
 import { fetchClient } from '../lib/client/FetchClient';
-import { unwrapHttpPromise } from '../lib/promise/HttpPromise';
+import {
+  genericError,
+  HttpError,
+  HttpResponse,
+  networkError,
+  timeoutError,
+  toErrorResponsePromise,
+} from '../lib/client/HttpResponse';
+import { HttpPromise, unwrapHttpPromise } from '../lib/promise/HttpPromise';
+import ApiHttpClient from './ApiHttpClient';
 
 const waitTimeout = (durationInMillis: number) => new Promise(
   // eslint-disable-next-line no-promise-executor-return
@@ -14,6 +21,9 @@ const mockedFetchResponseStatus: ResponseInit = {
   status: 200,
   statusText: 'Ok',
   // headers
+  headers: {
+    'content-type': 'application/json',
+  },
 };
 let mockedPromiseError: Error | undefined;
 
@@ -28,6 +38,19 @@ const mockedFetch = (): Promise<Response> => {
   return Promise.resolve(new Response(mockedFetchResponseBody, mockedFetchResponseStatus));
 };
 
+type MockUser = { id: number };
+
+const executeGetUserRequest = (mockUser: MockUser): HttpPromise<MockUser> => {
+  // Mock body
+  setMockedBody(mockUser);
+  // Add client
+  const apiClient: ApiHttpClient = new ApiHttpClient();
+  // Execute request
+  return apiClient
+    .restRequest<MockUser>(HttpMethod.GET, 'https://hostname/users')
+    .execute();
+};
+
 describe('Tests fetch client', () => {
   const oldFetch = global.fetch;
   global.fetch = mockedFetch;
@@ -77,7 +100,9 @@ describe('Tests fetch client', () => {
 
   test('Check handler execution error rejects promise with genericError', async () => {
     const httpClientWithErrorHandler = (httpRequest: HttpRequest<unknown>) => unwrapHttpPromise(fetchClient(
-      httpRequest, () => { throw new Error(); },
+      httpRequest, () => {
+        throw new Error();
+      },
     ));
     const response = new HttpRequest(
       httpClientWithErrorHandler,
@@ -87,4 +112,80 @@ describe('Tests fetch client', () => {
     ).execute();
     await expect(response).rejects.toEqual(genericError);
   });
+
+  test('Check return type of rest request must be User', async () => {
+    const mockFirstUser: MockUser = { id: 1 };
+    const result: MockUser = await executeGetUserRequest(mockFirstUser);
+    expect(result.id).toEqual(1);
+  });
+
+  test('Check return type of then function must be unwrap in the next then call', async () => {
+    // Mock body
+    const mockFirstUser: MockUser = { id: 1 };
+    const mockSecondUser: MockUser = { id: 2 };
+
+    // Add client
+    // Execute request in request
+    const result: MockUser = await executeGetUserRequest(mockFirstUser)
+      .then(() => executeGetUserRequest(mockSecondUser));
+    expect(result.id).toEqual(2);
+  });
+
+  test('Check return type of catch function must be unwrap in the next then call', async () => {
+    const httpClientWithErrorHandler = (
+      httpRequest: HttpRequest<unknown>,
+    ): Promise<HttpResponse<MockUser>> => fetchClient(
+      httpRequest,
+      () => {
+        const httpError: HttpError = {
+          errorCode: 'INTERNAL_ERROR',
+        };
+        return toErrorResponsePromise<HttpError>(httpError);
+      },
+    );
+
+    const result: HttpError = await new HttpRequest<HttpPromise<MockUser>>(
+      (httpRequest: HttpRequest<unknown>) => new HttpPromise<MockUser>(
+        unwrapHttpPromise(httpClientWithErrorHandler(httpRequest)),
+        httpRequest,
+      ),
+      'http://localhost',
+      HttpMethod.GET,
+      '/users',
+    )
+      .execute()
+      .catch((httpError: HttpError) => httpError);
+
+    expect(result.errorCode).toEqual('INTERNAL_ERROR');
+  });
+
+  test('Check return type of catch function must be unwrap in the next then call', async () => {
+    const mockFirstUser: MockUser = { id: 1 };
+
+    const httpClientWithErrorHandler = (
+      httpRequest: HttpRequest<unknown>,
+    ): Promise<HttpResponse<MockUser>> => fetchClient(
+      httpRequest,
+      () => {
+        const httpError: HttpError = {
+          errorCode: 'INTERNAL_ERROR',
+        };
+        return toErrorResponsePromise<HttpError>(httpError);
+      },
+    );
+
+    const result: MockUser = await new HttpRequest<HttpPromise<MockUser>>(
+      (httpRequest: HttpRequest<unknown>) => new HttpPromise<MockUser>(
+        unwrapHttpPromise(httpClientWithErrorHandler(httpRequest)),
+        httpRequest,
+      ),
+      'http://localhost',
+      HttpMethod.GET,
+      '/users',
+    )
+      .execute()
+      .catch(() => executeGetUserRequest(mockFirstUser));
+
+    expect(result.id).toEqual(1);
+  });
 });