@linagora/linid-im-front-corelib 0.0.4 → 0.0.6

package/tests/unit/components/LinidZoneRenderer.spec.js

@@ -0,0 +1,135 @@
+import { flushPromises, shallowMount } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import LinidZoneRenderer from 'src/components/LinidZoneRenderer.vue';
+import * as federationService from 'src/services/federationService';
+import { useLinidZoneStore } from 'src/stores/linidZoneStore';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { nextTick, watch } from 'vue';
+
+vi.mock('src/services/federationService', () => ({
+  loadAsyncComponent: vi.fn(),
+}));
+
+describe('Test component: LinidZoneRenderer', () => {
+  let pinia;
+  let store;
+  let wrapper;
+
+  beforeEach(() => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+    store = useLinidZoneStore();
+    wrapper = shallowMount(LinidZoneRenderer, {
+      props: { zone: '' },
+      global: { plugins: [pinia] },
+    });
+    vi.clearAllMocks();
+  });
+
+  describe('Test watchEffect', () => {
+    it('should initialize isLoadingComplete to false when mounted', async () => {
+      const values = [];
+      const stopWatch = watch(
+        () => wrapper.vm.isLoadingComplete,
+        (newVal) => {
+          values.push(newVal);
+        },
+        { flush: 'sync' }
+      );
+
+      await wrapper.setProps({ zone: 'zone-test' });
+
+      await flushPromises();
+      await nextTick();
+      stopWatch();
+
+      expect(values).toEqual([false, true]);
+    });
+
+    it('should set isLoadingComplete to true after initialization', async () => {
+      wrapper.setProps({ zone: 'any-zone' });
+
+      await flushPromises();
+      await nextTick();
+
+      expect(wrapper.vm.isLoadingComplete).toBe(true);
+    });
+
+    it('should not call loadAsyncComponent when the zone is not registered in store', async () => {
+      wrapper.setProps({ zone: 'unregistered-zone' });
+
+      await flushPromises();
+      await nextTick();
+
+      expect(federationService.loadAsyncComponent).not.toHaveBeenCalled();
+      expect(wrapper.vm.components).toEqual([]);
+    });
+
+    it('should not call loadAsyncComponent when the zone is registered has no entries', async () => {
+      wrapper.vm.linidZoneStore.zones['empty-zone'] = [];
+
+      wrapper.setProps({ zone: 'empty-zone' });
+
+      await flushPromises();
+      await nextTick();
+
+      expect(federationService.loadAsyncComponent).not.toHaveBeenCalled();
+      expect(wrapper.vm.components).toEqual([]);
+    });
+
+    it('should load components from store when zone is registered and has entries', async () => {
+      const MockComponentA = {
+        name: 'MockComponent',
+        template: '<div>Mock</div>',
+      };
+      const MockComponentB = {
+        name: 'MockComponent',
+        template: '<div>Mock</div>',
+      };
+      vi.mocked(federationService.loadAsyncComponent)
+        .mockReturnValueOnce(MockComponentA)
+        .mockReturnValueOnce(MockComponentB);
+
+      store.register('test-zone', {
+        plugin: 'test-plugin/MockComponentA',
+        props: { title: 'Test' },
+      });
+
+      store.register('test-zone', {
+        plugin: 'test-plugin/MockComponentB',
+        props: {},
+      });
+
+      wrapper.setProps({ zone: 'test-zone' });
+
+      await flushPromises();
+      await nextTick();
+
+      expect(federationService.loadAsyncComponent).toHaveBeenCalledTimes(2);
+      expect(federationService.loadAsyncComponent).toHaveBeenCalledWith(
+        'test-plugin/MockComponentA'
+      );
+      expect(federationService.loadAsyncComponent).toHaveBeenCalledWith(
+        'test-plugin/MockComponentB'
+      );
+
+      expect(wrapper.vm.components).toHaveLength(2);
+
+      expect(wrapper.vm.components[0].plugin).toBe(
+        'test-plugin/MockComponentA'
+      );
+      expect(wrapper.vm.components[0].props).toEqual({ title: 'Test' });
+      expect(JSON.stringify(wrapper.vm.components[0].component)).toEqual(
+        JSON.stringify(MockComponentA)
+      );
+
+      expect(wrapper.vm.components[1].plugin).toBe(
+        'test-plugin/MockComponentB'
+      );
+      expect(wrapper.vm.components[1].props).toEqual({});
+      expect(JSON.stringify(wrapper.vm.components[1].component)).toEqual(
+        JSON.stringify(MockComponentB)
+      );
+    });
+  });
+});

