[Security Solution] Edit host isolation exception IP UI

x-pack/plugins/security_solution/public/management/pages/event_filters/store/middleware.ts

@@ -231,8 +231,8 @@ const refreshListDataIfNeeded: MiddlewareActionHandler = async (store, eventFilt
     dispatch({
       type: 'eventFiltersListPageDataChanged',
       payload: {
-        type: 'LoadingResourceState',
         // @ts-expect-error-next-line will be fixed with when AsyncResourceState is refactored (#830)
+        type: 'LoadingResourceState',
         previousState: getCurrentListPageDataState(state),
       },
     });

x-pack/plugins/security_solution/public/management/pages/host_isolation_exceptions/service.ts

@@ -9,6 +9,7 @@ import {
   CreateExceptionListItemSchema,
   ExceptionListItemSchema,
   FoundExceptionListItemSchema,
+  UpdateExceptionListItemSchema,
 } from '@kbn/securitysolution-io-ts-list-types';
 import { ENDPOINT_HOST_ISOLATION_EXCEPTIONS_LIST_ID } from '@kbn/securitysolution-list-constants';
 import { HttpStart } from 'kibana/public';
@@ -88,3 +89,26 @@ export async function deleteHostIsolationExceptionItems(http: HttpStart, id: str
     },
   });
 }
+
+export async function getOneHostIsolationExceptionItem(
+  http: HttpStart,
+  id: string
+): Promise<UpdateExceptionListItemSchema> {
+  await ensureHostIsolationExceptionsListExists(http);
+  return http.get<ExceptionListItemSchema>(EXCEPTION_LIST_ITEM_URL, {
+    query: {
+      id,
+      namespace_type: 'agnostic',
+    },
+  });
+}
+
+export async function updateOneHostIsolationExceptionItem(
+  http: HttpStart,
+  exception: UpdateExceptionListItemSchema
+): Promise<ExceptionListItemSchema> {
+  await ensureHostIsolationExceptionsListExists(http);
+  return http.put<ExceptionListItemSchema>(EXCEPTION_LIST_ITEM_URL, {
+    body: JSON.stringify(exception),
+  });
+}

x-pack/plugins/security_solution/public/management/pages/host_isolation_exceptions/store/action.ts

@@ -5,7 +5,10 @@
  * 2.0.
  */
 
-import { ExceptionListItemSchema } from '@kbn/securitysolution-io-ts-list-types';
+import {
+  ExceptionListItemSchema,
+  UpdateExceptionListItemSchema,
+} from '@kbn/securitysolution-io-ts-list-types';
 import { Action } from 'redux';
 import { HostIsolationExceptionsPageState } from '../types';
 
@@ -38,10 +41,24 @@ export type HostIsolationExceptionsDeleteStatusChanged =
   Action<'hostIsolationExceptionsDeleteStatusChanged'> & {
     payload: HostIsolationExceptionsPageState['deletion']['status'];
   };
+
+export type HostIsolationExceptionsMarkToEdit = Action<'hostIsolationExceptionsMarkToEdit'> & {
+  payload: {
+    id: string;
+  };
+};
+
+export type HostIsolationExceptionsSubmitEdit = Action<'hostIsolationExceptionsSubmitEdit'> & {
+  payload: UpdateExceptionListItemSchema;
+};
+
 export type HostIsolationExceptionsPageAction =
   | HostIsolationExceptionsPageDataChanged
   | HostIsolationExceptionsCreateEntry
   | HostIsolationExceptionsFormStateChanged
   | HostIsolationExceptionsDeleteItem
   | HostIsolationExceptionsSubmitDelete
-  | HostIsolationExceptionsDeleteStatusChanged;
+  | HostIsolationExceptionsDeleteStatusChanged
+  | HostIsolationExceptionsFormEntryChanged
+  | HostIsolationExceptionsMarkToEdit
+  | HostIsolationExceptionsSubmitEdit;

x-pack/plugins/security_solution/public/management/pages/host_isolation_exceptions/store/middleware.test.ts

@@ -5,7 +5,10 @@
  * 2.0.
  */
 
