feat(serviceConfig): ent-4669 mock service calls via functions (#879)

src/services/__tests__/__snapshots__/config.test.js.snap

@@ -1,5 +1,16 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`ServiceConfig should allow passing a function and emulating a service call: function responses 1`] = `
+Array [
+  "lorem.ipsum",
+  "lorem.ipsum-function-schema-transform",
+  "lorem.ipsum-function-transform",
+  undefined,
+  "dolor.sit-error-transform",
+  "dolor.sit-error-transform",
+]
+`;
+
 exports[`ServiceConfig should handle caching service calls: cached responses, emulated 304 1`] = `
 Array [
   "1. method=get, status=200, desc=initial call",

src/services/__tests__/config.test.js

@@ -240,4 +240,80 @@ describe('ServiceConfig', () => {
 
     expect(responses).toMatchSnapshot('transformed responses');
   });
+
+  it('should allow passing a function and emulating a service call', async () => {
+    const responses = [];
+
+    // First, pass a regular function similar to any service call
+    const responseOne = await service.serviceCall({
+      cache: true,
+      url: () => 'lorem.ipsum'
+    });
+    responses.push(responseOne.data);
+
+    // Second, pass a function similar to any service call, schema transform
+    const responseTwo = await service.serviceCall({
+      cache: true,
+      url: () => Promise.resolve('lorem.ipsum'),
+      schema: [successResponse => `${successResponse}-function-schema-transform`]
+    });
+    responses.push(responseTwo.data);
+
+    // Third, pass a function similar to any service call, transform
+    const responseThree = await service.serviceCall({
+      cache: true,
+      url: () => Promise.resolve('lorem.ipsum'),
+      transform: [successResponse => `${successResponse}-function-transform`]
+    });
+    responses.push(responseThree.data);
+
+    // Fourth, use error
+    let responseFour;
+    try {
+      responseFour = await service.serviceCall({
+        cache: true,
+        url: () => Promise.reject(new Error('dolor.sit'))
+      });
+    } catch (e) {
+      responseFour = e.response || e;
+    }
+
+    responses.push(responseFour.data);
+
+    // Fifth, use reject error with transform
+    let responseFive;
+    try {
+      responseFive = await service.serviceCall({
+        cache: true,
+        url: () => Promise.reject(new Error('dolor.sit')),
+        transform: [
+          successResponse => `${successResponse}-transform`,
+          errorResponse => `${errorResponse}-error-transform`
+        ]
+      });
+    } catch (e) {
+      responseFive = e.response || e;
+    }
+
+    responses.push(responseFive.data);
+
+    // Sixth, use reject string with transform
+    let responseSix;
+    try {
+      responseSix = await service.serviceCall({
+        cache: true,
+        url: () => Promise.reject('dolor.sit'), // eslint-disable-line
+        transform: [
+          successResponse => `${successResponse}-transform`,
+          errorResponse => `${errorResponse}-error-transform`
+        ]
+      });
+    } catch (e) {
+      responseSix = e.response || e;
+    }
+
+    responses.push(responseSix.data);
+
+    expect(responses).toMatchSnapshot('function responses');
+  });
 });

src/services/config.js

@@ -145,19 +145,19 @@ const serviceCall = async config => {
 
     if (errorTransform) {
       transformers[1] = response => {
-        const updatedResponse = { ...response };
+        const updatedResponse = { ...(response.response || response) };
 
         if (updatedResponse?.message === cancelledMessage) {
           return Promise.reject(updatedResponse);
         }
 
         const { data, error: normalizeError } = serviceHelpers.passDataToCallback(
-          updatedResponse?.response?.data,
+          updatedResponse?.data || updatedResponse?.message,
           errorTransform
         );
 
         if (!normalizeError) {
-          updatedResponse.response = { ...updatedResponse.response, data };
+          updatedResponse.response = { ...updatedResponse, data };
         }
 
         return Promise.reject(updatedResponse);
@@ -178,6 +178,40 @@ const serviceCall = async config => {
     );
   }
 
+  if (typeof updatedConfig.url === 'function') {
+    const emulateCallback = updatedConfig.url;
+    updatedConfig.url = '/';
+
+    let message = `success, emulated`;
+    let emulatedResponse;
+    let isSuccess = true;
+
+    try {
+      emulatedResponse = await emulateCallback();
+    } catch (e) {
+      isSuccess = false;
+      message = e.message || e;
+    }
+
+    if (isSuccess) {
+      updatedConfig.adapter = adapterConfig =>
+        Promise.resolve({
+          data: emulatedResponse,
+          status: 200,
+          statusText: message,
+          config: adapterConfig
+        });
+    } else {
+      updatedConfig.adapter = adapterConfig =>
+        Promise.reject({ // eslint-disable-line
+          ...new Error(message),
+          message,
+          status: 418,
+          config: adapterConfig
+        });
+    }
+  }
+
   return axiosInstance(serviceConfig(updatedConfig));
 };