package/tests/unit/lifecycle/skeleton.spec.js

@@ -0,0 +1,138 @@
+import { BasicRemoteModule } from 'src/lifecycle/skeleton';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+describe('Test class: BasicRemoteModule', () => {
+  describe('Test constructor', () => {
+    it('should create a module with required parameters', () => {
+      const module = new BasicRemoteModule(
+        'test-module',
+        'Test Module',
+        '1.0.0'
+      );
+
+      expect(module.id).toBe('test-module');
+      expect(module.name).toBe('Test Module');
+      expect(module.version).toBe('1.0.0');
+      expect(module.description).toBeUndefined();
+    });
+
+    it('should create a module with description', () => {
+      const module = new BasicRemoteModule(
+        'test-module',
+        'Test Module',
+        '1.0.0',
+        'A test module for unit testing'
+      );
+
+      expect(module.id).toBe('test-module');
+      expect(module.name).toBe('Test Module');
+      expect(module.version).toBe('1.0.0');
+      expect(module.description).toBe('A test module for unit testing');
+    });
+  });
+
+  describe('Test lifecycle hooks', () => {
+    let module;
+
+    beforeEach(() => {
+      module = new BasicRemoteModule(
+        'test-module',
+        'Test Module',
+        '1.0.0',
+        'Test description'
+      );
+    });
+
+    describe('Test hook: setup', () => {
+      it('should return success by default', async () => {
+        const result = await module.setup();
+
+        expect(result).toEqual({ success: true });
+      });
+    });
+
+    describe('Test hook: configure', () => {
+      it('should return success with empty config', async () => {
+        const result = await module.configure({});
+
+        expect(result).toEqual({ success: true });
+      });
+
+      it('should return success with valid config', async () => {
+        const config = {
+          id: 'test-module',
+          remoteName: 'testModule',
+        };
+
+        const result = await module.configure(config);
+
+        expect(result).toEqual({ success: true });
+      });
+    });
+
+    describe('Test hook: initialize', () => {
+      it('should return success by default', async () => {
+        const result = await module.initialize();
+
+        expect(result).toEqual({ success: true });
+      });
+    });
+
+    describe('Test hook: ready', () => {
+      it('should return success by default', async () => {
+        const result = await module.ready();
+
+        expect(result).toEqual({ success: true });
+      });
+    });
+
+    describe('Test hook: postInit', () => {
+      it('should return success by default', async () => {
+        const result = await module.postInit();
+
+        expect(result).toEqual({ success: true });
+      });
+    });
+  });
+
+  describe('Test module extension', () => {
+    it('should allow extending the class', () => {
+      class CustomModule extends BasicRemoteModule {
+        constructor() {
+          super('custom-module', 'Custom Module', '1.0.0');
+        }
+      }
+
+      const module = new CustomModule();
+
+      expect(module).toBeInstanceOf(BasicRemoteModule);
+      expect(module.id).toBe('custom-module');
+      expect(module.name).toBe('Custom Module');
+      expect(module.version).toBe('1.0.0');
+    });
+
+    it('should allow overriding lifecycle methods', async () => {
+      class OverriddenModule extends BasicRemoteModule {
+        constructor() {
+          super('override-module', 'Override Module', '1.0.0');
+        }
+
+        async configure(config) {
+          if (!config.required) {
+            return { success: false, error: 'Missing required config' };
+          }
+          return { success: true };
+        }
+      }
+
+      const module = new OverriddenModule();
+
+      const failResult = await module.configure({});
+      expect(failResult.success).toBe(false);
+      expect(failResult.error).toBe('Missing required config');
+
+      const successResult = await module.configure({ required: true });
+      expect(successResult.success).toBe(true);
+    });
+  });
+});

