RI-6382: Test multiple source connections (#4389)

* enhance client to make multiple requests
    as only one source connection can be tested in single request
* display multiple sources
* have mixed state for successful and failed connections
* extract to decorator
* add direction transform options
* add test for transform options

Author: pawelangelow

redisinsight/api/src/common/decorators/transform-to-map.decorator.spec.ts

@@ -0,0 +1,139 @@
+import * as classTransformer from 'class-transformer';
+import { TransformToMap } from './transform-to-map.decorator';
+
+const { Expose, classToPlain, plainToClass } = classTransformer;
+
+class DummyClass {
+  @Expose()
+  value: string;
+}
+
+class TestDto {
+  @TransformToMap(DummyClass)
+  @Expose()
+  data: Record<string, DummyClass>;
+}
+
+describe('TransformToMap decorator', () => {
+  it('should transform each map value into an instance of DummyClass', () => {
+    const input = {
+      data: {
+        key1: { value: 'test1' },
+        key2: { value: 'test2' },
+      },
+    };
+
+    const instance = plainToClass(TestDto, input);
+
+    expect(instance.data).toBeDefined();
+    expect(instance.data.key1).toBeInstanceOf(DummyClass);
+    expect(instance.data.key2).toBeInstanceOf(DummyClass);
+    expect(instance.data.key1.value).toEqual('test1');
+    expect(instance.data.key2.value).toEqual('test2');
+  });
+
+  it('should handle empty objects gracefully', () => {
+    const input = { data: {} };
+    const instance = plainToClass(TestDto, input);
+
+    expect(instance.data).toEqual({});
+  });
+
+  it('should handle undefined values gracefully', () => {
+    const input = { data: undefined };
+    const instance = plainToClass(TestDto, input);
+
+    expect(instance.data).toEqual(undefined);
+  });
+
+  it('should convert a class instance to a plain object', () => {
+    const dummy1 = new DummyClass();
+    dummy1.value = 'test1';
+    const dummy2 = new DummyClass();
+    dummy2.value = 'test2';
+
+    const dataMap = {
+      key1: { value: 'test1' },
+      key2: { value: 'test2' },
+    };
+
+    const instance = new TestDto();
+    instance.data = dataMap;
+
+    const plain = classToPlain(instance);
+
+    expect(plain).toHaveProperty('data');
+    expect(plain.data).toEqual({
+      key1: { value: 'test1' },
+      key2: { value: 'test2' },
+    });
+  });
+
+  it('should handle an empty Map gracefully on reverse conversion', () => {
+    const instance = new TestDto();
+    instance.data = {};
+
+    const plain = classToPlain(instance);
+
+    expect(plain.data).toEqual({});
+  });
+
+  it('should handle undefined values gracefully on reverse conversion', () => {
+    const instance = new TestDto();
+    instance.data = undefined;
+
+    const plain = classToPlain(instance);
+
+    expect(plain.data).toEqual(undefined);
+  });
+
+  it('should trigger plainToClass without triggering classToPlain', () => {
+    const spyClassToPlain = jest.spyOn(classTransformer, 'classToPlain');
+
+    const input = {
+      data: {
+        key1: { value: 'test1' },
+        key2: { value: 'test2' },
+      },
+    };
+
+    const instance = plainToClass(TestDto, input, {
+      excludeExtraneousValues: true,
+    });
+
+    expect(instance.data).toBeDefined();
+    expect(instance.data.key1).toBeInstanceOf(DummyClass);
+    expect(instance.data.key1.value).toEqual('test1');
+
+    expect(spyClassToPlain).not.toHaveBeenCalled();
+
+    spyClassToPlain.mockRestore();
+  });
+
+  it('should trigger classToPlain without triggering plainToClass', () => {
+    const spyPlainToClass = jest.spyOn(classTransformer, 'plainToClass');
+
+    const dummy1 = new DummyClass();
+    dummy1.value = 'test1';
+    const dummy2 = new DummyClass();
+    dummy2.value = 'test2';
+
+    const instance = new TestDto();
+    instance.data = {
+      key1: dummy1,
+      key2: dummy2,
+    };
+
+    const plain = classToPlain(instance);
+
+    expect(plain).toHaveProperty('data');
+    expect(plain.data).toEqual({
+      key1: { value: 'test1' },
+      key2: { value: 'test2' },
+    });
+
+    expect(spyPlainToClass).not.toHaveBeenCalled();
+
+    spyPlainToClass.mockRestore();
+  });
+});

redisinsight/api/src/common/decorators/transform-to-map.decorator.ts

@@ -0,0 +1,39 @@
+import { applyDecorators } from '@nestjs/common';
+import { Transform, classToPlain, plainToClass } from 'class-transformer';
+import { ClassType } from 'class-transformer/ClassTransformer';
+
+export function TransformToMap<T>(targetClass: ClassType<T>) {
+  return applyDecorators(
+    Transform(
+      (value) => {
+        if (!value) {
+          return value;
+        }
+
+        return Object.fromEntries(
+          Object.entries(value).map(([key, val]) => [
+            key,
+            plainToClass(targetClass, val),
+          ]),
+        );
+      },
+      { toClassOnly: true },
+    ),
+
+    Transform(
+      (value) => {
+        if (!value) {
+          return value;
+        }
+
+        return Object.fromEntries(
+          Object.entries(value).map(([key, instance]) => [
+            key,
+            classToPlain(instance),
+          ]),
+        );
+      },
+      { toPlainOnly: true },
+    ),
+  );
+}

redisinsight/api/src/modules/rdi/client/api.rdi.client.spec.ts

@@ -18,6 +18,32 @@ const mockedAxios = axios as jest.Mocked<typeof axios>;
 jest.mock('axios');
 mockedAxios.create = jest.fn(() => mockedAxios);
 
+const createMockPostImplementation = (
+  targetsResponses: (any | Error)[],
+  sourcesResponses: (any | Error)[],
+) => {
+  let targetsCallCount = 0;
+  let sourcesCallCount = 0;
+
+  return (url: string) => {
+    if (url === RdiUrl.TestTargetsConnections) {
+      // eslint-disable-next-line no-plusplus
+      const response = targetsResponses[targetsCallCount++];
+      return response instanceof Error
+        ? Promise.reject(response)
+        : Promise.resolve(response);
+    }
+    if (url === RdiUrl.TestSourcesConnections) {
+      // eslint-disable-next-line no-plusplus
+      const response = sourcesResponses[sourcesCallCount++];
+      return response instanceof Error
+        ? Promise.reject(response)
+        : Promise.resolve(response);
+    }
+    return Promise.reject(new Error(`Unexpected URL: ${url}`));
+  };
+};
+
 describe('ApiRdiClient', () => {
   let client: ApiRdiClient;
 
@@ -274,7 +300,7 @@ describe('ApiRdiClient', () => {
   });
 
   describe('testConnections', () => {
-    const config = { sources: {} };
+    const config = { sources: { source1: {} } };
 
     it('should return a successful response', async () => {
       const expectedTargetsResponse = {
@@ -285,24 +311,72 @@ describe('ApiRdiClient', () => {
         },
       };
       const expectedSourcesResponse = {
-        connected: true,
-        error: '',
+        source1: {
+          connected: true,
+          error: '',
+        },
       };
 
-      mockedAxios.post
-        .mockResolvedValueOnce({ data: expectedTargetsResponse })
-        .mockResolvedValueOnce({ data: expectedSourcesResponse });
+      const targetsResponses = [{ data: expectedTargetsResponse }];
 
-      const response = await client.testConnections(config);
+      const sourcesResponses = [
+        { data: expectedSourcesResponse.source1 },
+      ];
 
-      expect(mockedAxios.post).toHaveBeenCalledWith(
-        RdiUrl.TestTargetsConnections,
-        config,
+      mockedAxios.post.mockImplementation(
+        createMockPostImplementation(targetsResponses, sourcesResponses),
       );
-      expect(mockedAxios.post).toHaveBeenCalledWith(
-        RdiUrl.TestSourcesConnections,
-        {},
+
+      const response = await client.testConnections(config);
+
+      expect(mockedAxios.post).toHaveBeenCalledTimes(2);
+
+      expect(response).toEqual({
+        sources: expectedSourcesResponse,
+        ...expectedTargetsResponse,
+      });
+    });
+
+    it('should return a successful response with multiple sources', async () => {
+      const expectedTargetsResponse = {
+        targets: {
+          target: {
+            status: 'success',
+          },
+        },
+      };
+
+      const expectedSourcesResponse = {
+        source1: {
+          connected: true,
+          error: '',
+        },
+        source2: {
+          connected: false,
+          error: 'Connection failed',
+        },
+      };
+
+      const targetsResponses = [{ data: expectedTargetsResponse }];
+
+      const sourcesResponses = [
+        { data: { connected: true, error: '' } },
+        { data: { connected: false, error: 'Connection failed' } },
+      ];
+
+      mockedAxios.post.mockImplementation(
+        createMockPostImplementation(targetsResponses, sourcesResponses),
       );
+
+      const response = await client.testConnections({
+        sources: {
+          source1: {},
+          source2: {},
+        },
+      });
+
+      expect(mockedAxios.post).toHaveBeenCalledTimes(3);
+
       expect(response).toEqual({
         sources: expectedSourcesResponse,
         ...expectedTargetsResponse,
@@ -323,22 +397,66 @@ describe('ApiRdiClient', () => {
 
       const loggerErrorSpy = jest.spyOn(client['logger'], 'error').mockImplementation();
 
-      mockedAxios.post
-        .mockResolvedValueOnce({ data: expectedTargetsResponse })
-        .mockRejectedValueOnce(new Error('Sources request failed'));
+      const targetsResponses = [{ data: expectedTargetsResponse }];
+
+      const sourcesResponses = [
+        new Error('Sources request failed'),
+      ];
+
+      mockedAxios.post.mockImplementation(
+        createMockPostImplementation(targetsResponses, sourcesResponses),
+      );
 
       const response = await client.testConnections(config);
 
       expect(response).toEqual({
         targets: expectedTargetsResponse.targets,
-        sources: { connected: false, error: 'Failed to fetch sources' },
+        sources: {},
       });
 
       expect(mockedAxios.post).toHaveBeenCalledTimes(2);
 
       expect(loggerErrorSpy).toHaveBeenCalledWith('Failed to fetch sources', expect.any(Error));
       loggerErrorSpy.mockRestore();
     });
+
+    it('should return targets data even if TestSourcesConnections fails, asd', async () => {
+      const expectedTargetsResponse = {
+        targets: { target1: { status: 'success' } },
+      };
+
+      const loggerErrorSpy = jest.spyOn(client['logger'], 'error').mockImplementation();
+
+      const targetsResponses = [{ data: expectedTargetsResponse }];
+
+      const sourcesResponses = [
+        { data: { connected: true, error: '' } },
+        new Error('Sources request failed'),
+      ];
+
+      mockedAxios.post.mockImplementation(
+        createMockPostImplementation(targetsResponses, sourcesResponses),
+      );
+
+      const response = await client.testConnections({
+        sources: {
+          source1: {},
+          source2: {},
+        },
+      });
+
+      expect(response).toEqual({
+        targets: expectedTargetsResponse.targets,
+        sources: {
+          source1: { connected: true, error: '' },
+        },
+      });
+
+      expect(mockedAxios.post).toHaveBeenCalledTimes(3);
+
+      expect(loggerErrorSpy).toHaveBeenCalledWith('Failed to fetch sources', expect.any(Error));
+      loggerErrorSpy.mockRestore();
+    });
   });
 
   describe('getPipelineStatus', () => {