@qlover/create-app 0.6.2 → 0.7.0

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

@@ -0,0 +1,288 @@
+/**
+ * AppConfig test suite
+ *
+ * Coverage:
+ * 1. constructor       - Constructor initialization
+ * 2. basic properties - App name, version, etc.
+ * 3. OpenAI configuration
+ * 4. Login configuration
+ * 5. API endpoints
+ * 6. Environment detection
+ * 7. Default values
+ * 8. Configuration validation
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { AppConfig } from '@/base/cases/AppConfig';
+import { InjectEnv } from '@qlover/corekit-bridge';
+import { envBlackList, envPrefix } from '@config/common';
+
+// Mock import.meta.env
+const mockImportMetaEnv = {
+  VITE_USER_NODE_ENV: 'test',
+  VITE_APP_NAME: 'TestApp',
+  VITE_APP_VERSION: '1.0.0',
+  VITE_USER_TOKEN_STORAGE_KEY: 'test_user_token',
+  VITE_USER_INFO_STORAGE_KEY: 'test_user_info',
+  VITE_OPEN_AI_BASE_URL: 'https://api.openai.com',
+  VITE_OPEN_AI_TOKEN: 'test_openai_token',
+  VITE_OPEN_AI_TOKEN_PREFIX: 'Bearer',
+  VITE_OPEN_AI_REQUIRE_TOKEN: 'true',
+  VITE_LOGIN_USER: 'testuser',
+  VITE_LOGIN_PASSWORD: 'testpass',
+  VITE_FE_API_BASE_URL: 'https://api.fe.com',
+  VITE_USER_API_BASE_URL: 'https://api.user.com',
+  VITE_AI_API_BASE_URL: 'https://api.ai.com',
+  VITE_AI_API_TOKEN: 'test_ai_token',
+  VITE_AI_API_TOKEN_PREFIX: 'Bearer',
+  VITE_AI_API_REQUIRE_TOKEN: 'true',
+  VITE_BOOT_HREF: 'https://test.com'
+};
+
+// Mock window.location
+const mockLocation = {
+  href: 'https://test.com/app'
+};
+
+// Helper function to inject environment variables using InjectEnv plugin
+function injectEnvVariables(
+  config: AppConfig,
+  envVars: Record<string, string>
+) {
+  const injectEnv = new InjectEnv({
+    target: config,
+    source: envVars,
+    prefix: envPrefix,
+    blackList: envBlackList
+  });
+
+  injectEnv.onBefore();
+}
+
+describe('AppConfig', () => {
+  let appConfig: AppConfig;
+  let originalImportMetaEnv: Record<string, string>;
+  let originalLocation: Location;
+
+  beforeEach(() => {
+    // Save original values
+    originalImportMetaEnv = { ...import.meta.env };
+    originalLocation = window.location;
+
+    // Mock import.meta.env
+    Object.defineProperty(import.meta, 'env', {
+      value: { ...mockImportMetaEnv },
+      writable: true
+    });
+
+    // Mock window.location
+    Object.defineProperty(window, 'location', {
+      value: mockLocation,
+      writable: true
+    });
+
+    appConfig = new AppConfig();
+
+    // Simulate environment variable injection
+    injectEnvVariables(appConfig, mockImportMetaEnv);
+  });
+
+  afterEach(() => {
+    // Restore original values
+    Object.defineProperty(import.meta, 'env', {
+      value: originalImportMetaEnv,
+      writable: true
+    });
+    Object.defineProperty(window, 'location', {
+      value: originalLocation,
+      writable: true
+    });
+  });
+
+  describe('Basic Properties', () => {
+    it('should have correct appName', () => {
+      expect(appConfig.appName).toBe('TestApp');
+    });
+
+    it('should have correct appVersion', () => {
+      expect(appConfig.appVersion).toBe('1.0.0');
+    });
+
+    it('should have correct env', () => {
+      // because blackList
+      expect(appConfig.env).toBeUndefined();
+    });
+
+    it('should have correct userTokenStorageKey', () => {
+      expect(appConfig.userTokenStorageKey).toBe('test_user_token');
+    });
+
+    it('should have correct userInfoStorageKey', () => {
+      expect(appConfig.userInfoStorageKey).toBe('test_user_info');
+    });
+  });
+
+  describe('OpenAI Configuration', () => {
+    it('should have correct openAiModels', () => {
+      const expectedModels = [
+        'gpt-4o-mini',
+        'gpt-3.5-turbo',
+        'gpt-3.5-turbo-2',
+        'gpt-4',
+        'gpt-4-32k'
+      ];
+      expect(appConfig.openAiModels).toEqual(expectedModels);
+    });
+
+    it('should have correct openAiBaseUrl', () => {
+      expect(appConfig.openAiBaseUrl).toBe('https://api.openai.com');
+    });
+
+    it('should have correct openAiToken', () => {
+      expect(appConfig.openAiToken).toBe('test_openai_token');
+    });
+
+    it('should have correct openAiTokenPrefix', () => {
+      expect(appConfig.openAiTokenPrefix).toBe('Bearer');
+    });
+
+    it('should have correct openAiRequireToken', () => {
+      expect(appConfig.openAiRequireToken).toBe(true);
+    });
+  });
+
+  describe('Login Configuration', () => {
+    it('should have correct loginUser', () => {
+      expect(appConfig.loginUser).toBe('testuser');
+    });
+
+    it('should have correct loginPassword', () => {
+      expect(appConfig.loginPassword).toBe('testpass');
+    });
+  });
+
+  describe('API Configuration', () => {
+    it('should have correct feApiBaseUrl', () => {
+      expect(appConfig.feApiBaseUrl).toBe('https://api.fe.com');
+    });
+
+    it('should have correct userApiBaseUrl', () => {
+      expect(appConfig.userApiBaseUrl).toBe('https://api.user.com');
+    });
+
+    it('should have correct aiApiBaseUrl', () => {
+      expect(appConfig.aiApiBaseUrl).toBe('https://api.ai.com');
+    });
+
+    it('should have correct aiApiToken', () => {
+      expect(appConfig.aiApiToken).toBe('test_ai_token');
+    });
+
+    it('should have correct aiApiTokenPrefix', () => {
+      expect(appConfig.aiApiTokenPrefix).toBe('Bearer');
+    });
+
+    it('should have correct aiApiRequireToken', () => {
+      expect(appConfig.aiApiRequireToken).toBe(true);
+    });
+  });
+
+  describe('Boot Configuration', () => {
+    it('should have correct bootHref', () => {
+      expect(appConfig.bootHref).toBe('https://test.com');
+    });
+  });
+
+  describe('Environment Detection', () => {
+    it('should correctly identify production environment', () => {
+      const productionConfig = new AppConfig('production');
+      expect(productionConfig.isProduction).toBe(true);
+    });
+
+    it('should correctly identify non-production environment', () => {
+      // Mock development environment
+      Object.defineProperty(import.meta, 'env', {
+        value: { ...mockImportMetaEnv, VITE_USER_NODE_ENV: 'development' },
+        writable: true
+      });
+
+      const developmentConfig = new AppConfig();
+      expect(developmentConfig.isProduction).toBe(false);
+    });
+
+    it('should correctly identify test environment', () => {
+      expect(appConfig.isProduction).toBe(false);
+    });
+  });
+
+  describe('Property Types', () => {
+    it('should have correct property types', () => {
+      expect(typeof appConfig.appName).toBe('string');
+      expect(typeof appConfig.appVersion).toBe('string');
+      expect(appConfig.env).toBeUndefined(); // because blackList
+      expect(typeof appConfig.userInfoStorageKey).toBe('string');
+    });
+  });
+
+  describe('Default Values', () => {
+    it('should have sensible default values when environment variables are not set', () => {
+      // Mock empty environment
+      Object.defineProperty(import.meta, 'env', {
+        value: {},
+        writable: true
+      });
+
+      const defaultConfig = new AppConfig();
+      // Don't inject environment variables to test defaults
+
+      expect(defaultConfig.appName).toBe('');
+      expect(defaultConfig.appVersion).toBe('');
+      expect(defaultConfig.userTokenStorageKey).toBe('__fe_user_token__');
+      expect(defaultConfig.userInfoStorageKey).toBe('__fe_user_info__');
+      expect(defaultConfig.openAiRequireToken).toBe(true);
+      expect(defaultConfig.aiApiBaseUrl).toBe('https://api.openai.com/v1');
+      expect(defaultConfig.aiApiTokenPrefix).toBe('Bearer');
+      expect(defaultConfig.aiApiRequireToken).toBe(true);
+    });
+  });
+
+  describe('Configuration Validation', () => {
+    it('should have valid OpenAI models configuration', () => {
+      expect(Array.isArray(appConfig.openAiModels)).toBe(true);
+      expect(appConfig.openAiModels.length).toBeGreaterThan(0);
+
+      // Check that all models are strings
+      appConfig.openAiModels.forEach((model) => {
+        expect(typeof model).toBe('string');
+        expect(model.length).toBeGreaterThan(0);
+      });
+    });
+
+    it('should have valid storage keys', () => {
+      expect(typeof appConfig.userTokenStorageKey).toBe('string');
+      expect(typeof appConfig.userInfoStorageKey).toBe('string');
+      expect(appConfig.userTokenStorageKey.length).toBeGreaterThan(0);
+      expect(appConfig.userInfoStorageKey.length).toBeGreaterThan(0);
+    });
+
+    it('should have valid API URLs when provided', () => {
+      // Test with valid URLs
+      const validUrlConfig = new AppConfig();
+      if (validUrlConfig.aiApiBaseUrl) {
+        expect(validUrlConfig.aiApiBaseUrl).toMatch(/^https?:\/\//);
+      }
+    });
+  });
+
+  describe('Instance Creation', () => {
+    it('should create new instance with default values', () => {
+      const newConfig = new AppConfig();
+      expect(newConfig).toBeInstanceOf(AppConfig);
+    });
+
+    it('should create new instance with custom environment', () => {
+      const customConfig = new AppConfig('custom');
+      expect(customConfig.env).toBe('custom');
+    });
+  });
+});

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

@@ -0,0 +1,102 @@
+/**
+ * AppError test suite
+ *
+ * Coverage:
+ * 1. constructor       - Constructor initialization with different source types
+ * 2. inheritance      - Verify inheritance from ExecutorError
+ * 3. error properties - Verify error properties are set correctly
+ */
+
+import { describe, it, expect } from 'vitest';
+import { AppError } from '@/base/cases/AppError';
+import { ExecutorError } from '@qlover/fe-corekit';
+
+describe('AppError', () => {
+  describe('constructor', () => {
+    it('should create instance with id only', () => {
+      const error = new AppError('TEST_ERROR');
+      expect(error).toBeInstanceOf(AppError);
+      expect(error).toBeInstanceOf(ExecutorError);
+      expect(error).toBeInstanceOf(Error);
+      expect(error.id).toBe('TEST_ERROR');
+      expect(error.message).toBe('TEST_ERROR');
+      expect(error.source).toBeUndefined();
+    });
+
+    it('should create instance with string source', () => {
+      const source = 'Test error message';
+      const error = new AppError('TEST_ERROR', source);
+      expect(error.id).toBe('TEST_ERROR');
+      expect(error.message).toBe(source);
+      expect(error.source).toBe(source);
+    });
+
+    it('should create instance with Error source', () => {
+      const source = new Error('Original error');
+      const error = new AppError('TEST_ERROR', source);
+      expect(error.id).toBe('TEST_ERROR');
+      expect(error.message).toBe('Original error');
+      expect(error.source).toBe(source);
+    });
+  });
+
+  describe('error properties', () => {
+    it('should have correct error type', () => {
+      const error = new AppError('TEST_ERROR');
+      expect(error.id).toBe('TEST_ERROR');
+    });
+
+    it('should maintain id property', () => {
+      const error = new AppError('TEST_ERROR');
+      Object.defineProperty(error, 'id', { value: 'NEW_ID' });
+      expect(error.id).toBe('NEW_ID');
+    });
+
+    it('should maintain source property', () => {
+      const source = 'source';
+      const error = new AppError('TEST_ERROR', source);
+      Object.defineProperty(error, 'source', { value: 'new source' });
+      expect(error.source).toBe('new source');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should work in try-catch block', () => {
+      expect(() => {
+        throw new AppError('TEST_ERROR');
+      }).toThrow(AppError);
+    });
+
+    it('should preserve stack trace', () => {
+      const error = new AppError('TEST_ERROR');
+      expect(error.stack).toBeDefined();
+      expect(error.stack).toContain('AppError.test.ts');
+    });
+
+    it('should handle nested errors', () => {
+      const originalError = new Error('Original error');
+      const wrappedError = new AppError('WRAPPED_ERROR', originalError);
+      expect(wrappedError.source).toBe(originalError);
+      expect(wrappedError.message).toBe('Original error');
+    });
+  });
+
+  describe('error message formatting', () => {
+    it('should use id as message when source is undefined', () => {
+      const error = new AppError('TEST_ERROR');
+      expect(error.message).toBe('TEST_ERROR');
+    });
+
+    it('should use source message when source is Error', () => {
+      const source = new Error('Source error message');
+      const error = new AppError('TEST_ERROR', source);
+      expect(error.message).toBe('Source error message');
+    });
+
+    it('should use source string when source is string', () => {
+      const source = 'Source error message';
+      const error = new AppError('TEST_ERROR', source);
+      expect(error.message).toBe('Source error message');
+    });
+  });
+});

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

