Update /api/workplace_search/overview endpoint to use new request handler

Author: cee-chen

x-pack/plugins/enterprise_search/server/routes/workplace_search/overview.test.ts

@@ -4,127 +4,51 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import { MockRouter, mockConfig, mockLogger } from '../../__mocks__';
+import { MockRouter, mockRequestHandler, mockDependencies } from '../../__mocks__';
 
 import { registerWSOverviewRoute } from './overview';
 
-jest.mock('node-fetch');
-const fetch = jest.requireActual('node-fetch');
-const { Response } = fetch;
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const fetchMock = require('node-fetch') as jest.Mocked<typeof fetch>;
-
-const ORG_ROUTE = 'http://localhost:3002/ws/org';
-
-describe('engine routes', () => {
+describe('Overview route', () => {
   describe('GET /api/workplace_search/overview', () => {
-    const AUTH_HEADER = 'Basic 123';
-    const mockRequest = {
-      headers: {
-        authorization: AUTH_HEADER,
-      },
-      query: {},
-    };
-
-    const mockRouter = new MockRouter({ method: 'get', payload: 'query' });
+    let mockRouter: MockRouter;
 
     beforeEach(() => {
       jest.clearAllMocks();
-      mockRouter.createRouter();
+      mockRouter = new MockRouter({ method: 'get', payload: 'query' });
 
       registerWSOverviewRoute({
+        ...mockDependencies,
         router: mockRouter.router,
-        log: mockLogger,
-        config: mockConfig,
       });
     });
 
-    describe('when the underlying Workplace Search API returns a 200', () => {
-      beforeEach(() => {
-        WorkplaceSearchAPI.shouldBeCalledWith(ORG_ROUTE, {
-          headers: { Authorization: AUTH_HEADER },
-        }).andReturn({ accountsCount: 1 });
-      });
-
-      it('should return 200 with a list of overview from the Workplace Search API', async () => {
-        await mockRouter.callRoute(mockRequest);
-
-        expect(mockRouter.response.ok).toHaveBeenCalledWith({
-          body: { accountsCount: 1 },
-          headers: { 'content-type': 'application/json' },
-        });
+    it('creates a request handler', () => {
+      expect(mockRequestHandler.createRequest).toHaveBeenCalledWith({
+        path: '/ws/org',
+        hasValidData: expect.any(Function),
       });
     });
 
-    describe('when the Workplace Search URL is invalid', () => {
-      beforeEach(() => {
-        WorkplaceSearchAPI.shouldBeCalledWith(ORG_ROUTE, {
-          headers: { Authorization: AUTH_HEADER },
-        }).andReturnError();
-      });
+    describe('hasValidData', () => {
+      it('should correctly validate that the response has data', () => {
+        const response = {
+          accountsCount: 1,
+        };
 
-      it('should return 502 with a message', async () => {
-        await mockRouter.callRoute(mockRequest);
+        const { hasValidData } = mockRequestHandler.createRequest.mock.calls[0][0];
 
-        expect(mockRouter.response.customError).toHaveBeenCalledWith({
-          statusCode: 502,
-          body: 'cannot-connect',
-        });
-        expect(mockLogger.error).toHaveBeenCalledWith('Cannot connect to Workplace Search: Failed');
-        expect(mockLogger.debug).not.toHaveBeenCalled();
+        expect(hasValidData(response)).toBe(true);
       });
-    });
 
-    describe('when the Workplace Search API returns invalid data', () => {
-      beforeEach(() => {
-        WorkplaceSearchAPI.shouldBeCalledWith(ORG_ROUTE, {
-          headers: { Authorization: AUTH_HEADER },
-        }).andReturnInvalidData();
-      });
+      it('should correctly validate that a response does not have data', () => {
+        const response = {
+          foo: 'bar',
+        };
 
-      it('should return 502 with a message', async () => {
-        await mockRouter.callRoute(mockRequest);
+        const hasValidData = mockRequestHandler.createRequest.mock.calls[0][0].hasValidData;
 
-        expect(mockRouter.response.customError).toHaveBeenCalledWith({
-          statusCode: 502,
-          body: 'cannot-connect',
-        });
-        expect(mockLogger.error).toHaveBeenCalledWith(
-          'Cannot connect to Workplace Search: Error: Invalid data received from Workplace Search: {"foo":"bar"}'
-        );
-        expect(mockLogger.debug).toHaveBeenCalled();
+        expect(hasValidData(response)).toBe(false);
       });
     });
-
-    const WorkplaceSearchAPI = {
-      shouldBeCalledWith(expectedUrl: string, expectedParams: object) {
-        return {
-          andReturn(response: object) {
-            fetchMock.mockImplementation((url: string, params: object) => {
-              expect(url).toEqual(expectedUrl);
-              expect(params).toEqual(expectedParams);
-
-              return Promise.resolve(new Response(JSON.stringify(response)));
-            });
-          },
-          andReturnInvalidData() {
-            fetchMock.mockImplementation((url: string, params: object) => {
-              expect(url).toEqual(expectedUrl);
-              expect(params).toEqual(expectedParams);
-
-              return Promise.resolve(new Response(JSON.stringify({ foo: 'bar' })));
-            });
-          },
-          andReturnError() {
-            fetchMock.mockImplementation((url: string, params: object) => {
-              expect(url).toEqual(expectedUrl);
-              expect(params).toEqual(expectedParams);
-
-              return Promise.reject('Failed');
-            });
-          },
-        };
-      },
-    };
   });
 });

x-pack/plugins/enterprise_search/server/routes/workplace_search/overview.ts

@@ -4,43 +4,20 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import fetch from 'node-fetch';
-
 import { IRouteDependencies } from '../../plugin';
 
-export function registerWSOverviewRoute({ router, config, log }: IRouteDependencies) {
+export function registerWSOverviewRoute({
+  router,
+  enterpriseSearchRequestHandler,
+}: IRouteDependencies) {
   router.get(
     {
       path: '/api/workplace_search/overview',
       validate: false,
     },
-    async (context, request, response) => {
-      try {
-        const entSearchUrl = config.host as string;
-        const url = `${encodeURI(entSearchUrl)}/ws/org`;
-
-        const overviewResponse = await fetch(url, {
-          headers: { Authorization: request.headers.authorization as string },
-        });
-
-        const body = await overviewResponse.json();
-        const hasValidData = typeof body?.accountsCount === 'number';
-
-        if (hasValidData) {
-          return response.ok({
-            body,
-            headers: { 'content-type': 'application/json' },
-          });
-        } else {
-          // Either a completely incorrect Enterprise Search host URL was configured, or Workplace Search is returning bad data
-          throw new Error(`Invalid data received from Workplace Search: ${JSON.stringify(body)}`);
-        }
-      } catch (e) {
-        log.error(`Cannot connect to Workplace Search: ${e.toString()}`);
-        if (e instanceof Error) log.debug(e.stack as string);
-
-        return response.customError({ statusCode: 502, body: 'cannot-connect' });
-      }
-    }
+    enterpriseSearchRequestHandler.createRequest({
+      path: '/ws/org',
+      hasValidData: (body: { accountsCount: number }) => typeof body?.accountsCount === 'number',
+    })
   );
 }