-import { CreateExceptionListItemSchema } from '@kbn/securitysolution-io-ts-list-types';
+import {
+  CreateExceptionListItemSchema,
+  UpdateEndpointListItemSchema,
+} from '@kbn/securitysolution-io-ts-list-types';
 import { applyMiddleware, createStore, Store } from 'redux';
 import { coreMock } from '../../../../../../../../src/core/public/mocks';
 import { getFoundExceptionListItemSchemaMock } from '../../../../../../lists/common/schemas/response/found_exception_list_item_schema.mock';
@@ -24,6 +27,8 @@ import {
   createHostIsolationExceptionItem,
   deleteHostIsolationExceptionItems,
   getHostIsolationExceptionItems,
+  getOneHostIsolationExceptionItem,
+  updateOneHostIsolationExceptionItem,
 } from '../service';
 import { HostIsolationExceptionsPageState } from '../types';
 import { createEmptyHostIsolationException } from '../utils';
@@ -36,6 +41,8 @@ jest.mock('../service');
 const getHostIsolationExceptionItemsMock = getHostIsolationExceptionItems as jest.Mock;
 const deleteHostIsolationExceptionItemsMock = deleteHostIsolationExceptionItems as jest.Mock;
 const createHostIsolationExceptionItemMock = createHostIsolationExceptionItem as jest.Mock;
+const getOneHostIsolationExceptionItemMock = getOneHostIsolationExceptionItem as jest.Mock;
+const updateOneHostIsolationExceptionItemMock = updateOneHostIsolationExceptionItem as jest.Mock;
 
 const fakeCoreStart = coreMock.createStart({ basePath: '/mock' });
 
@@ -170,6 +177,7 @@ describe('Host isolation exceptions middleware', () => {
         ],
       };
     });