package/tests/unit/services/federationService.spec.js

@@ -0,0 +1,146 @@
+import { loadRemote } from '@module-federation/enhanced/runtime';
+import { loadAsyncComponent } from 'src/services/federationService';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { defineAsyncComponent } from 'vue';
+
+vi.mock('@module-federation/enhanced/runtime');
+vi.mock('vue', async () => {
+  const actual = await vi.importActual('vue');
+  return {
+    ...actual,
+    defineAsyncComponent: vi.fn((loader) => loader),
+  };
+});
+
+describe('Test service: federationService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Test function: loadAsyncComponent', () => {
+    it('should load a remote component successfully', async () => {
+      const testComponent = { default: 'RemoteTestComponent' };
+      const remoteModule = { './TestComponent': testComponent };
+      vi.mocked(loadRemote).mockResolvedValue(remoteModule['./TestComponent']);
+
+      const loader = loadAsyncComponent('test-plugin/TestComponent');
+      const result = await loader();
+
+      expect(loadRemote).toHaveBeenCalledTimes(1);
+      expect(loadRemote).toHaveBeenCalledWith('test-plugin/TestComponent');
+      expect(defineAsyncComponent).toHaveBeenCalled();
+      expect(result).toEqual('RemoteTestComponent');
+    });
+
+    it('should throw an error if remote component export a null default', async () => {
+      const testComponent = { default: null };
+      const remoteModule = { './TestComponent': testComponent };
+      vi.mocked(loadRemote).mockResolvedValue(remoteModule['./TestComponent']);
+
+      const loader = loadAsyncComponent('invalid-plugin/TestComponent');
+
+      await expect(loader()).rejects.toThrow(
+        'Failed to load component from invalid-plugin'
+      );
+      expect(loadRemote).toHaveBeenCalledWith('invalid-plugin/TestComponent');
+    });
+
+    it('should throw an error if remote component export an undefined default', async () => {
+      const testComponent = { default: undefined };
+      const remoteModule = { './TestComponent': testComponent };
+      vi.mocked(loadRemote).mockResolvedValue(remoteModule['./TestComponent']);
+
+      const loader = loadAsyncComponent('invalid-plugin/TestComponent');
+
+      await expect(loader()).rejects.toThrow(
+        'Failed to load component from invalid-plugin'
+      );
+      expect(loadRemote).toHaveBeenCalledWith('invalid-plugin/TestComponent');
+    });
+
+    it('should throw an error if remote component does not have a default export', async () => {
+      const testComponent = { toto: vi.fn() };
+      const remoteModule = { './TestComponent': testComponent };
+      vi.mocked(loadRemote).mockResolvedValue(remoteModule['./TestComponent']);
+
+      const loader = loadAsyncComponent('invalid-plugin/TestComponent');
+
+      await expect(loader()).rejects.toThrow(
+        'Failed to load component from invalid-plugin'
+      );
+      expect(loadRemote).toHaveBeenCalledWith('invalid-plugin/TestComponent');
+    });
+
+    it('should throw an error if module is null', async () => {
+      vi.mocked(loadRemote).mockResolvedValue(null);
+
+      const loader = loadAsyncComponent('null-plugin/TestComponent');
+
+      await expect(loader()).rejects.toThrow(
+        'Failed to load component from null-plugin'
+      );
+    });
+
+    it('should throw an error if module is undefined', async () => {
+      vi.mocked(loadRemote).mockResolvedValue(undefined);
+
+      const loader = loadAsyncComponent('undefined-plugin/TestComponent');
+
+      await expect(loader()).rejects.toThrow(
+        'Failed to load component from undefined-plugin'
+      );
+    });
+
+    it('should throw an error if loadRemote rejects', async () => {
+      const error = new Error('Network error');
+
+      vi.mocked(loadRemote).mockRejectedValue(error);
+
+      const loader = loadAsyncComponent('failing-plugin/TestComponent');
+
+      await expect(loader()).rejects.toThrow('Network error');
+      expect(loadRemote).toHaveBeenCalledWith('failing-plugin/TestComponent');
+    });
+
+    it('should handle different plugin names', async () => {
+      const plugins = ['plugin-a', 'plugin-b', 'plugin-c'];
+      const testComponentA = { default: 'RemoteTestComponentA' };
+      const remoteModuleA = { './TestComponent': testComponentA };
+      const testComponentB = { default: 'RemoteTestComponentB' };
+      const remoteModuleB = { './TestComponent': testComponentB };
+      const testComponentC = { default: 'RemoteTestComponentC' };
+      const remoteModuleC = { './TestComponent': testComponentC };
+
+      vi.mocked(loadRemote)
+        .mockResolvedValueOnce(remoteModuleA['./TestComponent'])
+        .mockResolvedValueOnce(remoteModuleB['./TestComponent'])
+        .mockResolvedValueOnce(remoteModuleC['./TestComponent']);
+
+      for (const plugin of plugins) {
+        const loader = loadAsyncComponent(`${plugin}/TestComponent`);
+        const result = await loader();
+        const lastChar = plugin.charAt(plugin.length - 1).toUpperCase();
+
+        expect(loadRemote).toHaveBeenCalledWith(`${plugin}/TestComponent`);
+        expect(result).toEqual(`RemoteTestComponent${lastChar}`);
+      }
+
+      expect(loadRemote).toHaveBeenCalledTimes(3);
+    });
+
+    it('should handle module with additional exports', async () => {
+      const testComponent = {
+        default: 'RemoteTestComponent',
+        namedExport1: 'value1',
+        namedExport2: 'value2',
+      };
+      const remoteModule = { './TestComponent': testComponent };
+      vi.mocked(loadRemote).mockResolvedValue(remoteModule['./TestComponent']);
+
+      const loader = loadAsyncComponent('multi-export-plugin');
+      const result = await loader();
+
+      expect(result).toEqual('RemoteTestComponent');
+    });
+  });
+});

