@qlover/create-app 0.6.3 → 0.7.1

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

@@ -0,0 +1,207 @@
+/**
+ * I18nKeyErrorPlugin test suite
+ *
+ * Coverage:
+ * 1. constructor       - Constructor initialization
+ * 2. plugin name      - Plugin name verification
+ * 3. onError handling - Error translation behavior
+ * 4. edge cases       - Various error scenarios
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { I18nKeyErrorPlugin } from '@/base/cases/I18nKeyErrorPlugin';
+import { MockLogger } from '../../../__mocks__/MockLogger';
+import { MockI18nService } from '../../../__mocks__/I18nService';
+import type { ExecutorContext } from '@qlover/fe-corekit';
+
+describe('I18nKeyErrorPlugin', () => {
+  let plugin: I18nKeyErrorPlugin;
+  let mockLogger: MockLogger;
+  let mockI18nService: MockI18nService;
+
+  beforeEach(() => {
+    mockLogger = new MockLogger();
+    mockI18nService = new MockI18nService();
+    plugin = new I18nKeyErrorPlugin(mockLogger, mockI18nService);
+  });
+
+  describe('plugin properties', () => {
+    it('should have correct plugin name', () => {
+      expect(plugin.pluginName).toBe('I18nKeyErrorPlugin');
+    });
+  });
+
+  describe('onError handling', () => {
+    it('should handle non-Error objects', () => {
+      const context: ExecutorContext<unknown> = {
+        error: new Error('not an error'),
+        parameters: {},
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+      const result = plugin.onError(context);
+      expect(result).toBeUndefined();
+      expect(mockLogger.debug).not.toHaveBeenCalled();
+      expect(mockI18nService.t).toHaveBeenCalledWith('not an error');
+    });
+
+    it('should handle Error objects without i18n key', () => {
+      const error = new Error('regular error');
+      const context: ExecutorContext<unknown> = {
+        error,
+        parameters: {},
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+      const result = plugin.onError(context);
+      expect(result).toBeUndefined();
+      expect(mockLogger.debug).not.toHaveBeenCalled();
+      expect(mockI18nService.t).toHaveBeenCalledWith('regular error');
+    });
+
+    it('should translate i18n key errors', () => {
+      const error = new Error('error.key');
+      mockI18nService.t.mockReturnValueOnce('Translated error message');
+
+      const context: ExecutorContext<unknown> = {
+        error,
+        parameters: {},
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+
+      const result = plugin.onError(context);
+
+      expect(result).toBeInstanceOf(Error);
+      expect(result?.message).toBe('Translated error message');
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        'I18nKeyErrorPlugin Error:',
+        'Translated error message'
+      );
+      expect(mockI18nService.t).toHaveBeenCalledWith('error.key');
+    });
+
+    it('should not translate when i18n returns same key', () => {
+      const error = new Error('error.key');
+      mockI18nService.t.mockReturnValueOnce('error.key');
+
+      const context: ExecutorContext<unknown> = {
+        error,
+        parameters: {},
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+
+      const result = plugin.onError(context);
+
+      expect(result).toBeUndefined();
+      expect(mockLogger.debug).not.toHaveBeenCalled();
+      expect(mockI18nService.t).toHaveBeenCalledWith('error.key');
+    });
+  });
+
+  describe('error translation', () => {
+    it('should handle complex i18n keys with parameters', () => {
+      const error = new Error('error.with.params');
+      mockI18nService.t.mockReturnValueOnce(
+        'Error with param1: {0} and param2: {1}'
+      );
+
+      const context: ExecutorContext<unknown> = {
+        error,
+        parameters: { param1: 'value1', param2: 'value2' },
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+
+      const result = plugin.onError(context);
+
+      expect(result).toBeInstanceOf(Error);
+      expect(mockI18nService.t).toHaveBeenCalledWith('error.with.params');
+      expect(mockLogger.debug).toHaveBeenCalled();
+    });
+
+    it('should handle nested error objects', () => {
+      const originalError = new Error('original.error');
+      const wrappedError = new Error('wrapped.error');
+      // @ts-expect-error
+      wrappedError.cause = originalError;
+
+      mockI18nService.t
+        .mockReturnValueOnce('Wrapped Error')
+        .mockReturnValueOnce('Original Error');
+
+      const context: ExecutorContext<unknown> = {
+        error: wrappedError,
+        parameters: {},
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+
+      const result = plugin.onError(context);
+
+      expect(result).toBeInstanceOf(Error);
+      expect(mockI18nService.t).toHaveBeenCalledWith('wrapped.error');
+      expect(mockLogger.debug).toHaveBeenCalled();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty error message', () => {
+      const error = new Error('');
+      const context: ExecutorContext<unknown> = {
+        error,
+        parameters: {},
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+      const result = plugin.onError(context);
+      expect(result).toBeUndefined();
+      expect(mockLogger.debug).not.toHaveBeenCalled();
+      // Empty string is not a valid i18n key, so t() should not be called
+      expect(mockI18nService.t).not.toHaveBeenCalled();
+    });
+
+    it('should handle null error message', () => {
+      const error = new Error();
+      error.message = ''; // Force empty message
+      const context: ExecutorContext<unknown> = {
+        error,
+        parameters: {},
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+      const result = plugin.onError(context);
+      expect(result).toBeUndefined();
+      expect(mockLogger.debug).not.toHaveBeenCalled();
+      // Empty string is not a valid i18n key, so t() should not be called
+      expect(mockI18nService.t).not.toHaveBeenCalled();
+    });
+
+    it('should handle undefined context error', () => {
+      const context: ExecutorContext<unknown> = {
+        error: undefined,
+        parameters: {},
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+      const result = plugin.onError(context);
+      expect(result).toBeUndefined();
+      expect(mockLogger.debug).not.toHaveBeenCalled();
+      expect(mockI18nService.t).not.toHaveBeenCalled();
+    });
+
+    it('should handle null context error', () => {
+      const context: ExecutorContext<unknown> = {
+        error: undefined,
+        parameters: {},
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+      const result = plugin.onError(context);
+      expect(result).toBeUndefined();
+      expect(mockLogger.debug).not.toHaveBeenCalled();
+      expect(mockI18nService.t).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -0,0 +1,181 @@
+/**
+ * InversifyContainer test-suite
+ *
+ * Coverage:
+ * 1. constructor      - Container initialization tests
+ * 2. bind            - Value binding tests
+ * 3. get             - Value retrieval tests
+ * 4. auto-binding    - Injectable class auto-binding tests
+ * 5. singleton scope - Singleton pattern verification tests
+ * 6. error handling  - Error cases and boundary tests
+ */
+
+import { InversifyContainer } from '@/base/cases/InversifyContainer';
+import { injectable } from 'inversify';
+
+describe('InversifyContainer', () => {
+  let container: InversifyContainer;
+
+  beforeEach(() => {
+    container = new InversifyContainer();
+  });
+
+  describe('constructor', () => {
+    it('should create container instance', () => {
+      expect(container).toBeInstanceOf(InversifyContainer);
+    });
+  });
+
+  describe('bind', () => {
+    it('should bind and get constant value', () => {
+      const key = Symbol('test');
+      const value = { test: 'value' };
+
+      container.bind(key, value);
+      const result = container.get(key);
+
+      expect(result).toBe(value);
+    });
+
+    it('should handle multiple bindings', () => {
+      const key1 = Symbol('test1');
+      const key2 = Symbol('test2');
+      const value1 = { test: 'value1' };
+      const value2 = { test: 'value2' };
+
+      container.bind(key1, value1);
+      container.bind(key2, value2);
+
+      expect(container.get(key1)).toBe(value1);
+      expect(container.get(key2)).toBe(value2);
+    });
+
+    it('should handle binding of null and undefined values', () => {
+      const key1 = Symbol('null');
+      const key2 = Symbol('undefined');
+      container.bind(key1, null);
+      container.bind(key2, undefined);
+
+      expect(container.get(key1)).toBeNull();
+      expect(container.get(key2)).toBeUndefined();
+    });
+  });
+
+  describe('get', () => {
+    it('should throw error when getting unbound non-injectable value', () => {
+      const key = Symbol('nonexistent');
+      expect(() => container.get(key)).toThrow();
+    });
+
+    it('should handle retrieval of primitive values', () => {
+      const numberKey = Symbol('number');
+      const stringKey = Symbol('string');
+      const booleanKey = Symbol('boolean');
+
+      container.bind(numberKey, 42);
+      container.bind(stringKey, 'test');
+      container.bind(booleanKey, true);
+
+      expect(container.get(numberKey)).toBe(42);
+      expect(container.get(stringKey)).toBe('test');
+      expect(container.get(booleanKey)).toBe(true);
+    });
+  });
+
+  describe('auto-binding', () => {
+    it('should auto bind injectable class', () => {
+      @injectable()
+      class TestService {
+        getValue(): string {
+          return 'test';
+        }
+      }
+
+      const result = container.get(TestService);
+
+      expect(result).toBeInstanceOf(TestService);
+      expect(result.getValue()).toBe('test');
+    });
+
+    it('should handle manual dependency injection', () => {
+      @injectable()
+      class ServiceA {
+        getValue(): string {
+          return 'A';
+        }
+      }
+
+      @injectable()
+      class ServiceB {
+        constructor(private serviceA: ServiceA) {}
+
+        getValueWithA(): string {
+          return `B with ${this.serviceA.getValue()}`;
+        }
+      }
+
+      const serviceA = container.get(ServiceA);
+      container.bind(ServiceA, serviceA);
+      container.bind(ServiceB, new ServiceB(serviceA));
+
+      const serviceB = container.get(ServiceB);
+      expect(serviceB).toBeInstanceOf(ServiceB);
+      expect(serviceB.getValueWithA()).toBe('B with A');
+    });
+  });
+
+  describe('singleton scope', () => {
+    it('should maintain singleton scope for simple services', () => {
+      @injectable()
+      class TestService {
+        private count = 0;
+        increment(): number {
+          return ++this.count;
+        }
+      }
+
+      const instance1 = container.get(TestService);
+      const instance2 = container.get(TestService);
+
+      instance1.increment();
+      expect(instance2.increment()).toBe(2);
+      expect(instance1).toBe(instance2);
+    });
+
+    it('should maintain singleton scope for complex services', () => {
+      @injectable()
+      class ComplexService {
+        private state = { count: 0 };
+
+        updateState(): { count: number } {
+          this.state.count++;
+          return this.state;
+        }
+      }
+
+      const instance1 = container.get(ComplexService);
+      instance1.updateState();
+      instance1.updateState();
+
+      const instance2 = container.get(ComplexService);
+      expect(instance2.updateState().count).toBe(3);
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw error when getting unbound non-injectable value', () => {
+      const key = Symbol('nonexistent');
+      expect(() => container.get(key)).toThrow();
+    });
+
+    it('should throw error when getting non-existent binding', () => {
+      const nonExistentKey = Symbol('non-existent');
+      expect(() => container.get(nonExistentKey)).toThrow();
+    });
+
+    it('should handle invalid service identifier', () => {
+      expect(() => container.get({} as unknown as symbol)).toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,61 @@
+/**
+ * PublicAssetsPath test suite
+ *
+ * Coverage:
+ * 1. constructor      - Default and custom prefix initialization
+ * 2. getPath         - Simple path concatenation with prefix
+ */
+
+import { describe, it, expect } from 'vitest';
+import { PublicAssetsPath } from '@/base/cases/PublicAssetsPath';
+import { routerPrefix } from '@config/common';
+
+describe('PublicAssetsPath', () => {
+  describe('constructor', () => {
+    it('should initialize with default prefix from config', () => {
+      const publicPath = new PublicAssetsPath();
+      expect(publicPath.getPath('test')).toBe(`${routerPrefix}/test`);
+    });
+
+    it('should initialize with custom prefix', () => {
+      const customPrefix = '/custom';
+      const publicPath = new PublicAssetsPath(customPrefix);
+      expect(publicPath.getPath('test')).toBe('/custom/test');
+    });
+
+    it('should initialize with empty prefix', () => {
+      const publicPath = new PublicAssetsPath('');
+      expect(publicPath.getPath('test')).toBe('/test');
+    });
+  });
+
+  describe('getPath', () => {
+    it('should concatenate prefix with path', () => {
+      const publicPath = new PublicAssetsPath('/prefix');
+      expect(publicPath.getPath('test')).toBe('/prefix/test');
+    });
+
+    it('should handle empty path', () => {
+      const publicPath = new PublicAssetsPath('/prefix');
+      expect(publicPath.getPath('')).toBe('/prefix/');
+    });
+
+    it('should preserve the input path as is', () => {
+      const publicPath = new PublicAssetsPath('/prefix');
+      const paths = [
+        'simple/path',
+        '/path/with/leading/slash',
+        'path/with/trailing/slash/',
+        'path with spaces',
+        'path/with/unicode/字符',
+        'path?with=query#and-hash'
+      ];
+
+      paths.forEach((path) => {
+        expect(publicPath.getPath(path)).toBe(
+          `/prefix/${path.replace(/^\//, '')}`
+        );
+      });
+    });
+  });
+});

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

@@ -0,0 +1,199 @@
+/**
+ * RequestLogger test suite
+ *
+ * Coverage:
+ * 1. constructor      - Logger injection
+ * 2. onBefore        - Request initialization logging
+ * 3. onSuccess       - Successful request logging
+ * 4. onError         - Error handling and logging
+ * 5. loggerError     - Error formatting and logging
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { RequestLogger } from '@/base/cases/RequestLogger';
+import { MockLogger } from '../../../__mocks__/MockLogger';
+import type {
+  ExecutorContext,
+  RequestAdapterFetchConfig,
+  RequestAdapterResponse
+} from '@qlover/fe-corekit';
+import type {
+  ApiCatchPluginConfig,
+  ApiCatchPluginResponse
+} from '@qlover/corekit-bridge';
+
+describe('RequestLogger', () => {
+  let logger: MockLogger;
+  let requestLogger: RequestLogger;
+  let mockDate: Date;
+
+  beforeEach(() => {
+    logger = new MockLogger();
+    requestLogger = new RequestLogger(logger);
+    mockDate = new Date('2024-01-01T12:00:00');
+    vi.spyOn(global, 'Date').mockImplementation(() => mockDate);
+  });
+
+  describe('plugin properties', () => {
+    it('should have correct plugin name', () => {
+      expect(requestLogger.pluginName).toBe('RequestLogger');
+    });
+
+    it('should have logger instance', () => {
+      expect(requestLogger.logger).toBe(logger);
+    });
+  });
+
+  describe('onBefore', () => {
+    it('should log request details before execution', () => {
+      const context: ExecutorContext<RequestAdapterFetchConfig<unknown>> = {
+        parameters: {
+          method: 'GET',
+          url: 'https://api.example.com/data',
+          headers: { 'Content-Type': 'application/json' }
+        },
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+
+      requestLogger.onBefore(context);
+
+      expect(logger.log).toHaveBeenCalledWith(
+        `%c[Request before]%c [${mockDate.toLocaleString()}] GET https://api.example.com/data`,
+        'color: #0ff;',
+        'color: inherit;',
+        context.parameters
+      );
+    });
+  });
+
+  describe('onSuccess', () => {
+    it('should log successful response', async () => {
+      const response = { data: { id: 1 }, status: 200 };
+      const context: ExecutorContext<
+        RequestAdapterFetchConfig & ApiCatchPluginConfig
+      > = {
+        parameters: {
+          method: 'POST',
+          url: 'https://api.example.com/create',
+          headers: { 'Content-Type': 'application/json' }
+        },
+        returnValue: response,
+        hooksRuntimes: {}
+      };
+
+      await requestLogger.onSuccess(context);
+
+      expect(logger.log).toHaveBeenCalledWith(
+        `%c[Request success]%c [${mockDate.toLocaleString()}] POST https://api.example.com/create`,
+        'color: #0f0;',
+        'color: inherit;',
+        response
+      );
+    });
+
+    it('should handle API catch plugin error', async () => {
+      const apiError = {
+        id: 'API_ERROR',
+        message: 'API Error',
+        name: 'ExecutorError'
+      };
+      const response: RequestAdapterResponse & ApiCatchPluginResponse = {
+        data: null,
+        status: 400,
+        statusText: 'Bad Request',
+        headers: {},
+        config: {
+          method: 'GET',
+          url: 'https://api.example.com/error',
+          headers: {}
+        },
+        response: new Response(),
+        apiCatchResult: apiError
+      };
+      const context: ExecutorContext<
+        RequestAdapterFetchConfig & ApiCatchPluginConfig
+      > = {
+        parameters: {
+          method: 'GET',
+          url: 'https://api.example.com/error',
+          headers: {}
+        },
+        returnValue: response,
+        hooksRuntimes: {}
+      };
+
+      await requestLogger.onSuccess(context);
+
+      expect(logger.log).toHaveBeenCalledWith(
+        `%c[Request error]%c [${mockDate.toLocaleString()}] GET https://api.example.com/error`,
+        'color: #f00;',
+        'color: inherit;',
+        apiError
+      );
+    });
+  });
+
+  describe('onError', () => {
+    it('should log request error', () => {
+      const error = new Error('Network error');
+      const context: ExecutorContext<RequestAdapterFetchConfig> = {
+        parameters: {
+          method: 'PUT',
+          url: 'https://api.example.com/update',
+          headers: {}
+        },
+        error,
+        returnValue: undefined,
+        hooksRuntimes: {}
+      };
+
+      requestLogger.onError(context);
+
+      expect(logger.log).toHaveBeenCalledWith(
+        `%c[Request error]%c [${mockDate.toLocaleString()}] PUT https://api.example.com/update`,
+        'color: #f00;',
+        'color: inherit;',
+        error
+      );
+    });
+  });
+
+  describe('loggerError', () => {
+    it('should format and log error details', () => {
+      const config: RequestAdapterFetchConfig = {
+        method: 'DELETE',
+        url: 'https://api.example.com/delete',
+        headers: {}
+      };
+      const error = new Error('Operation failed');
+
+      requestLogger.loggerError(config, error);
+
+      expect(logger.log).toHaveBeenCalledWith(
+        `%c[Request error]%c [${mockDate.toLocaleString()}] DELETE https://api.example.com/delete`,
+        'color: #f00;',
+        'color: inherit;',
+        error
+      );
+    });
+
+    it('should handle non-Error objects', () => {
+      const config: RequestAdapterFetchConfig = {
+        method: 'GET',
+        url: 'https://api.example.com/data',
+        headers: {}
+      };
+      const error = { code: 404, message: 'Not found' };
+
+      requestLogger.loggerError(config, error);
+
+      expect(logger.log).toHaveBeenCalledWith(
+        `%c[Request error]%c [${mockDate.toLocaleString()}] GET https://api.example.com/data`,
+        'color: #f00;',
+        'color: inherit;',
+        error
+      );
+    });
+  });
+});