[Security Solution] Adds diff algorithm and unit tests for scalar array values

x-pack/plugins/security_solution/server/lib/detection_engine/prebuilt_rules/logic/diff/calculation/algorithms/index.ts

@@ -7,4 +7,5 @@
 
 export { numberDiffAlgorithm } from './number_diff_algorithm';
 export { singleLineStringDiffAlgorithm } from './single_line_string_diff_algorithm';
+export { scalarArrayDiffAlgorithm } from './scalar_array_diff_algorithm';
 export { simpleDiffAlgorithm } from './simple_diff_algorithm';

x-pack/plugins/security_solution/server/lib/detection_engine/prebuilt_rules/logic/diff/calculation/algorithms/scalar_array_diff_algorithm.test.ts

@@ -0,0 +1,152 @@
+/*
+ * 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 type { ThreeVersionsOf } from '../../../../../../../../common/api/detection_engine';
+import {
+  ThreeWayDiffOutcome,
+  ThreeWayMergeOutcome,
+  MissingVersion,
+} from '../../../../../../../../common/api/detection_engine';
+import { scalarArrayDiffAlgorithm } from './scalar_array_diff_algorithm';
+
+describe('scalarArrayDiffAlgorithm', () => {
+  it('returns current_version as merged output if there is no update', () => {
+    const mockVersions: ThreeVersionsOf<string[]> = {
+      base_version: ['A'],
+      current_version: ['A'],
+      target_version: ['A'],
+    };
+
+    const result = scalarArrayDiffAlgorithm(mockVersions);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        merged_version: mockVersions.current_version,
+        diff_outcome: ThreeWayDiffOutcome.StockValueNoUpdate,
+        merge_outcome: ThreeWayMergeOutcome.Current,
+        has_conflict: false,
+      })
+    );
+  });
+
+  it('returns current_version as merged output if current_version is different and there is no update', () => {
+    const mockVersions: ThreeVersionsOf<string[]> = {
+      base_version: ['A'],
+      current_version: ['B'],
+      target_version: ['A'],
+    };
+
+    const result = scalarArrayDiffAlgorithm(mockVersions);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        merged_version: mockVersions.current_version,
+        diff_outcome: ThreeWayDiffOutcome.CustomizedValueNoUpdate,
+        merge_outcome: ThreeWayMergeOutcome.Current,
+        has_conflict: false,
+      })
+    );
+  });
+
+  it('returns target_version as merged output if current_version is the same and there is an update', () => {
+    const mockVersions: ThreeVersionsOf<string[]> = {
+      base_version: ['A'],
+      current_version: ['A'],
+      target_version: ['B'],
+    };
+
+    const result = scalarArrayDiffAlgorithm(mockVersions);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        merged_version: mockVersions.target_version,
+        diff_outcome: ThreeWayDiffOutcome.StockValueCanUpdate,
+        merge_outcome: ThreeWayMergeOutcome.Target,
+        has_conflict: false,
+      })
+    );
+  });
+
+  it('returns current_version as merged output if current version is different but it matches the update', () => {
+    const mockVersions: ThreeVersionsOf<string[]> = {
+      base_version: ['A'],
+      current_version: ['B'],
+      target_version: ['B'],
+    };
+
+    const result = scalarArrayDiffAlgorithm(mockVersions);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        merged_version: mockVersions.current_version,
+        diff_outcome: ThreeWayDiffOutcome.CustomizedValueSameUpdate,
+        merge_outcome: ThreeWayMergeOutcome.Current,
+        has_conflict: false,
+      })
+    );
+  });
+
+  it('returns custom merged version as merged output if all three versions are different', () => {
+    const mockVersions: ThreeVersionsOf<string[]> = {
+      base_version: ['A'],
+      current_version: ['B', 'C'],
+      target_version: ['C', 'D'],
+    };
+    const expectedMergedVersion = ['B', 'C', 'D'];
+
+    const result = scalarArrayDiffAlgorithm(mockVersions);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        merged_version: expectedMergedVersion,
+        diff_outcome: ThreeWayDiffOutcome.CustomizedValueCanUpdate,
+        merge_outcome: ThreeWayMergeOutcome.Merged,
+        has_conflict: false,
+      })
+    );
+  });
+
+  describe('if base_version is missing', () => {
+    it('returns current_version as merged output if current_version and target_version are the same', () => {
+      const mockVersions: ThreeVersionsOf<string[]> = {
+        base_version: MissingVersion,
+        current_version: ['A'],
+        target_version: ['A'],
+      };
+
+      const result = scalarArrayDiffAlgorithm(mockVersions);
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          merged_version: mockVersions.current_version,
+          diff_outcome: ThreeWayDiffOutcome.StockValueNoUpdate,
+          merge_outcome: ThreeWayMergeOutcome.Current,
+          has_conflict: false,
+        })
+      );
+    });
+
+    it('returns target_version as merged output if current_version and target_version are different', () => {
+      const mockVersions: ThreeVersionsOf<string[]> = {
+        base_version: MissingVersion,
+        current_version: ['A'],
+        target_version: ['B'],
+      };
+
+      const result = scalarArrayDiffAlgorithm(mockVersions);
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          merged_version: mockVersions.target_version,
+          diff_outcome: ThreeWayDiffOutcome.StockValueCanUpdate,
+          merge_outcome: ThreeWayMergeOutcome.Target,
+          has_conflict: false,
+        })
+      );
+    });
+  });
+});

x-pack/plugins/security_solution/server/lib/detection_engine/prebuilt_rules/logic/diff/calculation/algorithms/scalar_array_diff_algorithm.ts

@@ -0,0 +1,116 @@
+/*
+ * 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 { difference, union } from 'lodash';
+import { assertUnreachable } from '../../../../../../../../common/utility_types';
+import type {
+  ThreeVersionsOf,
+  ThreeWayDiff,
+} from '../../../../../../../../common/api/detection_engine/prebuilt_rules';
+import {
+  determineDiffOutcome,
+  determineIfValueCanUpdate,
+  ThreeWayDiffOutcome,
+  ThreeWayMergeOutcome,
+  MissingVersion,
+} from '../../../../../../../../common/api/detection_engine/prebuilt_rules';
+
+export type ScalarArrayDiffAlgorithmType = string[]; // We currently don't have any fields that use any other types than strings
+
+export const scalarArrayDiffAlgorithm = (
+  versions: ThreeVersionsOf<ScalarArrayDiffAlgorithmType>
+): ThreeWayDiff<ScalarArrayDiffAlgorithmType> => {
+  const {
+    base_version: baseVersion,
+    current_version: currentVersion,
+    target_version: targetVersion,
+  } = versions;
+
+  const diffOutcome = determineDiffOutcome(baseVersion, currentVersion, targetVersion);
+  const valueCanUpdate = determineIfValueCanUpdate(diffOutcome);
+
+  const { mergeOutcome, mergedVersion } = mergeVersions({
+    baseVersion,
+    currentVersion,
+    targetVersion,
+    diffOutcome,
+  });
+
+  return {
+    base_version: baseVersion,
+    current_version: currentVersion,
+    target_version: targetVersion,
+    merged_version: mergedVersion,
+
+    diff_outcome: diffOutcome,
+    merge_outcome: mergeOutcome,
+    has_update: valueCanUpdate,
+    has_conflict: mergeOutcome === ThreeWayMergeOutcome.Conflict,
+  };
+};
+
+interface MergeResult<TValue> {
+  mergeOutcome: ThreeWayMergeOutcome;
+  mergedVersion: TValue;
+}
+
+interface MergeArgs<TValue> {
+  baseVersion: TValue | MissingVersion;
+  currentVersion: TValue;
+  targetVersion: TValue;
+  diffOutcome: ThreeWayDiffOutcome;
+}
+
+const mergeVersions = ({
+  baseVersion,
+  currentVersion,
+  targetVersion,
+  diffOutcome,
+}: MergeArgs<ScalarArrayDiffAlgorithmType>): MergeResult<ScalarArrayDiffAlgorithmType> => {
+  switch (diffOutcome) {
+    case ThreeWayDiffOutcome.StockValueNoUpdate:
+    case ThreeWayDiffOutcome.CustomizedValueNoUpdate:
+    case ThreeWayDiffOutcome.CustomizedValueSameUpdate: {
+      return {
+        mergeOutcome: ThreeWayMergeOutcome.Current,
+        mergedVersion: currentVersion,
+      };
+    }
+    case ThreeWayDiffOutcome.StockValueCanUpdate: {
+      return {
+        mergeOutcome: ThreeWayMergeOutcome.Target,
+        mergedVersion: targetVersion,
+      };
+    }
+    case ThreeWayDiffOutcome.CustomizedValueCanUpdate: {
+      if (baseVersion === MissingVersion) {
+        return {
+          mergeOutcome: ThreeWayMergeOutcome.Merged,
+          mergedVersion: union(currentVersion, targetVersion),
+        };
+      }
+
+      const addedCurrent = difference(currentVersion, baseVersion);
+      const removedCurrent = difference(baseVersion, currentVersion);
+
+      const addedTarget = difference(targetVersion, baseVersion);
+      const removedTarget = difference(baseVersion, targetVersion);
+
+      const bothAdded = union(addedCurrent, addedTarget);
+      const bothRemoved = union(removedCurrent, removedTarget);
+
+      const merged = difference(union(baseVersion, bothAdded), bothRemoved);
+
+      return {
+        mergeOutcome: ThreeWayMergeOutcome.Merged,
+        mergedVersion: merged,
+      };
+    }
+    default:
+      return assertUnreachable(diffOutcome);
+  }
+};