package/tests/unit/services/httpClientService.spec.js

@@ -0,0 +1,49 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+// We need to reset the module between tests to clear the singleton
+let getHttpClient, setHttpClient;
+
+describe('Test service: httpClientService', () => {
+  beforeEach(async () => {
+    vi.resetModules();
+    const module = await import('src/services/httpClientService');
+    getHttpClient = module.getHttpClient;
+    setHttpClient = module.setHttpClient;
+  });
+
+  describe('Test function: setHttpClient', () => {
+    it('should set the HTTP client successfully', () => {
+      const mockClient = { get: vi.fn(), post: vi.fn() };
+
+      setHttpClient(mockClient);
+
+      expect(getHttpClient()).toBe(mockClient);
+    });
+
+    it('should warn and ignore re-initialization', () => {
+      const consoleWarnSpy = vi
+        .spyOn(globalThis.console, 'warn')
+        .mockImplementation(() => {});
+      const firstClient = { get: vi.fn() };
+      const secondClient = { post: vi.fn() };
+
+      setHttpClient(firstClient);
+      setHttpClient(secondClient);
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        '[LinID CoreLib] HTTP client has already been initialized. Re-initialization is ignored.'
+      );
+      expect(getHttpClient()).toBe(firstClient);
+
+      consoleWarnSpy.mockRestore();
+    });
+  });
+
+  describe('Test function: getHttpClient', () => {
+    it('should throw an error if client is not initialized', () => {
+      expect(() => getHttpClient()).toThrow(
+        '[LinID CoreLib] HTTP client is not initialized. Call setHttpClient() first.'
+      );
+    });
+  });
+});

