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

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

@@ -1,113 +0,0 @@
-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');
-    });
-  });
-});

package/tests/unit/stores/linIdConfigurationStore.spec.js

@@ -1,171 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia';
-import { useLinIdConfigurationStore } from 'src/stores/linIdConfigurationStore';
-import * as linIdConfigurationService from 'src/services/linIdConfigurationService';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-vi.mock('src/services/linIdConfigurationService', () => ({
-  getEntitiesConfiguration: vi.fn(),
-  getRoutesConfiguration: vi.fn(),
-}));
-
-describe('Test store: linIdConfigurationStore', () => {
-  let store;
-
-  beforeEach(() => {
-    setActivePinia(createPinia());
-    store = useLinIdConfigurationStore();
-    vi.clearAllMocks();
-  });
-
-  describe('Test initial state', () => {
-    it('should have empty initial state', () => {
-      expect(store.entities).toEqual([]);
-      expect(store.routes).toEqual([]);
-      expect(store.loading).toBe(false);
-      expect(store.error).toBeNull();
-    });
-  });
-
-  describe('Test getter: getEntityByName', () => {
-    it('should return undefined when entity is not found', () => {
-      store.entities = [{ name: 'user', attributes: [] }];
-
-      const result = store.getEntityByName('unknown');
-
-      expect(result).toBeUndefined();
-    });
-
-    it('should return the entity when found', () => {
-      const userEntity = { name: 'user', attributes: [{ name: 'email' }] };
-      store.entities = [userEntity, { name: 'group', attributes: [] }];
-
-      const result = store.getEntityByName('user');
-
-      expect(result).toEqual(userEntity);
-    });
-  });
-
-  describe('Test getter: getRoutesByEntity', () => {
-    it('should return empty array when no routes match', () => {
-      store.routes = [
-        { method: 'GET', path: '/groups', entity: 'group', variables: [] },
-      ];
-
-      const result = store.getRoutesByEntity('user');
-
-      expect(result).toEqual([]);
-    });
-
-    it('should return all routes for the specified entity', () => {
-      const userRoutes = [
-        { method: 'GET', path: '/users', entity: 'user', variables: [] },
-        { method: 'POST', path: '/users', entity: 'user', variables: [] },
-      ];
-      store.routes = [
-        ...userRoutes,
-        { method: 'GET', path: '/groups', entity: 'group', variables: [] },
-      ];
-
-      const result = store.getRoutesByEntity('user');
-
-      expect(result).toEqual(userRoutes);
-    });
-  });
-
-  describe('Test action: fetchConfiguration', () => {
-    it('should fetch entities and routes successfully', async () => {
-      const mockEntities = [{ name: 'user', attributes: [] }];
-      const mockRoutes = [
-        { method: 'GET', path: '/users', entity: 'user', variables: [] },
-      ];
-
-      vi.mocked(
-        linIdConfigurationService.getEntitiesConfiguration
-      ).mockResolvedValue(mockEntities);
-      vi.mocked(
-        linIdConfigurationService.getRoutesConfiguration
-      ).mockResolvedValue(mockRoutes);
-
-      await store.fetchConfiguration();
-
-      expect(store.entities).toEqual(mockEntities);
-      expect(store.routes).toEqual(mockRoutes);
-      expect(store.loading).toBe(false);
-      expect(store.error).toBeNull();
-    });
-
-    it('should set loading to true during fetch', async () => {
-      let loadingDuringFetch = false;
-
-      vi.mocked(
-        linIdConfigurationService.getEntitiesConfiguration
-      ).mockImplementation(async () => {
-        loadingDuringFetch = store.loading;
-        return [];
-      });
-      vi.mocked(
-        linIdConfigurationService.getRoutesConfiguration
-      ).mockResolvedValue([]);
-
-      await store.fetchConfiguration();
-
-      expect(loadingDuringFetch).toBe(true);
-      expect(store.loading).toBe(false);
-    });
-
-    it('should handle errors and set error message', async () => {
-      const consoleErrorSpy = vi
-        .spyOn(globalThis.console, 'error')
-        .mockImplementation(() => {});
-      const error = new Error('Network failure');
-
-      vi.mocked(
-        linIdConfigurationService.getEntitiesConfiguration
-      ).mockRejectedValue(error);
-
-      await store.fetchConfiguration();
-
-      expect(store.error).toBe('Network failure');
-      expect(store.loading).toBe(false);
-      expect(store.entities).toEqual([]);
-      expect(store.routes).toEqual([]);
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        '[LinID CoreLib] Failed to fetch configuration:',
-        error
-      );
-
-      consoleErrorSpy.mockRestore();
-    });
-
-    it('should handle non-Error exceptions', async () => {
-      const consoleErrorSpy = vi
-        .spyOn(globalThis.console, 'error')
-        .mockImplementation(() => {});
-
-      vi.mocked(
-        linIdConfigurationService.getEntitiesConfiguration
-      ).mockRejectedValue('String error');
-
-      await store.fetchConfiguration();
-
-      expect(store.error).toBe('Failed to fetch configuration');
-
-      consoleErrorSpy.mockRestore();
-    });
-
-    it('should reset error on new fetch', async () => {
-      store.error = 'Previous error';
-
-      vi.mocked(
-        linIdConfigurationService.getEntitiesConfiguration
-      ).mockResolvedValue([]);
-      vi.mocked(
-        linIdConfigurationService.getRoutesConfiguration
-      ).mockResolvedValue([]);
-
-      await store.fetchConfiguration();
-
-      expect(store.error).toBeNull();
-    });
-  });
-});