+
     it('should dispatch a form loading state when an entry is submited', async () => {
       const waiter = spyMiddleware.waitForAction('hostIsolationExceptionsFormStateChanged', {
         validate({ payload }) {
@@ -182,6 +190,7 @@ describe('Host isolation exceptions middleware', () => {
       });
       await waiter;
     });
+
     it('should dispatch a form success state when an entry is confirmed by the API', async () => {
       const waiter = spyMiddleware.waitForAction('hostIsolationExceptionsFormStateChanged', {
         validate({ payload }) {
@@ -198,6 +207,7 @@ describe('Host isolation exceptions middleware', () => {
         exception: entry,
       });
     });
+
     it('should dispatch a form failure state when an entry is rejected by the API', async () => {
       createHostIsolationExceptionItemMock.mockRejectedValue({
         body: { message: 'error message', statusCode: 500, error: 'Not today' },
@@ -215,6 +225,101 @@ describe('Host isolation exceptions middleware', () => {
     });
   });
 
+  describe('When updating an item from host isolation exceptions', () => {
+    const fakeId = 'dc5d1d00-2766-11ec-981f-7f84cfc8764f';
+    let fakeException: UpdateEndpointListItemSchema;
+    beforeEach(() => {
+      fakeException = {
+        ...createEmptyHostIsolationException(),
+        name: 'name edit me',
+        description: 'initial description',
+        id: fakeId,
+        item_id: fakeId,
+        entries: [
+          {
+            field: 'destination.ip',
+            operator: 'included',
+            type: 'match',
+            value: '10.0.0.5',
+          },
+        ],
+      };
+      getOneHostIsolationExceptionItemMock.mockReset();
+      getOneHostIsolationExceptionItemMock.mockImplementation(async () => {
+        return fakeException;
+      });
+    });
+
+    it('should load data from an entry when an exception is marked to edit', async () => {
+      const waiter = spyMiddleware.waitForAction('hostIsolationExceptionsFormEntryChanged');
+      store.dispatch({
+        type: 'hostIsolationExceptionsMarkToEdit',
+        payload: {
+          id: fakeId,
+        },
+      });
+      await waiter;
+      expect(getOneHostIsolationExceptionItemMock).toHaveBeenCalledWith(fakeCoreStart.http, fakeId);
+    });
+
+    it('should call the update API when an item edit is submitted', async () => {
+      const waiter = Promise.all([
+        // loading status
+        spyMiddleware.waitForAction('hostIsolationExceptionsFormStateChanged', {
+          validate: ({ payload }) => {
+            return isLoadingResourceState(payload);
+          },
+        }),
+        // loaded status
+        spyMiddleware.waitForAction('hostIsolationExceptionsFormStateChanged', {
+          validate({ payload }) {
+            return isLoadedResourceState(payload);
+          },
+        }),
+      ]);
+      store.dispatch({
+        type: 'hostIsolationExceptionsSubmitEdit',
+        payload: fakeException,
+      });
+      expect(updateOneHostIsolationExceptionItemMock).toHaveBeenCalledWith(fakeCoreStart.http, {
+        name: 'name edit me',
+        description: 'initial description',
+        id: fakeId,
+        item_id: fakeId,
+        entries: [
+          {
+            field: 'destination.ip',
+            operator: 'included',
+            type: 'match',
+            value: '10.0.0.5',
+          },
+        ],
+        namespace_type: 'agnostic',
+        os_types: ['windows', 'linux', 'macos'],
+        tags: ['policy:all'],
+        type: 'simple',
+        comments: [],
+      });
+      await waiter;
+    });
+
+    it('should dispatch a form failure state when an entry is rejected by the API', async () => {
+      updateOneHostIsolationExceptionItemMock.mockRejectedValue({
+        body: { message: 'error message', statusCode: 500, error: 'Not today' },
+      });
+      const waiter = spyMiddleware.waitForAction('hostIsolationExceptionsFormStateChanged', {
+        validate({ payload }) {
+          return isFailedResourceState(payload);
+        },
+      });
+      store.dispatch({
+        type: 'hostIsolationExceptionsSubmitEdit',
+        payload: fakeException,
+      });
+      await waiter;
+    });
+  });
+
   describe('When deleting an item from host isolation exceptions', () => {
     beforeEach(() => {
       deleteHostIsolationExceptionItemsMock.mockReset();

x-pack/plugins/security_solution/public/management/pages/host_isolation_exceptions/store/middleware.ts

@@ -9,23 +9,27 @@ import {
   CreateExceptionListItemSchema,
   ExceptionListItemSchema,
   FoundExceptionListItemSchema,
+  UpdateExceptionListItemSchema,
 } from '@kbn/securitysolution-io-ts-list-types';
 import { CoreStart, HttpSetup, HttpStart } from 'kibana/public';
 import { matchPath } from 'react-router-dom';
-import { transformNewItemOutput } from '@kbn/securitysolution-list-hooks';
-import { AppLocation, Immutable } from '../../../../../common/endpoint/types';
+import { transformNewItemOutput, transformOutput } from '@kbn/securitysolution-list-hooks';
+import { AppLocation, Immutable, ImmutableObject } from '../../../../../common/endpoint/types';
 import { ImmutableMiddleware, ImmutableMiddlewareAPI } from '../../../../common/store';
 import { AppAction } from '../../../../common/store/actions';
 import { MANAGEMENT_ROUTING_HOST_ISOLATION_EXCEPTIONS_PATH } from '../../../common/constants';
 import { parseQueryFilterToKQL } from '../../../common/utils';
 import {
   createFailedResourceState,
   createLoadedResourceState,
+  createLoadingResourceState,
 } from '../../../state/async_resource_builders';
 import {
   deleteHostIsolationExceptionItems,
   getHostIsolationExceptionItems,
   createHostIsolationExceptionItem,
+  getOneHostIsolationExceptionItem,
+  updateOneHostIsolationExceptionItem,
 } from '../service';
 import { HostIsolationExceptionsPageState } from '../types';
 import { getCurrentListPageDataState, getCurrentLocation, getItemToDelete } from './selector';
@@ -53,6 +57,14 @@ export const createHostIsolationExceptionsPageMiddleware = (
     if (action.type === 'hostIsolationExceptionsSubmitDelete') {
       deleteHostIsolationExceptionsItem(store, coreStart.http);
     }
+
+    if (action.type === 'hostIsolationExceptionsMarkToEdit') {
+      loadHostIsolationExceptionsItem(store, coreStart.http, action.payload.id);
+    }
+
+    if (action.type === 'hostIsolationExceptionsSubmitEdit') {
+      updateHostIsolationExceptionsItem(store, coreStart.http, action.payload);
+    }
   };
 };
 
@@ -67,8 +79,8 @@ async function createHostIsolationException(
   dispatch({
     type: 'hostIsolationExceptionsFormStateChanged',
     payload: {
-      type: 'LoadingResourceState',
       // @ts-expect-error-next-line will be fixed with when AsyncResourceState is refactored (#830)
+      type: 'LoadingResourceState',
       previousState: entry,
     },
   });
@@ -110,8 +122,8 @@ async function loadHostIsolationExceptionsList(
     dispatch({
       type: 'hostIsolationExceptionsPageDataChanged',
       payload: {
-        type: 'LoadingResourceState',
         // @ts-expect-error-next-line will be fixed with when AsyncResourceState is refactored (#830)
+        type: 'LoadingResourceState',
         previousState: getCurrentListPageDataState(store.getState()),
       },
     });
@@ -152,8 +164,8 @@ async function deleteHostIsolationExceptionsItem(
     dispatch({
       type: 'hostIsolationExceptionsDeleteStatusChanged',
       payload: {
-        type: 'LoadingResourceState',
         // @ts-expect-error-next-line will be fixed with when AsyncResourceState is refactored (#830)
+        type: 'LoadingResourceState',
         previousState: store.getState().deletion.status,
       },
     });
@@ -172,3 +184,69 @@ async function deleteHostIsolationExceptionsItem(
     });
   }
 }
+
+async function loadHostIsolationExceptionsItem(
+  store: ImmutableMiddlewareAPI<HostIsolationExceptionsPageState, AppAction>,
+  http: HttpSetup,
+  id: string
+) {
+  const { dispatch } = store;
+  try {
+    const exception: UpdateExceptionListItemSchema = await getOneHostIsolationExceptionItem(
+      http,
+      id
+    );
+    dispatch({
+      type: 'hostIsolationExceptionsFormEntryChanged',
+      payload: exception,
+    });
+  } catch (error) {
+    dispatch({
+      type: 'hostIsolationExceptionsFormStateChanged',
+      payload: createFailedResourceState<ExceptionListItemSchema>(error.body ?? error),
+    });
+  }
+}
+async function updateHostIsolationExceptionsItem(
+  store: ImmutableMiddlewareAPI<HostIsolationExceptionsPageState, AppAction>,
+  http: HttpSetup,
+  exception: ImmutableObject<UpdateExceptionListItemSchema>
+) {
+  const { dispatch } = store;
+  dispatch({
+    type: 'hostIsolationExceptionsFormStateChanged',
+    payload: createLoadingResourceState(createLoadedResourceState(exception)),
+  });
+
+  try {
+    const entry = transformOutput(exception as UpdateExceptionListItemSchema);
+    // Clean unnecessary fields for update action
+    const fieldsToRemove: Array<keyof ExceptionListItemSchema> = [
+      'created_at',
+      'created_by',
+      'created_at',
+      'created_by',
+      'list_id',
+      'tie_breaker_id',
+      'updated_at',
+      'updated_by',
+    ];
+
+    fieldsToRemove.forEach((field) => {
+      delete entry[field as keyof UpdateExceptionListItemSchema];
+    });
+    const response: ExceptionListItemSchema = await updateOneHostIsolationExceptionItem(
+      http,
+      entry
+    );
+    dispatch({
+      type: 'hostIsolationExceptionsFormStateChanged',
+      payload: createLoadedResourceState(response),
+    });
+  } catch (error) {
+    dispatch({
+      type: 'hostIsolationExceptionsFormStateChanged',
+      payload: createFailedResourceState<ExceptionListItemSchema>(error.body ?? error),
+    });
+  }
+}

x-pack/plugins/security_solution/public/management/pages/host_isolation_exceptions/store/reducer.ts

@@ -56,6 +56,15 @@ export const hostIsolationExceptionsPageReducer: StateReducer = (
         },
       };
     }
+    case 'hostIsolationExceptionsFormEntryChanged': {
+      return {
+        ...state,
+        form: {
+          ...state.form,
+          entry: action.payload,
+        },
+      };
+    }
     case 'hostIsolationExceptionsPageDataChanged': {
       return {
         ...state,