[ILM] Policy form should not throw away data

x-pack/plugins/index_lifecycle_management/__jest__/client_integration/edit_policy/constants.ts

@@ -195,3 +195,41 @@ export const POLICY_WITH_NODE_ROLE_ALLOCATION: PolicyFromES = {
   },
   name: POLICY_NAME,
 };
+
+export const POLICY_WITH_KNOWN_AND_UNKNOWN_FIELDS = ({
+  version: 1,
+  modified_date: Date.now().toString(),
+  policy: {
+    foo: 'bar',
+    phases: {
+      hot: {
+        min_age: '0ms',
+        actions: {
+          rollover: {
+            unknown_setting: 123,
+            max_size: '50gb',
+          },
+        },
+      },
+      warm: {
+        actions: {
+          my_unfollow_action: {},
+          set_priority: {
+            priority: 22,
+            unknown_setting: true,
+          },
+        },
+      },
+      delete: {
+        wait_for_snapshot: {
+          policy: SNAPSHOT_POLICY_NAME,
+        },
+        delete: {
+          delete_searchable_snapshot: true,
+        },
+      },
+    },
+    name: POLICY_NAME,
+  },
+  name: POLICY_NAME,
+} as any) as PolicyFromES;

x-pack/plugins/index_lifecycle_management/__jest__/client_integration/edit_policy/edit_policy.test.ts

@@ -19,6 +19,7 @@ import {
   POLICY_WITH_INCLUDE_EXCLUDE,
   POLICY_WITH_NODE_ATTR_AND_OFF_ALLOCATION,
   POLICY_WITH_NODE_ROLE_ALLOCATION,
+  POLICY_WITH_KNOWN_AND_UNKNOWN_FIELDS,
   getDefaultHotPhasePolicy,
 } from './constants';
 
@@ -31,6 +32,70 @@ describe('<EditPolicy />', () => {
     server.restore();
   });
 
+  describe('serialization', () => {
+    /**
+     * We assume that policies that populate this form are loaded directly from ES and so
+     * are valid according to ES. There may be settings in the policy created through the ILM
+     * API that the UI does not cater for, like the unfollow action. We do not want to overwrite
+     * the configuration for these actions in the UI.
+     */
+    it('preserves policy settings it did not configure', async () => {
+      httpRequestsMockHelpers.setLoadPolicies([POLICY_WITH_KNOWN_AND_UNKNOWN_FIELDS]);
+      httpRequestsMockHelpers.setLoadSnapshotPolicies([]);
+      httpRequestsMockHelpers.setListNodes({
+        nodesByRoles: {},
+        nodesByAttributes: { test: ['123'] },
+        isUsingDeprecatedDataRoleConfig: false,
+      });
+
+      await act(async () => {
+        testBed = await setup();
+      });
+
+      const { component, actions } = testBed;
+      component.update();
+
+      // Set max docs to test whether we keep the unknown fields in that object after serializing
+      await actions.hot.setMaxDocs('1000');
+      // Remove the delete phase to ensure that we also correctly remove data
+      await actions.delete.enable(false);
+      await actions.savePolicy();
+
+      const latestRequest = server.requests[server.requests.length - 1];
+      const entirePolicy = JSON.parse(JSON.parse(latestRequest.requestBody).body);
+
+      expect(entirePolicy).toEqual({
+        foo: 'bar', // Made up value
+        name: 'my_policy',
+        phases: {
+          hot: {
+            actions: {
+              rollover: {
+                max_docs: 1000,
+                max_size: '50gb',
+                unknown_setting: 123, // Made up setting that should stay preserved
+              },
+              set_priority: {
+                priority: 100,
+              },
+            },
+            min_age: '0ms',
+          },
+          warm: {
+            actions: {
+              my_unfollow_action: {}, // Made up action
+              set_priority: {
+                priority: 22,
+                unknown_setting: true,
+              },
+            },
+            min_age: '0ms',
+          },
+        },
+      });
+    });
+  });
+
   describe('hot phase', () => {
     describe('serialization', () => {
       beforeEach(async () => {

x-pack/plugins/index_lifecycle_management/__jest__/components/edit_policy.test.tsx

@@ -298,12 +298,12 @@ describe('edit policy', () => {
             phases: {
               hot: {
                 actions: {
-                  set_priority: {
-                    priority: 100,
-                  },
                   rollover: {
-                    max_size: '50gb',
                     max_age: '30d',
+                    max_size: '50gb',
+                  },
+                  set_priority: {
+                    priority: 100,
                   },
                 },
                 min_age: '0ms',

x-pack/plugins/index_lifecycle_management/public/application/sections/edit_policy/form/deserializer_and_serializer.test.ts

@@ -0,0 +1,88 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+import { cloneDeep, set } from 'lodash';
+import { SerializedPolicy } from '../../../../../common/types';
+import { deserializer } from './deserializer';
+import { createSerializer } from './serializer';
+
+describe('deserializer and serializer', () => {
+  it('preserves unknown policy settings', () => {
+    const originalPolicy: SerializedPolicy = {
+      name: 'test',
+      phases: {
+        hot: {
+          actions: {
+            rollover: {
+              max_age: '1d',
+              max_size: '10gb',
+              max_docs: 1000,
+            },
+            forcemerge: {
+              index_codec: 'best_compression',
+              max_num_segments: 22,
+            },
+          },
+          min_age: '12ms',
+        },
+        warm: {
+          actions: {
+            shrink: { number_of_shards: 12 },
+            allocate: {
+              number_of_replicas: 3,
+            },
+            set_priority: {
+              priority: 10,
+            },
+          },
+        },
+        cold: {
+          actions: {
+            allocate: { number_of_replicas: 12 },
+            freeze: {},
+            set_priority: {
+              priority: 12,
+            },
+          },
+        },
+        delete: {
+          actions: {
+            delete: {
+              delete_searchable_snapshot: true,
+            },
+            wait_for_snapshot: {
+              policy: 'test',
+            },
+          },
+        },
+      },
+    };
+
+    /**
+     * Next we insert unknown values at various places in the policy object
+     * where we know they may occur.
+     */
+    [
+      '',
+      'phases.hot.actions',
+      'phases.hot.actions.rollover',
+      'phases.warm.actions',
+      'phases.warm.actions.forcemerge',
+      'phases.cold.actions',
+      'phases.delete.actions',
+    ].forEach((path) => {
+      set(originalPolicy, path, { unknown: 'value' });
+    });
+
+    const copyOfOriginalPolicy = cloneDeep(originalPolicy);
+    const formInternal = deserializer(copyOfOriginalPolicy);
+    const serializer = createSerializer(copyOfOriginalPolicy);
+
+    expect(serializer(formInternal)).toEqual(originalPolicy);
+
+    // Assert that the original policy is unaltered after deserialization and serialization
+    expect(originalPolicy).toEqual(copyOfOriginalPolicy);
+  });
+});

x-pack/plugins/index_lifecycle_management/public/application/sections/edit_policy/form/schema.ts

@@ -23,7 +23,7 @@ import { i18nTexts } from '../i18n_texts';
 const { emptyField, numberGreaterThanField } = fieldValidators;
 
 const serializers = {
-  stringToNumber: (v: string): any => (v ? parseInt(v, 10) : undefined),
+  stringToNumber: (v: string): any => (v != null ? parseInt(v, 10) : undefined),
 };
 
 export const schema: FormSchema<FormInternal> = {