[8.18] [ML] Adding tests for file upload merge tools (#209704) (#210026)

# Backport

This will backport the following commits from `main` to `8.18`:
- [[ML] Adding tests for file upload merge tools
(#209704)](#209704)

<!--- Backport version: 9.4.3 -->

### Questions ?
Please refer to the [Backport tool
documentation](https://github.com/sqren/backport)

<!--BACKPORT [{"author":{"name":"James
Gowdy","email":"[email protected]"},"sourceCommit":{"committedDate":"2025-02-06T14:53:14Z","message":"[ML]
Adding tests for file upload merge tools (#209704)\n\nAdding tests for
the merge tools utility
functions.","sha":"42def2d71bcbf5391280cf87ad72bba7b0a9c271","branchLabelMapping":{"^v9.1.0$":"main","^v8.19.0$":"8.x","^v(\\d+).(\\d+).\\d+$":"$1.$2"}},"sourcePullRequest":{"labels":[":ml","release_note:skip","test-coverage","v9.0.0","backport:version","v8.18.0","v9.1.0","v8.19.0"],"title":"[ML]
Adding tests for file upload merge
tools","number":209704,"url":"https://github.com/elastic/kibana/pull/209704","mergeCommit":{"message":"[ML]
Adding tests for file upload merge tools (#209704)\n\nAdding tests for
the merge tools utility
functions.","sha":"42def2d71bcbf5391280cf87ad72bba7b0a9c271"}},"sourceBranch":"main","suggestedTargetBranches":["9.0","8.18","8.x"],"targetPullRequestStates":[{"branch":"9.0","label":"v9.0.0","branchLabelMappingKey":"^v(\\d+).(\\d+).\\d+$","isSourceBranch":false,"state":"NOT_CREATED"},{"branch":"8.18","label":"v8.18.0","branchLabelMappingKey":"^v(\\d+).(\\d+).\\d+$","isSourceBranch":false,"state":"NOT_CREATED"},{"branch":"main","label":"v9.1.0","branchLabelMappingKey":"^v9.1.0$","isSourceBranch":true,"state":"MERGED","url":"https://github.com/elastic/kibana/pull/209704","number":209704,"mergeCommit":{"message":"[ML]
Adding tests for file upload merge tools (#209704)\n\nAdding tests for
the merge tools utility
functions.","sha":"42def2d71bcbf5391280cf87ad72bba7b0a9c271"}},{"branch":"8.x","label":"v8.19.0","branchLabelMappingKey":"^v8.19.0$","isSourceBranch":false,"state":"NOT_CREATED"}]}]
BACKPORT-->

Co-authored-by: James Gowdy <[email protected]>

Author: kibanamachine

x-pack/platform/plugins/private/data_visualizer/public/lite/file_manager/merge_tools.test.ts

@@ -0,0 +1,269 @@
+/*
+ * 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 {
+  createMergedMappings,
+  getMappingClashInfo,
+  getFormatClashes,
+  CLASH_TYPE,
+} from './merge_tools';
+import type { FileWrapper, FileAnalysis } from './file_wrapper';
+
+describe('merge_tools', () => {
+  describe('createMergedMappings', () => {
+    it('should return merged mappings when all mappings are the same', () => {
+      const files = [
+        {
+          getMappings: () => ({ properties: { field1: { type: 'text' } } }),
+        } as never as FileWrapper,
+        {
+          getMappings: () => ({ properties: { field1: { type: 'text' } } }),
+        } as never as FileWrapper,
+      ];
+
+      const result = createMergedMappings(files);
+      expect(result.mergedMappings).toEqual({ properties: { field1: { type: 'text' } } });
+      expect(result.mappingClashes).toEqual([]);
+    });
+
+    it('should return merged mappings when a keyword mapping is being merged with a text mapping', () => {
+      const files = [
+        {
+          getMappings: () => ({ properties: { field1: { type: 'text' } } }),
+        } as never as FileWrapper,
+        {
+          getMappings: () => ({ properties: { field1: { type: 'keyword' } } }),
+        } as never as FileWrapper,
+      ];
+
+      const result = createMergedMappings(files);
+      expect(result.mergedMappings).toEqual({ properties: { field1: { type: 'text' } } });
+      expect(result.mappingClashes).toEqual([]);
+    });
+
+    it('should return merged mappings when a text mapping is being merged with a keyword mapping', () => {
+      const files = [
+        {
+          getMappings: () => ({ properties: { field1: { type: 'keyword' } } }),
+        } as never as FileWrapper,
+        {
+          getMappings: () => ({ properties: { field1: { type: 'text' } } }),
+        } as never as FileWrapper,
+      ];
+
+      const result = createMergedMappings(files);
+      expect(result.mergedMappings).toEqual({ properties: { field1: { type: 'text' } } });
+      expect(result.mappingClashes).toEqual([]);
+    });
+
+    it('should return mapping clashes when mappings are different', () => {
+      const files = [
+        {
+          getFileName: () => 'file1',
+          getMappings: () => ({ properties: { field1: { type: 'text' } } }),
+        } as never as FileWrapper,
+        {
+          getFileName: () => 'file2',
+          getMappings: () => ({ properties: { field1: { type: 'number' } } }),
+        } as never as FileWrapper,
+      ];
+
+      const result = createMergedMappings(files);
+      expect(result.mergedMappings).toEqual({ properties: { field1: { type: 'text' } } });
+      expect(result.mappingClashes).toEqual([
+        {
+          fieldName: 'field1',
+          existingType: 'text',
+          clashingType: { fileName: 'file2', newType: 'number', fileIndex: 1 },
+        },
+      ]);
+    });
+
+    it('should return mapping clashes when first field doesn`t match the others', () => {
+      const files = [
+        {
+          getFileName: () => 'file1',
+          getMappings: () => ({ properties: { field1: { type: 'text' } } }),
+        } as never as FileWrapper,
+        {
+          getFileName: () => 'file2',
+          getMappings: () => ({ properties: { field1: { type: 'number' } } }),
+        } as never as FileWrapper,
+        {
+          getFileName: () => 'file3',
+          getMappings: () => ({ properties: { field1: { type: 'number' } } }),
+        } as never as FileWrapper,
+      ];
+
+      const result = createMergedMappings(files);
+
+      expect(result.mergedMappings).toEqual({ properties: { field1: { type: 'text' } } });
+      expect(result.mappingClashes).toEqual([
+        {
+          fieldName: 'field1',
+          existingType: 'text',
+          clashingType: {
+            fileName: 'file2',
+            newType: 'number',
+            fileIndex: 1,
+          },
+        },
+        {
+          fieldName: 'field1',
+          existingType: 'text',
+          clashingType: {
+            fileName: 'file3',
+            newType: 'number',
+            fileIndex: 2,
+          },
+        },
+      ]);
+    });
+  });
+
+  describe('getMappingClashInfo', () => {
+    it('should return file clashes based on mapping clashes', () => {
+      const mappingClashes = [
+        {
+          fieldName: 'field1',
+          existingType: 'text',
+          clashingType: {
+            fileName: 'file2',
+            newType: 'number',
+            fileIndex: 1,
+          },
+        },
+        {
+          fieldName: 'field1',
+          existingType: 'text',
+          clashingType: {
+            fileName: 'file3',
+            newType: 'number',
+            fileIndex: 2,
+          },
+        },
+      ];
+
+      const filesStatus = [
+        { fileName: 'file1', supportedFormat: true } as FileAnalysis,
+        { fileName: 'file2', supportedFormat: true } as FileAnalysis,
+        { fileName: 'file3', supportedFormat: true } as FileAnalysis,
+      ];
+
+      const result = getMappingClashInfo(mappingClashes, filesStatus);
+
+      expect(result).toEqual([
+        { fileName: 'file1', clash: true, clashType: CLASH_TYPE.MAPPING },
+        { fileName: 'file2', clash: false, clashType: CLASH_TYPE.MAPPING },
+        { fileName: 'file3', clash: false, clashType: CLASH_TYPE.MAPPING },
+      ]);
+    });
+  });
+
+  describe('getFormatClashes', () => {
+    it('should return no clashes when all formats are supported', () => {
+      const files = [
+        {
+          getFormat: () => 'semi_structured_text',
+          getFileName: () => 'file1',
+          getStatus: () => ({ supportedFormat: true }),
+        } as FileWrapper,
+        {
+          getFormat: () => 'semi_structured_text',
+          getFileName: () => 'file2',
+          getStatus: () => ({ supportedFormat: true }),
+        } as FileWrapper,
+      ];
+
+      const result = getFormatClashes(files);
+      expect(result).toEqual([
+        { fileName: 'file1', clash: false },
+        { fileName: 'file2', clash: false },
+      ]);
+    });
+
+    it('should return format clashes when formats are different', () => {
+      const files = [
+        {
+          getFormat: () => 'semi_structured_text',
+          getFileName: () => 'file1',
+          getStatus: () => ({ supportedFormat: true }),
+        } as FileWrapper,
+        {
+          getFormat: () => 'delimited',
+          getFileName: () => 'file2',
+          getStatus: () => ({ supportedFormat: true }),
+        } as FileWrapper,
+      ];
+
+      const result = getFormatClashes(files);
+      expect(result).toEqual([
+        { fileName: 'file1', clash: true, clashType: CLASH_TYPE.FORMAT },
+        { fileName: 'file2', clash: true, clashType: CLASH_TYPE.FORMAT },
+      ]);
+    });
+
+    it('should choose the correct file that clashes', () => {
+      const files = [
+        {
+          getFormat: () => 'semi_structured_text',
+          getFileName: () => 'file1',
+          getStatus: () => ({ supportedFormat: true }),
+        } as FileWrapper,
+        {
+          getFormat: () => 'semi_structured_text',
+          getFileName: () => 'file2',
+          getStatus: () => ({ supportedFormat: true }),
+        } as FileWrapper,
+        {
+          getFormat: () => 'delimited',
+          getFileName: () => 'file3',
+          getStatus: () => ({ supportedFormat: true }),
+        } as FileWrapper,
+      ];
+
+      const result = getFormatClashes(files);
+
+      expect(result).toEqual([
+        { fileName: 'file1', clash: false, clashType: undefined },
+        { fileName: 'file2', clash: false, clashType: undefined },
+        { fileName: 'file3', clash: true, clashType: 1 },
+      ]);
+    });
+
+    it('should return unsupported format clashes', () => {
+      const files = [
+        {
+          getFormat: () => 'semi_structured_text',
+          getFileName: () => 'file1',
+          getStatus: () => ({ supportedFormat: true }),
+          getMappings: () => ({ properties: { field1: { type: 'text' } } }),
+        } as unknown as FileWrapper,
+        {
+          getFormat: () => 'semi_structured_text',
+          getFileName: () => 'file2',
+          getStatus: () => ({ supportedFormat: true }),
+          getMappings: () => ({ properties: { field1: { type: 'text' } } }),
+        } as unknown as FileWrapper,
+        {
+          getFormat: () => 'unknown',
+          getFileName: () => 'file3',
+          getStatus: () => ({ supportedFormat: false }),
+          getMappings: () => ({ properties: { field1: { type: 'text' } } }),
+        } as unknown as FileWrapper,
+      ];
+
+      const result = getFormatClashes(files);
+
+      expect(result).toEqual([
+        { fileName: 'file1', clash: false, clashType: undefined },
+        { fileName: 'file2', clash: false, clashType: undefined },
+        { fileName: 'file3', clash: true, clashType: CLASH_TYPE.UNSUPPORTED },
+      ]);
+    });
+  });
+});