@qlover/create-app 0.6.2 → 0.7.0

package/dist/templates/react-app/__tests__/src/base/cases/RequestStatusCatcher.test.ts

@@ -0,0 +1,192 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * RequestStatusCatcher test suite
+ *
+ * Coverage:
+ * 1. constructor      - Logger injection
+ * 2. default         - Default handler behavior
+ * 3. handler         - Dynamic status code handling
+ * 4. case200         - Success case handling
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { RequestStatusCatcher } from '@/base/cases/RequestStatusCatcher';
+import { MockLogger } from '../../../__mocks__/MockLogger';
+import type { RequestAdapterResponse } from '@qlover/fe-corekit';
+
+describe('RequestStatusCatcher', () => {
+  let logger: MockLogger;
+  let statusCatcher: RequestStatusCatcher;
+
+  beforeEach(() => {
+    logger = new MockLogger();
+    statusCatcher = new RequestStatusCatcher(logger);
+  });
+
+  describe('constructor', () => {
+    it('should be properly initialized with logger', () => {
+      expect(statusCatcher).toBeInstanceOf(RequestStatusCatcher);
+      expect(logger).toBeDefined();
+    });
+  });
+
+  describe('default handler', () => {
+    it('should log warning for unhandled status codes', () => {
+      const context: RequestAdapterResponse = {
+        data: null,
+        status: 418,
+        statusText: "I'm a teapot",
+        headers: {},
+        config: {
+          method: 'GET',
+          url: 'https://api.example.com/coffee',
+          headers: {}
+        },
+        response: new Response()
+      };
+
+      statusCatcher.default(context);
+
+      expect(logger.warn).toHaveBeenCalledWith(
+        'RequestStatusCatcher default handler',
+        context
+      );
+    });
+  });
+
+  describe('handler', () => {
+    it('should call case200 for 200 status code', () => {
+      const context: RequestAdapterResponse = {
+        data: { success: true },
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        config: {
+          method: 'GET',
+          url: 'https://api.example.com/data',
+          headers: {}
+        },
+        response: new Response()
+      };
+
+      statusCatcher.handler(context);
+      // case200 is currently empty, so we just verify it doesn't throw
+      expect(true).toBe(true);
+    });
+
+    it('should call default handler for unknown status codes', () => {
+      const context: RequestAdapterResponse = {
+        data: null,
+        status: 499,
+        statusText: 'Unknown Status',
+        headers: {},
+        config: {
+          method: 'GET',
+          url: 'https://api.example.com/unknown',
+          headers: {}
+        },
+        response: new Response()
+      };
+
+      statusCatcher.handler(context);
+
+      expect(logger.warn).toHaveBeenCalledWith(
+        'RequestStatusCatcher default handler',
+        context
+      );
+    });
+
+    it('should handle null or undefined status', () => {
+      const context = {
+        data: null,
+        status: undefined,
+        statusText: 'No Status',
+        headers: {},
+        config: {
+          method: 'GET',
+          url: 'https://api.example.com/nostatus',
+          headers: {}
+        },
+        response: new Response()
+      } as unknown as RequestAdapterResponse;
+
+      statusCatcher.handler(context);
+
+      expect(logger.warn).toHaveBeenCalledWith(
+        'RequestStatusCatcher default handler',
+        context
+      );
+    });
+  });
+
+  describe('case200', () => {
+    it('should handle successful responses', () => {
+      const context: RequestAdapterResponse = {
+        data: { success: true },
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        config: {
+          method: 'GET',
+          url: 'https://api.example.com/success',
+          headers: {}
+        },
+        response: new Response()
+      };
+
+      statusCatcher.case200(context);
+      // Currently case200 is empty, so we just verify it doesn't throw
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('dynamic handler resolution', () => {
+    it('should dynamically resolve and call status handlers', () => {
+      // Add a custom handler for testing
+      const customHandler = vi.fn();
+      (statusCatcher as any).case418 = customHandler;
+
+      const context: RequestAdapterResponse = {
+        data: null,
+        status: 418,
+        statusText: "I'm a teapot",
+        headers: {},
+        config: {
+          method: 'GET',
+          url: 'https://api.example.com/teapot',
+          headers: {}
+        },
+        response: new Response()
+      };
+
+      statusCatcher.handler(context);
+
+      expect(customHandler).toHaveBeenCalledWith(context);
+    });
+
+    it('should handle non-function properties gracefully', () => {
+      // Add a non-function property
+      (statusCatcher as any).case500 = 'not a function';
+
+      const context: RequestAdapterResponse = {
+        data: null,
+        status: 500,
+        statusText: 'Internal Server Error',
+        headers: {},
+        config: {
+          method: 'GET',
+          url: 'https://api.example.com/error',
+          headers: {}
+        },
+        response: new Response()
+      };
+
+      statusCatcher.handler(context);
+
+      expect(logger.warn).toHaveBeenCalledWith(
+        'RequestStatusCatcher default handler',
+        context
+      );
+    });
+  });
+});

package/dist/templates/react-app/__tests__/src/base/cases/RouterLoader.test.ts

@@ -0,0 +1,235 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * RouterLoader test suite
+ *
+ * Coverage:
+ * 1. constructor      - Initialization and validation
+ * 2. getComponentMaps - Component mapping management
+ * 3. getComponent    - Component resolution
+ * 4. toRoute         - Route transformation
+ * 5. error handling  - Invalid configurations
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { RouterLoader } from '@/base/cases/RouterLoader';
+import type {
+  RouteConfigValue,
+  RouterLoaderOptions
+} from '@/base/cases/RouterLoader';
+import { createElement } from 'react';
+
+describe('RouterLoader', () => {
+  // Mock components and render function
+  const mockHomeComponent = vi.fn(() => createElement('div', { id: 'home' }));
+  const mockAboutComponent = vi.fn(() => createElement('div', { id: 'about' }));
+  const mockNotFoundComponent = vi.fn(() =>
+    createElement('div', { id: '404' })
+  );
+  const mockRender = vi.fn((route) =>
+    createElement('div', null, route.element())
+  );
+
+  let defaultOptions: RouterLoaderOptions;
+
+  beforeEach(() => {
+    defaultOptions = {
+      routes: [
+        {
+          path: '/',
+          element: 'Home',
+          children: [
+            {
+              path: 'about',
+              element: 'About'
+            }
+          ]
+        }
+      ],
+      componentMaps: {
+        Home: mockHomeComponent,
+        About: mockAboutComponent,
+        '404': mockNotFoundComponent
+      },
+      render: mockRender
+    };
+
+    vi.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create instance with valid options', () => {
+      const loader = new RouterLoader(defaultOptions);
+      expect(loader).toBeInstanceOf(RouterLoader);
+    });
+
+    it('should throw error when render is not provided', () => {
+      const invalidOptions = { ...defaultOptions, render: undefined };
+      expect(() => new RouterLoader(invalidOptions as any)).toThrow(
+        'RouterLoader render is required'
+      );
+    });
+  });
+
+  describe('getComponentMaps', () => {
+    it('should return component maps', () => {
+      const loader = new RouterLoader(defaultOptions);
+      const maps = loader.getComponentMaps();
+      expect(maps).toEqual(defaultOptions.componentMaps);
+    });
+
+    it('should return empty object when no component maps provided', () => {
+      const options = { ...defaultOptions, componentMaps: undefined };
+      const loader = new RouterLoader(options);
+      expect(loader.getComponentMaps()).toEqual({});
+    });
+  });
+
+  describe('getComponent', () => {
+    let loader: RouterLoader;
+
+    beforeEach(() => {
+      loader = new RouterLoader(defaultOptions);
+    });
+
+    it('should return component for valid element', () => {
+      const component = loader.getComponent('Home');
+      expect(component).toBe(mockHomeComponent);
+    });
+
+    it('should throw error for non-existent component', () => {
+      expect(() => loader.getComponent('NonExistent')).toThrow(
+        'Component not found: NonExistent'
+      );
+    });
+
+    it('should return 404 component for empty element', () => {
+      const component = loader.getComponent('404');
+      expect(component).toBe(mockNotFoundComponent);
+    });
+  });
+
+  describe('toRoute', () => {
+    let loader: RouterLoader;
+    let consoleWarnSpy: any;
+
+    beforeEach(() => {
+      loader = new RouterLoader(defaultOptions);
+      consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('should transform route configuration correctly', () => {
+      const route: RouteConfigValue = {
+        path: '/test',
+        element: 'Home'
+      };
+
+      const result = loader.toRoute(route);
+
+      expect(result.path).toBe('/test');
+      expect(result.element).toBeTruthy();
+      expect(mockRender).toHaveBeenCalled();
+    });
+
+    it('should handle nested routes', () => {
+      const route: RouteConfigValue = {
+        path: '/parent',
+        element: 'Home',
+        children: [
+          {
+            path: 'child',
+            element: 'About'
+          }
+        ]
+      };
+
+      const result = loader.toRoute(route);
+
+      expect(result.path).toBe('/parent');
+      expect(result.children).toHaveLength(1);
+      expect(result.children![0].path).toBe('child');
+    });
+
+    it('should warn and use 404 component for invalid element', () => {
+      const route: RouteConfigValue = {
+        path: '/invalid',
+        element: undefined
+      };
+
+      const result = loader.toRoute(route);
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Invalid route, path is: /invalid, element is: undefined'
+      );
+      expect(result.element).toBeTruthy();
+      expect(mockRender).toHaveBeenCalled();
+    });
+
+    it('should preserve route metadata', () => {
+      const route: RouteConfigValue = {
+        path: '/meta',
+        element: 'Home',
+        meta: {
+          title: 'Test Page',
+          description: 'A test page',
+          category: 'main'
+        }
+      };
+
+      const result = loader.toRoute(route);
+
+      expect(result.path).toBe('/meta');
+      expect((result as any).meta).toEqual({
+        title: 'Test Page',
+        description: 'A test page',
+        category: 'main'
+      });
+    });
+
+    it('should handle empty children array', () => {
+      const route: RouteConfigValue = {
+        path: '/empty',
+        element: 'Home',
+        children: []
+      };
+
+      const result = loader.toRoute(route);
+
+      expect(result.children).toEqual([]);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle missing component maps gracefully', () => {
+      const options = {
+        routes: defaultOptions.routes,
+        render: mockRender
+      };
+
+      const loader = new RouterLoader(options);
+      expect(() => loader.getComponent('Home')).toThrow(
+        'Component not found: Home'
+      );
+    });
+
+    it('should handle invalid route configurations', () => {
+      const loader = new RouterLoader(defaultOptions);
+      const invalidRoute = {
+        path: '/invalid'
+      } as RouteConfigValue;
+
+      const consoleWarnSpy = vi
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+      loader.toRoute(invalidRoute);
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Invalid route, path is: /invalid, element is: undefined'
+      );
+      consoleWarnSpy.mockRestore();
+    });
+  });
+});

package/dist/templates/react-app/__tests__/src/base/services/I18nService.test.ts

@@ -0,0 +1,224 @@
+/**
+ * I18nService test suite
+ *
+ * Coverage:
+ * 1. constructor      - State initialization
+ * 2. onBefore        - Plugin initialization
+ * 3. changeLanguage  - Language switching
+ * 4. changeLoading   - Loading state management
+ * 5. static methods  - Language validation and retrieval
+ * 6. translation     - Key translation with parameters
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { I18nService, I18nServiceState } from '@/base/services/I18nService';
+import i18n from 'i18next';
+import i18nConfig from '@config/i18n';
+
+const { supportedLngs, fallbackLng } = i18nConfig;
+
+// Mock i18next
+vi.mock('i18next', () => ({
+  default: {
+    use: vi.fn().mockReturnThis(),
+    init: vi.fn(),
+    t: vi.fn(),
+    changeLanguage: vi.fn(),
+    language: 'en',
+    services: {
+      languageDetector: {
+        addDetector: vi.fn()
+      }
+    }
+  }
+}));
+
+// Mock react-i18next
+vi.mock('react-i18next', () => ({
+  initReactI18next: {}
+}));
+
+// Mock i18next-browser-languagedetector
+vi.mock('i18next-browser-languagedetector', () => ({
+  default: {}
+}));
+
+// Mock i18next-http-backend
+vi.mock('i18next-http-backend', () => ({
+  default: {}
+}));
+
+describe('I18nService', () => {
+  let service: I18nService;
+  const testPath = '/en/test/path';
+
+  beforeEach(() => {
+    service = new I18nService(testPath);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with correct state', () => {
+      expect(service.state).toBeInstanceOf(I18nServiceState);
+      expect(service.state.language).toBe('en');
+      expect(service.state.loading).toBe(false);
+    });
+
+    it('should have correct plugin name', () => {
+      expect(service.pluginName).toBe('I18nService');
+    });
+
+    it('should initialize with correct selector', () => {
+      const state = new I18nServiceState('en');
+      expect(service.selector.loading(state)).toBe(false);
+    });
+  });
+
+  describe('onBefore', () => {
+    it('should initialize i18n with correct configuration', () => {
+      service.onBefore();
+
+      expect(i18n.use).toHaveBeenCalledTimes(3);
+      expect(i18n.init).toHaveBeenCalledWith(
+        expect.objectContaining({
+          debug: false,
+          detection: {
+            order: ['pathLanguageDetector', 'navigator'],
+            caches: []
+          }
+        })
+      );
+    });
+
+    it('should add custom language detector', () => {
+      service.onBefore();
+
+      expect(i18n.services.languageDetector.addDetector).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'pathLanguageDetector',
+          lookup: expect.any(Function),
+          cacheUserLanguage: expect.any(Function)
+        })
+      );
+    });
+
+    it('should detect language from path correctly', () => {
+      service.onBefore();
+      const detector = vi.mocked(i18n.services.languageDetector.addDetector)
+        .mock.calls[0][0];
+      const language = detector.lookup();
+      expect(language).toBe('en');
+    });
+
+    it('should return fallback language for invalid path', () => {
+      const invalidService = new I18nService('/invalid/path');
+      invalidService.onBefore();
+      const detector = vi.mocked(i18n.services.languageDetector.addDetector)
+        .mock.calls[0][0];
+      const language = detector.lookup();
+      expect(language).toBe(fallbackLng);
+    });
+  });
+
+  describe('changeLanguage', () => {
+    it('should change language using i18n', async () => {
+      await service.changeLanguage('en');
+      expect(i18n.changeLanguage).toHaveBeenCalledWith('en');
+    });
+
+    it('should handle language change error', async () => {
+      vi.mocked(i18n.changeLanguage).mockRejectedValueOnce(
+        new Error('Change failed')
+      );
+      await expect(service.changeLanguage('en')).rejects.toThrow(
+        'Change failed'
+      );
+    });
+  });
+
+  describe('changeLoading', () => {
+    it('should update loading state', () => {
+      const emitSpy = vi.spyOn(service, 'emit');
+      service.changeLoading(true);
+      expect(emitSpy).toHaveBeenCalledWith({
+        language: 'en',
+        loading: true
+      });
+    });
+
+    it('should preserve current state when changing loading', () => {
+      const currentState = service.state;
+      service.changeLoading(true);
+      expect(service.state).toEqual({
+        ...currentState,
+        loading: true
+      });
+    });
+  });
+
+  describe('static methods', () => {
+    describe('getCurrentLanguage', () => {
+      it('should return current i18n language', () => {
+        expect(I18nService.getCurrentLanguage()).toBe('en');
+      });
+    });
+
+    describe('isValidLanguage', () => {
+      it('should validate supported languages', () => {
+        for (const lang of supportedLngs) {
+          expect(I18nService.isValidLanguage(lang)).toBe(true);
+        }
+      });
+
+      it('should reject unsupported languages', () => {
+        expect(I18nService.isValidLanguage('invalid')).toBe(false);
+      });
+    });
+  });
+
+  describe('translation', () => {
+    beforeEach(() => {
+      // @ts-expect-error
+      vi.mocked(i18n.t).mockImplementation((key) => `translated_${key}`);
+    });
+
+    it('should translate key without parameters', () => {
+      const key = 'test.key';
+      const result = service.t(key);
+      expect(result).toBe('translated_test.key');
+      expect(i18n.t).toHaveBeenCalledWith(key, {
+        lng: 'en'
+      });
+    });
+
+    it('should translate key with parameters', () => {
+      const key = 'test.key';
+      const params = { value: 'test' };
+      const result = service.t(key, params);
+      expect(result).toBe('translated_test.key');
+      expect(i18n.t).toHaveBeenCalledWith(key, {
+        lng: 'en',
+        ...params
+      });
+    });
+
+    it('should return key when translation is empty', () => {
+      vi.mocked(i18n.t).mockReturnValueOnce('');
+      const key = 'test.key';
+      const result = service.t(key);
+      expect(result).toBe(key);
+    });
+
+    it('should return key when translation equals key', () => {
+      // @ts-expect-error
+      vi.mocked(i18n.t).mockImplementation((key) => key);
+      const key = 'test.key';
+      const result = service.t(key);
+      expect(result).toBe(key);
+    });
+  });
+});