package/tests/unit/stores/linidZoneStore.spec.js

@@ -1,94 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia';
-import { useLinidZoneStore } from 'src/stores/linidZoneStore';
-import { beforeEach, describe, expect, it } from 'vitest';
-
-describe('Test store: linidZoneStore', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia());
-  });
-
-  describe('Test initial state', () => {
-    it('should initialize with empty zones', () => {
-      const store = useLinidZoneStore();
-
-      expect(store.zones).toEqual({});
-    });
-  });
-
-  describe('Test function: register', () => {
-    it('should register an entry in a new zone', () => {
-      const store = useLinidZoneStore();
-      const entry = {
-        plugin: 'test-plugin/TestComponent',
-        props: {},
-      };
-
-      store.register('list-page.sidebar', entry);
-
-      expect(store.zones['list-page.sidebar']).toBeDefined();
-      expect(store.zones['list-page.sidebar']).toHaveLength(1);
-      expect(store.zones['list-page.sidebar'][0]).toEqual(entry);
-    });
-
-    it('should register multiple entries in the same zone', () => {
-      const store = useLinidZoneStore();
-      const entry1 = {
-        plugin: 'plugin-1/Component1',
-        props: {},
-      };
-      const entry2 = {
-        plugin: 'plugin-2/Component2',
-        props: { value: 42 },
-      };
-
-      store.register('list-page.sidebar', entry1);
-      store.register('list-page.sidebar', entry2);
-
-      expect(store.zones['list-page.sidebar']).toHaveLength(2);
-      expect(store.zones['list-page.sidebar'][0]).toEqual(entry1);
-      expect(store.zones['list-page.sidebar'][1]).toEqual(entry2);
-    });
-
-    it('should register entries in different zones independently', () => {
-      const store = useLinidZoneStore();
-      const headerEntry = {
-        plugin: 'header-plugin/HeaderComponent',
-        props: {},
-      };
-      const footerEntry = {
-        plugin: 'footer-plugin/FooterComponent',
-        props: {},
-      };
-
-      store.register('list-page.header', headerEntry);
-      store.register('list-page.footer', footerEntry);
-
-      expect(store.zones['list-page.header']).toHaveLength(1);
-      expect(store.zones['list-page.footer']).toHaveLength(1);
-      expect(store.zones['list-page.header'][0]).toEqual(headerEntry);
-      expect(store.zones['list-page.footer'][0]).toEqual(footerEntry);
-    });
-
-    it('should handle entries with complex props', () => {
-      const store = useLinidZoneStore();
-      const entry = {
-        plugin: 'complex-plugin/ComplexComponent',
-        props: {
-          title: 'Test Title',
-          count: 123,
-          enabled: true,
-          config: {
-            nested: {
-              value: 'deep',
-            },
-          },
-          items: ['a', 'b', 'c'],
-        },
-      };
-
-      store.register('list-page.body', entry);
-
-      expect(store.zones['list-page.body'][0].props).toEqual(entry.props);
-    });
-  });
-});

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "files": [],
-  "references": [
-    {
-      "path": "./tsconfig.node.json"
-    },
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ESNext", "DOM"],
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "types": ["node", "vite/client", "vue"],
-    "declaration": true,
-    "declarationDir": "dist/types",
-    "outDir": "dist"
-  },
-  "include": ["src"],
-  "exclude": ["vite.config.ts", "tests", "vitest.config.ts"]
-}

package/tsconfig.node.json

@@ -1,9 +0,0 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "module": "nodenext",
-    "strict": true,
-    "types": ["node"]
-  },
-  "include": ["vite.config.ts", "vitest.config.ts"]
-}

package/tsconfig.spec.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "baseUrl": ".",
-    "outDir": "./out-tsc/vitest",
-    "allowJs": true,
-    "module": "esnext",
-    "moduleResolution": "bundler"
-  },
-  "include": ["tests", "src"],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    }
-  ]
-}

package/vite.config.ts

@@ -1,37 +0,0 @@
-import vue from '@vitejs/plugin-vue';
-import fs from 'fs';
-import path from 'path';
-import { defineConfig } from 'vite';
-
-export default defineConfig({
-  plugins: [
-    vue(),
-
-    {
-      name: 'copy-package-json',
-      closeBundle() {
-        const src = path.resolve(__dirname, 'package.json');
-        const dest = path.resolve(__dirname, 'dist', 'package.json');
-        if (fs.existsSync(src)) {
-          fs.copyFileSync(src, dest);
-        }
-      },
-    },
-  ],
-
-  build: {
-    lib: {
-      entry: path.resolve(__dirname, 'src/index.ts'),
-      name: 'CoreLib',
-      fileName: (format) => `core-lib.${format}.js`,
-    },
-    rollupOptions: {
-      external: ['vue'],
-      output: {
-        globals: {
-          vue: 'Vue',
-        },
-      },
-    },
-  },
-});

package/vitest.config.ts

@@ -1,19 +0,0 @@
-import vue from '@vitejs/plugin-vue';
-import tsconfigPaths from 'vite-tsconfig-paths';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'happy-dom',
-    globals: true,
-    include: ['tests/unit/**/*.{test,spec}.js'],
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'html', 'lcov'],
-      reportsDirectory: './coverage',
-      include: ['src/**/*.{ts,js,vue}'],
-      exclude: ['**/tests/**', 'src/types/**', 'src/index.ts'],
-    },
-  },
-  plugins: [vue(), tsconfigPaths()],
-});