[Secuity Solution][DQD] add historical results (Phase 1)

x-pack/packages/security-solution/ecs_data_quality_dashboard/impl/data_quality_panel/data_quality_details/indices_details/pattern/constants.ts

@@ -6,3 +6,6 @@
  */
 
 export const MIN_PAGE_SIZE = 10;
+
+export const HISTORY_TAB_ID = 'history';
+export const LATEST_CHECK_TAB_ID = 'latest_check';

x-pack/packages/security-solution/ecs_data_quality_dashboard/impl/data_quality_panel/data_quality_details/indices_details/pattern/contexts/historical_results_context/index.tsx

@@ -0,0 +1,21 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { createContext, useContext } from 'react';
+import { HistoricalResultsValue } from './types';
+
+export const HistoricalResultsContext = createContext<HistoricalResultsValue | null>(null);
+
+export const useHistoricalResultsContext = () => {
+  const context = useContext(HistoricalResultsContext);
+  if (context == null) {
+    throw new Error(
+      'useHistoricalResultsContext must be used inside the HistoricalResultsContextProvider.'
+    );
+  }
+  return context;
+};

x-pack/packages/security-solution/ecs_data_quality_dashboard/impl/data_quality_panel/data_quality_details/indices_details/pattern/contexts/historical_results_context/types.ts

@@ -0,0 +1,19 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { HistoricalResult } from '../../../../../types';
+import { UseHistoricalResultsFetch } from '../../index_check_flyout/types';
+
+export interface HistoricalResultsValue {
+  historicalResultsState: {
+    results: HistoricalResult[];
+    total: number;
+    isLoading: boolean;
+    error: Error | null;
+  };
+  fetchHistoricalResults: UseHistoricalResultsFetch;
+}

x-pack/packages/security-solution/ecs_data_quality_dashboard/impl/data_quality_panel/data_quality_details/indices_details/pattern/index_check_flyout/index_properties/index_check_fields/constants.ts → x-pack/packages/security-solution/ecs_data_quality_dashboard/impl/data_quality_panel/data_quality_details/indices_details/pattern/hooks/use_historical_results/constants.ts

@@ -5,8 +5,4 @@
  * 2.0.
  */
 
-export const ALL_TAB_ID = 'allTab';
-export const ECS_COMPLIANT_TAB_ID = 'ecsCompliantTab';
-export const CUSTOM_TAB_ID = 'customTab';
-export const INCOMPATIBLE_TAB_ID = 'incompatibleTab';
-export const SAME_FAMILY_TAB_ID = 'sameFamilyTab';
+export const GET_INDEX_RESULTS = '/internal/ecs_data_quality_dashboard/results/{indexName}';

x-pack/packages/security-solution/ecs_data_quality_dashboard/impl/data_quality_panel/data_quality_details/indices_details/pattern/hooks/use_historical_results/index.test.tsx