@@ -0,0 +1,228 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * DialogHandler test suite
+ *
+ * Coverage:
+ * 1. constructor       - Constructor initialization
+ * 2. setters          - Message, Modal, Notification setters
+ * 3. formatErrorMessage - Error message formatting
+ * 4. notification methods - success, error, info, warn
+ * 5. confirm method   - Modal confirmation
+ * 6. edge cases       - Null/undefined handling
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { DialogHandler } from '../../../../src/base/cases/DialogHandler';
+import type {
+  MessageApi,
+  ModalApi,
+  NotificationApi
+} from '@brain-toolkit/antd-theme-override/react';
+import type { ConfirmOptions } from '../../../../src/base/port/InteractionHubInterface';
+
+describe('DialogHandler', () => {
+  let dialogHandler: DialogHandler;
+  let mockMessage: MessageApi;
+  let mockModal: ModalApi;
+  let mockNotification: NotificationApi;
+
+  beforeEach(() => {
+    // Create mock APIs
+    mockMessage = {
+      success: vi.fn(),
+      error: vi.fn(),
+      info: vi.fn(),
+      warning: vi.fn()
+    } as unknown as MessageApi;
+
+    mockModal = {
+      confirm: vi.fn()
+    } as unknown as ModalApi;
+
+    mockNotification = {
+      success: vi.fn(),
+      error: vi.fn(),
+      info: vi.fn(),
+      warning: vi.fn()
+    } as unknown as NotificationApi;
+
+    // Initialize DialogHandler
+    dialogHandler = new DialogHandler();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create instance with empty antds object', () => {
+      expect(dialogHandler).toBeInstanceOf(DialogHandler);
+      expect((dialogHandler as any).antds).toEqual({});
+    });
+  });
+
+  describe('setters', () => {
+    it('should set message api', () => {
+      dialogHandler.setMessage(mockMessage);
+      expect((dialogHandler as any).antds.message).toBe(mockMessage);
+    });
+
+    it('should set modal api', () => {
+      dialogHandler.setModal(mockModal);
+      expect((dialogHandler as any).antds.modal).toBe(mockModal);
+    });
+
+    it('should set notification api', () => {
+      dialogHandler.setNotification(mockNotification);
+      expect((dialogHandler as any).antds.notification).toBe(mockNotification);
+    });
+  });
+
+  describe('formatErrorMessage', () => {
+    it('should format Error object', () => {
+      const error = new Error('test error');
+      const result = (dialogHandler as any).formatErrorMessage(error);
+      expect(result).toBe('test error');
+    });
+
+    it('should format string error', () => {
+      const result = (dialogHandler as any).formatErrorMessage('test error');
+      expect(result).toBe('test error');
+    });
+
+    it('should handle unknown error type', () => {
+      const result = (dialogHandler as any).formatErrorMessage({});
+      expect(result).toBe('An unknown error occurred');
+    });
+  });
+
+  describe('notification methods', () => {
+    beforeEach(() => {
+      dialogHandler.setMessage(mockMessage);
+    });
+
+    describe('success', () => {
+      it('should call message.success with content', () => {
+        dialogHandler.success('test success');
+        expect(mockMessage.success).toHaveBeenCalledWith({
+          content: 'test success'
+        });
+      });
+
+      it('should pass through options', () => {
+        const options = { duration: 5000 };
+        dialogHandler.success('test success', options);
+        expect(mockMessage.success).toHaveBeenCalledWith({
+          content: 'test success',
+          ...options
+        });
+      });
+    });
+
+    describe('error', () => {
+      it('should call message.error with content', () => {
+        dialogHandler.error('test error');
+        expect(mockMessage.error).toHaveBeenCalledWith({
+          content: 'test error'
+        });
+      });
+
+      it('should format error from options', () => {
+        const error = new Error('formatted error');
+        const options = { error };
+        dialogHandler.error('test error', options);
+        expect(mockMessage.error).toHaveBeenCalledWith({
+          content: 'formatted error',
+          error
+        });
+      });
+
+      it('should pass through additional options', () => {
+        const error = new Error('formatted error');
+        const options = { error, duration: 5000 };
+        dialogHandler.error('test error', options);
+        expect(mockMessage.error).toHaveBeenCalledWith({
+          content: 'formatted error',
+          error,
+          duration: 5000
+        });
+      });
+    });
+
+    describe('info', () => {
+      it('should call message.info with content', () => {
+        dialogHandler.info('test info');
+        expect(mockMessage.info).toHaveBeenCalledWith({
+          content: 'test info'
+        });
+      });
+
+      it('should pass through options', () => {
+        const options = { duration: 5000 };
+        dialogHandler.info('test info', options);
+        expect(mockMessage.info).toHaveBeenCalledWith({
+          content: 'test info',
+          ...options
+        });
+      });
+    });
+
+    describe('warn', () => {
+      it('should call message.warning with content', () => {
+        dialogHandler.warn('test warning');
+        expect(mockMessage.warning).toHaveBeenCalledWith({
+          content: 'test warning'
+        });
+      });
+
+      it('should pass through options', () => {
+        const options = { duration: 5000 };
+        dialogHandler.warn('test warning', options);
+        expect(mockMessage.warning).toHaveBeenCalledWith({
+          content: 'test warning',
+          ...options
+        });
+      });
+    });
+  });
+
+  describe('confirm', () => {
+    beforeEach(() => {
+      dialogHandler.setModal(mockModal);
+    });
+
+    it('should call modal.confirm with options', () => {
+      const options: ConfirmOptions = {
+        title: 'Confirm',
+        content: 'Are you sure?',
+        onOk: vi.fn(),
+        onCancel: vi.fn()
+      };
+      dialogHandler.confirm(options);
+      expect(mockModal.confirm).toHaveBeenCalledWith(options);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle undefined message api', () => {
+      expect(() => dialogHandler.success('test')).not.toThrow();
+      expect(() => dialogHandler.error('test')).not.toThrow();
+      expect(() => dialogHandler.info('test')).not.toThrow();
+      expect(() => dialogHandler.warn('test')).not.toThrow();
+    });
+
+    it('should handle undefined modal api', () => {
+      const options: ConfirmOptions = {
+        title: 'test',
+        content: 'test content'
+      };
+      expect(() => dialogHandler.confirm(options)).not.toThrow();
+    });
+
+    it('should handle undefined notification api', () => {
+      expect(() =>
+        dialogHandler.setNotification(undefined as any)
+      ).not.toThrow();
+    });
+  });
+});