package/tests/unit/services/linIdConfigurationService.spec.js

@@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  getEntitiesConfiguration,
+  getEntityConfiguration,
+  getRoutesConfiguration,
+} from 'src/services/linIdConfigurationService';
+import * as httpClientService from 'src/services/httpClientService';
+
+vi.mock('src/services/httpClientService', () => ({
+  getHttpClient: vi.fn(),
+}));
+
+describe('Test service: linIdConfigurationService', () => {
+  let mockHttpClient;
+
+  beforeEach(() => {
+    mockHttpClient = {
+      get: vi.fn(),
+    };
+    vi.mocked(httpClientService.getHttpClient).mockReturnValue(mockHttpClient);
+    vi.clearAllMocks();
+  });
+
+  describe('Test function: getEntitiesConfiguration', () => {
+    it('should fetch all entities from /metadata/entities', async () => {
+      const mockEntities = [
+        { name: 'user', attributes: [] },
+        { name: 'group', attributes: [] },
+      ];
+      mockHttpClient.get.mockResolvedValue({ data: mockEntities });
+
+      const result = await getEntitiesConfiguration();
+
+      expect(httpClientService.getHttpClient).toHaveBeenCalled();
+      expect(mockHttpClient.get).toHaveBeenCalledWith('/metadata/entities');
+      expect(result).toEqual(mockEntities);
+    });
+
+    it('should propagate errors from HTTP client', async () => {
+      const error = new Error('Network error');
+      mockHttpClient.get.mockRejectedValue(error);
+
+      await expect(getEntitiesConfiguration()).rejects.toThrow('Network error');
+    });
+  });
+
+  describe('Test function: getEntityConfiguration', () => {
+    it('should fetch a specific entity from /metadata/entities/:entity', async () => {
+      const mockEntity = {
+        name: 'user',
+        attributes: [
+          {
+            name: 'email',
+            type: 'string',
+            required: true,
+            hasValidations: false,
+            input: 'text',
+            inputSettings: {},
+          },
+        ],
+      };
+      mockHttpClient.get.mockResolvedValue({ data: mockEntity });
+
+      const result = await getEntityConfiguration('user');
+
+      expect(mockHttpClient.get).toHaveBeenCalledWith(
+        '/metadata/entities/user'
+      );
+      expect(result).toEqual(mockEntity);
+    });
+
+    it('should handle special characters in entity ID', async () => {
+      const mockEntity = { name: 'my-entity', attributes: [] };
+      mockHttpClient.get.mockResolvedValue({ data: mockEntity });
+
+      const result = await getEntityConfiguration('my-entity');
+
+      expect(mockHttpClient.get).toHaveBeenCalledWith(
+        '/metadata/entities/my-entity'
+      );
+      expect(result).toEqual(mockEntity);
+    });
+
+    it('should propagate errors from HTTP client', async () => {
+      mockHttpClient.get.mockRejectedValue(new Error('Not found'));
+
+      await expect(getEntityConfiguration('unknown')).rejects.toThrow(
+        'Not found'
+      );
+    });
+  });
+
+  describe('Test function: getRoutesConfiguration', () => {
+    it('should fetch all routes from /metadata/routes', async () => {
+      const mockRoutes = [
+        { method: 'GET', path: '/users', entity: 'user', variables: [] },
+        { method: 'POST', path: '/users', entity: 'user', variables: [] },
+      ];
+      mockHttpClient.get.mockResolvedValue({ data: mockRoutes });
+
+      const result = await getRoutesConfiguration();
+
+      expect(mockHttpClient.get).toHaveBeenCalledWith('/metadata/routes');
+      expect(result).toEqual(mockRoutes);
+    });
+
+    it('should propagate errors from HTTP client', async () => {
+      mockHttpClient.get.mockRejectedValue(new Error('Server error'));
+
+      await expect(getRoutesConfiguration()).rejects.toThrow('Server error');
+    });
+  });
+});