@@ -0,0 +1,158 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { act, renderHook } from '@testing-library/react-hooks';
+
+import { mockHistoricalResult } from '../../../../../mock/historical_results/mock_historical_results_response';
+import { TestDataQualityProviders } from '../../../../../mock/test_providers/test_providers';
+import * as fetchHistoricalResults from './utils/fetch_historical_results';
+import { useHistoricalResults } from '.';
+
+describe('useHistoricalResults', () => {
+  beforeEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should return initial historical results state and fetch historical results function', () => {
+    const { result } = renderHook(() => useHistoricalResults(), {
+      wrapper: TestDataQualityProviders,
+    });
+
+    expect(result.current.historicalResultsState).toEqual({
+      results: [],
+      total: 0,
+      isLoading: true,
+      error: null,
+    });
+
+    expect(result.current.fetchHistoricalResults).toBeInstanceOf(Function);
+  });
+
+  describe('when fetchHistoricalResults is called', () => {
+    it('should fetch historical results and update historical results state', async () => {
+      const fetchResultsSpy = jest
+        .spyOn(fetchHistoricalResults, 'fetchHistoricalResults')
+        .mockResolvedValue({
+          results: [mockHistoricalResult],
+          total: 1,
+        });
+
+      const { result } = renderHook(() => useHistoricalResults(), {
+        wrapper: TestDataQualityProviders,
+      });
+
+      const abortController = new AbortController();
+
+      await act(() =>
+        result.current.fetchHistoricalResults({
+          abortController,
+          indexName: 'indexName',
+          size: 10,
+          from: 0,
+          startDate: 'now-7d',
+          endDate: 'now',
+          outcome: 'pass',
+        })
+      );
+
+      expect(fetchResultsSpy).toHaveBeenCalledWith({
+        indexName: 'indexName',
+        httpFetch: expect.any(Function),
+        abortController,
+        size: 10,
+        from: 0,
+        startDate: 'now-7d',
+        endDate: 'now',
+        outcome: 'pass',
+      });
+
+      expect(result.current.historicalResultsState).toEqual({
+        results: [mockHistoricalResult],
+        total: 1,
+        isLoading: false,
+        error: null,
+      });
+    });
+  });
+
+  describe('when fetchHistoricalResults fails', () => {
+    it('should update historical results state with error', async () => {
+      const fetchResultsSpy = jest
+        .spyOn(fetchHistoricalResults, 'fetchHistoricalResults')
+        .mockRejectedValue(new Error('An error occurred'));
+
+      const { result } = renderHook(() => useHistoricalResults(), {
+        wrapper: TestDataQualityProviders,
+      });
+
+      const abortController = new AbortController();
+
+      await act(() =>
+        result.current.fetchHistoricalResults({
+          abortController,
+          indexName: 'indexName',
+          size: 10,
+          from: 0,
+          startDate: 'now-7d',
+          endDate: 'now',
+          outcome: 'pass',
+        })
+      );
+
+      expect(fetchResultsSpy).toHaveBeenCalledWith({
+        indexName: 'indexName',
+        httpFetch: expect.any(Function),
+        abortController,
+        size: 10,
+        from: 0,
+        startDate: 'now-7d',
+        endDate: 'now',
+        outcome: 'pass',
+      });
+
+      expect(result.current.historicalResultsState).toEqual({
+        results: [],
+        total: 0,
+        isLoading: false,
+        error: new Error('An error occurred'),
+      });
+    });
+  });
+
+  describe('during fetchHistoricalResults call', () => {
+    it('should set isLoading to true', async () => {
+      jest.spyOn(fetchHistoricalResults, 'fetchHistoricalResults').mockImplementation(() => {
+        return new Promise(() => {});
+      });
+
+      const { result } = renderHook(() => useHistoricalResults(), {
+        wrapper: TestDataQualityProviders,
+      });
+
+      const abortController = new AbortController();
+
+      act(() => {
+        result.current.fetchHistoricalResults({
+          abortController,
+          indexName: 'indexName',
+          size: 10,
+          from: 0,
+          startDate: 'now-7d',
+          endDate: 'now',
+          outcome: 'pass',
+        });
+      });
+
+      expect(result.current.historicalResultsState).toEqual({
+        results: [],
+        total: 0,
+        isLoading: true,
+        error: null,
+      });
+    });
+  });
+});

x-pack/packages/security-solution/ecs_data_quality_dashboard/impl/data_quality_panel/data_quality_details/indices_details/pattern/hooks/use_historical_results/index.tsx

