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

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

@@ -0,0 +1,171 @@
+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

@@ -0,0 +1,94 @@
+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,30 +1,14 @@
 {
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": [
-      "ESNext",
-      "DOM"
-    ],
-    "allowJs": true,
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "types": [
-      "node",
-      "vite/client",
-      "vue"
-    ],
-    "declaration": true,
-    "declarationDir": "dist/types",
-    "outDir": "dist"
-  },
-  "include": [
-    "src/**/*.ts",
-    "src/**/*.vue",
-    "vite.config.ts"
+  "files": [],
+  "references": [
+    {
+      "path": "./tsconfig.node.json"
+    },
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
   ]
 }

package/tsconfig.lib.json

@@ -0,0 +1,20 @@
+{
+  "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

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

package/tsconfig.spec.json

@@ -0,0 +1,16 @@
+{
+  "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,22 +1,17 @@
-/// <reference types="node" />
-import {defineConfig} from "vite";
-import vue from "@vitejs/plugin-vue";
-import path from "path";
-import fs from "fs";
-import {fileURLToPath} from "url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+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",
+      name: 'copy-package-json',
       closeBundle() {
-        const src = path.resolve(__dirname, "package.json");
-        const dest = path.resolve(__dirname, "dist", "package.json");
+        const src = path.resolve(__dirname, 'package.json');
+        const dest = path.resolve(__dirname, 'dist', 'package.json');
         if (fs.existsSync(src)) {
           fs.copyFileSync(src, dest);
         }
@@ -26,15 +21,15 @@ export default defineConfig({
 
   build: {
     lib: {
-      entry: path.resolve(__dirname, "src/index.ts"),
-      name: "CoreLib",
+      entry: path.resolve(__dirname, 'src/index.ts'),
+      name: 'CoreLib',
       fileName: (format) => `core-lib.${format}.js`,
     },
     rollupOptions: {
-      external: ["vue"],
+      external: ['vue'],
       output: {
         globals: {
-          vue: "Vue",
+          vue: 'Vue',
         },
       },
     },

package/vitest.config.ts

@@ -0,0 +1,19 @@
+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()],
+});

package/dist/types/vite.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;