@@ -0,0 +1,85 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { useReducer, useCallback } from 'react';
+
+import { GET_RESULTS_ERROR_TITLE } from '../../../../../translations';
+import { useDataQualityContext } from '../../../../../data_quality_context';
+import { useIsMountedRef } from '../../../../../hooks/use_is_mounted_ref';
+import { fetchHistoricalResults } from './utils/fetch_historical_results';
+import { FetchHistoricalResultsReducerState, UseHistoricalResultsReturnValue } from './types';
+import { UseHistoricalResultsFetchOpts } from '../../index_check_flyout/types';
+import { fetchHistoricalResultsReducer } from './reducers/fetch_historical_results_reducer';
+
+export const initialFetchHistoricalResultsReducerState: FetchHistoricalResultsReducerState = {
+  results: [],
+  total: 0,
+  isLoading: true,
+  error: null,
+};
+
+export const useHistoricalResults = (): UseHistoricalResultsReturnValue => {
+  const [state, dispatch] = useReducer(
+    fetchHistoricalResultsReducer,
+    initialFetchHistoricalResultsReducerState
+  );
+  const { httpFetch, toasts } = useDataQualityContext();
+  const { isMountedRef } = useIsMountedRef();
+
+  const fetchResults = useCallback(
+    async ({
+      abortController,
+      indexName,
+      size,
+      from,
+      startDate,
+      endDate,
+      outcome,
+    }: UseHistoricalResultsFetchOpts) => {
+      dispatch({ type: 'FETCH_START' });
+
+      try {
+        const { results, total } = await fetchHistoricalResults({
+          indexName,
+          httpFetch,
+          abortController,
+          size,
+          from,
+          startDate,
+          endDate,
+          outcome,
+        });
+
+        if (isMountedRef.current) {
+          dispatch({
+            type: 'FETCH_SUCCESS',
+            payload: {
+              results,
+              total,
+            },
+          });
+        }
+      } catch (error) {
+        if (isMountedRef.current) {
+          toasts.addError(error, { title: GET_RESULTS_ERROR_TITLE });
+          dispatch({ type: 'FETCH_ERROR', payload: error });
+        }
+      }
+    },
+    [dispatch, httpFetch, toasts, isMountedRef]
+  );
+
+  return {
+    historicalResultsState: {
+      results: state.results,
+      total: state.total,
+      isLoading: state.isLoading,
+      error: state.error,
+    },
+    fetchHistoricalResults: fetchResults,
+  };
+};

x-pack/packages/security-solution/ecs_data_quality_dashboard/impl/data_quality_panel/data_quality_details/indices_details/pattern/hooks/use_historical_results/reducers/fetch_historical_results_reducer.test.ts

@@ -0,0 +1,66 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { mockHistoricalResult } from '../../../../../../mock/historical_results/mock_historical_results_response';
+import { fetchHistoricalResultsReducer } from './fetch_historical_results_reducer';
+
+const getInitialState = () => ({
+  results: [],
+  total: 0,
+  isLoading: true,
+  error: null,
+});
+
+describe('fetchHistoricalResultsReducer', () => {
+  describe('on fetch start', () => {
+    it('should return initial state', () => {
+      expect(fetchHistoricalResultsReducer(getInitialState(), { type: 'FETCH_START' })).toEqual({
+        results: [],
+        total: 0,
+        isLoading: true,
+        error: null,
+      });
+    });
+  });
+
+  describe('on fetch success', () => {
+    it('should update state with fetched results', () => {
+      const results = [mockHistoricalResult];
+      const total = 1;
+
+      expect(
+        fetchHistoricalResultsReducer(getInitialState(), {
+          type: 'FETCH_SUCCESS',
+          payload: { results, total },
+        })
+      ).toEqual({
+        results,
+        total,
+        isLoading: false,
+        error: null,
+      });
+    });
+  });
+
+  describe('on fetch error', () => {
+    it('should update state with error', () => {
+      const error = new Error('An error occurred');
+
+      expect(
+        fetchHistoricalResultsReducer(getInitialState(), {
+          type: 'FETCH_ERROR',
+          payload: error,
+        })
+      ).toEqual({
+        results: [],
+        total: 0,
+        isLoading: false,
+        error,
+      });
+    });
+  });
+});