@qlover/create-app 1.1.0 → 2.0.0

package/dist/templates/react-app/__tests__/src/core/IOC.test.ts

@@ -1,242 +0,0 @@
-import { IOCIdentifier } from '@config/IOCIdentifier';
-import type { AppConfig } from '@/base/cases/AppConfig';
-import { InversifyContainer } from '@/base/cases/InversifyContainer';
-import { ClientIOCRegister } from '@/core/clientIoc/ClientIOCRegister';
-import { IOC } from '@/core/IOC';
-
-describe('IOC Container Tests', () => {
-  let container: InversifyContainer;
-  let mockAppConfig: AppConfig;
-
-  beforeEach(() => {
-    container = new InversifyContainer();
-    mockAppConfig = {
-      appName: '',
-      appVersion: '',
-      env: 'test',
-      userInfoStorageKey: '__fe_user_info__',
-      userTokenStorageKey: '__fe_user_token__',
-      openAiModels: [
-        'gpt-4o-mini',
-        'gpt-3.5-turbo',
-        'gpt-3.5-turbo-2',
-        'gpt-4',
-        'gpt-4-32k'
-      ],
-      openAiBaseUrl: '',
-      openAiToken: '',
-      openAiTokenPrefix: '',
-      openAiRequireToken: true,
-      loginUser: '',
-      loginPassword: '',
-      feApiBaseUrl: '',
-      userApiBaseUrl: '',
-      aiApiBaseUrl: 'https://api.openai.com/v1',
-      aiApiToken: '',
-      aiApiTokenPrefix: 'Bearer',
-      aiApiRequireToken: true,
-      bootHref: '',
-      isProduction: false
-    };
-  });
-
-  describe('InversifyContainer', () => {
-    it('should create container with correct configuration', () => {
-      expect(container).toBeInstanceOf(InversifyContainer);
-    });
-
-    it('should bind and get services correctly', () => {
-      const mockService = { test: 'service' };
-      const mockKey = 'testKey';
-
-      container.bind(mockKey, mockService);
-      const result = container.get(mockKey);
-
-      expect(result).toBe(mockService);
-    });
-
-    it('should handle string identifiers correctly', () => {
-      const mockLogger = { info: vi.fn() };
-      container.bind(IOCIdentifier.Logger, mockLogger);
-
-      const result = container.get(IOCIdentifier.Logger);
-      expect(result).toBe(mockLogger);
-    });
-  });
-
-  describe('IOC Function', () => {
-    it('should be a function', () => {
-      expect(typeof IOC).toBe('function');
-    });
-
-    it('should accept string identifiers', () => {
-      // This test verifies that IOC function can be called with string identifiers
-      // The function should accept the identifier, but will throw if service is not bound
-      expect(() => {
-        IOC('NonExistentService' as any);
-      }).toThrow();
-    });
-
-    it('should get registered services successfully', () => {
-      // Logger is registered during IOC initialization
-      expect(() => {
-        IOC(IOCIdentifier.Logger);
-      }).not.toThrow();
-
-      const logger = IOC(IOCIdentifier.Logger);
-      expect(logger).toBeDefined();
-    });
-
-    it('should accept class constructors', () => {
-      // Mock class for testing
-      class TestService {
-        constructor() {}
-      }
-
-      // if service is not bound, it will return the class itself
-      const result = IOC(TestService);
-      expect(result).toBeInstanceOf(TestService);
-    });
-  });
-
-  describe('IocRegisterImpl', () => {
-    let registerImpl: ClientIOCRegister;
-
-    beforeEach(() => {
-      registerImpl = new ClientIOCRegister({
-        pathname: '/test',
-        appConfig: mockAppConfig
-      });
-    });
-
-    it('should create register implementation correctly', () => {
-      expect(registerImpl).toBeInstanceOf(ClientIOCRegister);
-    });
-
-    it('should register services without throwing', () => {
-      const mockManager = {
-        get: vi.fn(),
-        bind: vi.fn(),
-        implement: vi.fn(),
-        implemention: container
-      };
-
-      expect(() => {
-        registerImpl.register(container, mockManager);
-      }).not.toThrow();
-    });
-  });
-
-  describe('IOCIdentifierMap Type Safety', () => {
-    it('should have correct type mapping for JSON', () => {
-      // This test verifies that the type mapping is correct
-      const identifierMap = {};
-
-      // TypeScript should enforce that these keys exist
-      expect(IOCIdentifier.JSONSerializer in identifierMap).toBeDefined();
-      expect(IOCIdentifier.LocalStorage in identifierMap).toBeDefined();
-      expect(IOCIdentifier.Logger in identifierMap).toBeDefined();
-      expect(IOCIdentifier.AppConfig in identifierMap).toBeDefined();
-    });
-  });
-
-  describe('Service Registration Integration', () => {
-    it('should register global services correctly', async () => {
-      const registerImpl = new ClientIOCRegister({
-        pathname: '/test',
-        appConfig: mockAppConfig
-      });
-
-      const mockManager = {
-        get: vi.fn(),
-        bind: vi.fn(),
-        implement: vi.fn(),
-        implemention: container
-      };
-
-      // This should not throw and should register services
-      expect(() => {
-        registerImpl.register(container, mockManager);
-      }).not.toThrow();
-    });
-
-    it('should handle app config registration', () => {
-      container.bind(IOCIdentifier.AppConfig, mockAppConfig);
-      const result = container.get(IOCIdentifier.AppConfig);
-
-      expect(result).toBe(mockAppConfig);
-      expect(result.appName).toBe('');
-      expect(result.env).toBe('test');
-    });
-
-    it('should handle logger registration', () => {
-      const mockLogger = {
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        debug: vi.fn()
-      };
-
-      container.bind(IOCIdentifier.Logger, mockLogger);
-      const result = container.get(IOCIdentifier.Logger);
-
-      expect(result).toBe(mockLogger);
-      expect(typeof result.info).toBe('function');
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle missing service gracefully', () => {
-      expect(() => {
-        container.get('NonExistentService');
-      }).toThrow();
-    });
-
-    it('should handle invalid identifier types', () => {
-      expect(() => {
-        container.get(null as never);
-      }).toThrow();
-    });
-  });
-
-  describe('Dependency Injection', () => {
-    it('should support injectable decorators', () => {
-      // This test verifies that the container supports @injectable decorators
-      // The autobind configuration should allow this
-      expect(container).toBeDefined();
-    });
-
-    it('should support singleton scope', () => {
-      // This test verifies that the container uses singleton scope by default
-      const service1 = { id: 'test' };
-      const service2 = { id: 'test' };
-
-      container.bind('TestService1', service1);
-      container.bind('TestService2', service2);
-
-      const result1 = container.get('TestService1');
-      const result2 = container.get('TestService2');
-
-      expect(result1).toBe(service1);
-      expect(result2).toBe(service2);
-    });
-  });
-
-  describe('IOCIdentifier Constants', () => {
-    it('should be frozen object', () => {
-      expect(Object.isFrozen(IOCIdentifier)).toBe(true);
-    });
-
-    it('should have string values', () => {
-      Object.values(IOCIdentifier).forEach((value) => {
-        expect(typeof value).toBe('string');
-      });
-    });
-
-    it('should have unique values', () => {
-      const values = Object.values(IOCIdentifier);
-      const uniqueValues = new Set(values);
-      expect(uniqueValues.size).toBe(values.length);
-    });
-  });
-});

package/dist/templates/react-app/__tests__/src/core/bootstraps/BootstrapClient.test.ts

@@ -1,135 +0,0 @@
-/**
- * BootstrapClient test-suite
- *
- * Coverage:
- * 1. main method       – Bootstrap client main flow tests
- * 2. parameter validation – Input parameter validation tests
- * 3. error handling    – Error handling tests
- * 4. integration       – Bootstrap flow integration tests
- */
-
-import { testIOC } from '@__tests__/__mocks__/testIOC/TestIOC';
-import { I, type IOCIdentifierMap } from '@config/IOCIdentifier';
-import type { BootstrapClientArgs } from '@/core/bootstraps/BootstrapClient';
-import { BootstrapClient } from '@/core/bootstraps/BootstrapClient';
-import type { BootstrapsRegistryInterface } from '@/core/bootstraps/BootstrapsRegistry';
-import * as globals from '@/core/globals';
-import type {
-  BootstrapExecutorPlugin,
-  IOCContainerInterface,
-  IOCFunctionInterface
-} from '@qlover/corekit-bridge';
-
-describe('BootstrapClient', () => {
-  describe('bootstrap start flow', () => {
-    const mockRoot = {
-      location: { href: 'http://localhost:3000/en' }
-    };
-
-    const testBootstrapPlugin: BootstrapExecutorPlugin = {
-      pluginName: 'test-bootstrap-1',
-      onExec: vi.fn().mockResolvedValue(undefined)
-    };
-
-    it('should bootstrap real strapup flow', async () => {
-      // 将 mock 函数提取出来，以便验证是否被调用
-      const mockRegister = vi.fn().mockReturnValue([testBootstrapPlugin]);
-
-      class TestBootstrapsRegistry implements BootstrapsRegistryInterface {
-        public register = mockRegister;
-      }
-
-      const args: BootstrapClientArgs = {
-        root: mockRoot,
-        bootHref: mockRoot.location.href,
-        ioc: testIOC,
-        RegistryClass: TestBootstrapsRegistry
-      };
-
-      const result = await BootstrapClient.main(args);
-
-      expect(result).toEqual(args);
-      expect(globals.logger.info).toHaveBeenCalledWith('bootstrap start...');
-      expect(testBootstrapPlugin.onExec).toHaveBeenCalled();
-      // 验证 register 方法是否被调用
-      expect(mockRegister).toHaveBeenCalled();
-    });
-
-    it('should handle bootstrap I18nService', async () => {
-      // 将 mock 函数提取出来，以便验证是否被调用
-      const mockRegister = vi
-        .fn()
-        .mockImplementationOnce(
-          (
-            ioc: IOCFunctionInterface<IOCIdentifierMap, IOCContainerInterface>
-          ) => {
-            // TestIocRegister 中已经注册了，无法bind
-            return [ioc.get(I.I18nServiceInterface)];
-          }
-        );
-
-      class TestBootstrapsRegistry implements BootstrapsRegistryInterface {
-        public register = mockRegister;
-      }
-
-      const args: BootstrapClientArgs = {
-        root: mockRoot,
-        bootHref: mockRoot.location.href,
-        ioc: testIOC,
-        RegistryClass: TestBootstrapsRegistry
-      };
-
-      await BootstrapClient.main(args);
-
-      const ioc = testIOC.getIoc();
-      expect(mockRegister).toBeCalled();
-      expect(ioc).toBeDefined();
-
-      const i18nService = ioc!.get(I.I18nServiceInterface);
-      expect(i18nService).toBeDefined();
-      // @ts-ignore
-      expect(i18nService.pathname).toBe(args.bootHref);
-
-      // mock i18n set language to en
-      i18nService.emit({ ...i18nService.state, language: 'en' });
-
-      expect(i18nService.state.language).toBe('en');
-    });
-
-    it('should handle bootstrap UserApiBootstarp', async () => {
-      const mockOnExec = vi.fn().mockResolvedValue(undefined);
-      const mockUserBootstrap: BootstrapExecutorPlugin = {
-        pluginName: 'TestUserBootstrap',
-        onExec: mockOnExec
-      };
-      // 将 mock 函数提取出来，以便验证是否被调用
-      const mockRegister = vi
-        .fn()
-        .mockImplementationOnce(
-          (
-            _ioc: IOCFunctionInterface<IOCIdentifierMap, IOCContainerInterface>
-          ) => {
-            return [mockUserBootstrap];
-          }
-        );
-
-      class TestBootstrapsRegistry implements BootstrapsRegistryInterface {
-        public register = mockRegister;
-      }
-
-      const args: BootstrapClientArgs = {
-        root: mockRoot,
-        bootHref: mockRoot.location.href,
-        ioc: testIOC,
-        RegistryClass: TestBootstrapsRegistry
-      };
-
-      await BootstrapClient.main(args);
-      const ioc = testIOC.getIoc();
-      expect(ioc).toBeDefined();
-
-      expect(mockRegister).toBeCalled();
-      expect(mockOnExec).toBeCalled();
-    });
-  });
-});

package/dist/templates/react-app/__tests__/src/core/bootstraps/BootstrapsApp.test.ts

@@ -1,74 +0,0 @@
-import { browserGlobalsName } from '@config/common';
-import { createIOCFunction } from '@qlover/corekit-bridge';
-import { InversifyContainer } from '@/base/cases/InversifyContainer';
-import { BootstrapClient } from '@/core/bootstraps/BootstrapClient';
-import type { BootstrapClientArgs } from '@/core/bootstraps/BootstrapClient';
-import type { IOCIdentifierMap } from '@config/IOCIdentifier';
-import { name, version } from '../../../../package.json';
-
-// Mock IocRegisterImpl to properly handle registration
-vi.mock('@/core/registers/IocRegisterImpl', () => ({
-  IocRegisterImpl: vi.fn().mockImplementation((_options) => ({
-    getRegisterList: vi.fn().mockReturnValue([]),
-    register: vi.fn().mockImplementation((_container, _manager) => {
-      // Mock the actual registration process to avoid I18nService constructor issues
-      // This prevents the real registration from happening which causes the error
-    })
-  }))
-}));
-
-// Mock BootstrapsRegistry to avoid I18nService instantiation
-vi.mock('@/core/bootstraps/BootstrapsRegistry', () => ({
-  BootstrapsRegistry: vi.fn().mockImplementation(() => ({
-    register: vi.fn().mockReturnValue([])
-  }))
-}));
-
-describe('BootstrapApp', () => {
-  let mockArgs: BootstrapClientArgs;
-  let mockIOC: ReturnType<typeof createIOCFunction<IOCIdentifierMap>>;
-
-  beforeEach(() => {
-    // Reset all mocks
-    vi.clearAllMocks();
-
-    // Setup mock IOC with proper typing
-    const container = new InversifyContainer();
-    mockIOC = createIOCFunction<IOCIdentifierMap>(container);
-
-    // Setup test arguments
-    mockArgs = {
-      root: {},
-      bootHref: 'http://localhost:3000',
-      ioc: {
-        create: vi.fn().mockReturnValue(mockIOC)
-      }
-    };
-  });
-
-  describe('main', () => {
-    it('should initialize bootstrap successfully', async () => {
-      const result = await BootstrapClient.main(mockArgs);
-
-      expect(result.bootHref).toBe('http://localhost:3000');
-      // default inject env,globals var, ioc
-
-      expect(
-        (mockArgs.root as Record<string, unknown>)[browserGlobalsName]
-      ).toBeDefined();
-
-      // Verify that the globals object is injected into root
-      const injectedGlobals = (mockArgs.root as Record<string, unknown>)[
-        browserGlobalsName
-      ] as Record<string, unknown>;
-      expect(injectedGlobals).toHaveProperty('logger');
-      expect(injectedGlobals).toHaveProperty('appConfig');
-      expect(
-        (injectedGlobals.appConfig as Record<string, unknown>).appName
-      ).toBe(name);
-      expect(
-        (injectedGlobals.appConfig as Record<string, unknown>).appVersion
-      ).toBe(version);
-    });
-  });
-});

package/dist/templates/react-app/__tests__/src/main.test.tsx

@@ -1,46 +0,0 @@
-import { BootstrapClient } from '@/core/bootstraps/BootstrapClient';
-
-// Mock BootstrapApp - must return a resolved promise to prevent hanging
-vi.mock('@/core/bootstraps/BootstrapClient', () => ({
-  BootstrapClient: {
-    main: vi.fn().mockResolvedValue({})
-  }
-}));
-
-// Mock react-dom
-vi.mock('react-dom/client', () => ({
-  createRoot: vi.fn(() => ({
-    render: vi.fn(),
-    unmount: vi.fn()
-  }))
-}));
-
-// Mock App component
-vi.mock('@/App', () => ({
-  default: vi.fn(() => 'MockedApp')
-}));
-
-describe('main.tsx', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.resetModules();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('BootstrapApp initialization', () => {
-    it('should call BootstrapApp.main()', async () => {
-      await import('@/main');
-      expect(BootstrapClient.main).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('Module loading', () => {
-    it('should load main module without errors', async () => {
-      const mainModule = await import('@/main');
-      expect(mainModule).toBeDefined();
-    });
-  });
-});

package/dist/templates/react-app/__tests__/src/uikit/components/BaseHeader.test.tsx

@@ -1,97 +0,0 @@
-import { BootstrapTest } from '@__mocks__/BootstrapTest';
-import { TestApp } from '@__mocks__/components';
-import { I } from '@config/IOCIdentifier';
-import { render, screen } from '@testing-library/react';
-import type { IOCRegister } from '@/base/port/IOCInterface';
-import { UserService } from '@/base/services/UserService';
-import { BaseHeader } from '@/uikit/components/BaseHeader';
-
-const BaseHeaderRegister: IOCRegister = {
-  register(ioc): void {
-    ioc.bind(I.UserServiceInterface, ioc.get(UserService));
-  }
-};
-
-describe('BaseHeader', () => {
-  beforeAll(async () => {
-    await BootstrapTest.main({
-      root: globalThis,
-      bootHref: 'http://localhost:3000/en/test',
-      iocRegister: BaseHeaderRegister
-    });
-  });
-
-  it('renders header with correct structure', () => {
-    render(
-      <TestApp>
-        <BaseHeader />
-      </TestApp>
-    );
-
-    const header = screen.getByTestId('BaseHeader');
-    expect(header).toBeDefined();
-  });
-
-  it('renders logo and app name correctly', () => {
-    render(
-      <TestApp>
-        <BaseHeader />
-      </TestApp>
-    );
-
-    const logo = screen.getByTestId('BaseHeader-logo');
-    const appName = screen.getByTestId('BaseHeader-app-name');
-
-    expect(logo).toBeDefined();
-    expect(logo.getAttribute('alt')).toBe('logo');
-    expect(appName).toBeDefined();
-    expect(appName.textContent).toBeTruthy();
-  });
-
-  it('renders theme and language switchers', () => {
-    render(
-      <TestApp>
-        <BaseHeader />
-      </TestApp>
-    );
-
-    // Note: These components render as Ant Design Select components
-    // We can verify they exist by checking for their parent containers
-    const header = screen.getByTestId('BaseHeader');
-    expect(header).toBeDefined();
-    // The actual Select components might not have data-testid in production code
-  });
-
-  it('renders logout button when showLogoutButton is true', () => {
-    render(
-      <TestApp>
-        <BaseHeader showLogoutButton />
-      </TestApp>
-    );
-
-    const logoutButton = screen.getByTestId('LogoutButton');
-    expect(logoutButton).toBeDefined();
-  });
-
-  it('does not render logout button when showLogoutButton is false', () => {
-    render(
-      <TestApp>
-        <BaseHeader showLogoutButton={false} />
-      </TestApp>
-    );
-
-    expect(screen.queryByTestId('LogoutButton')).toBeNull();
-  });
-
-  it('renders home link correctly', () => {
-    render(
-      <TestApp>
-        <BaseHeader />
-      </TestApp>
-    );
-
-    const link = screen.getByTestId('locale-link');
-    expect(link).toBeDefined();
-    expect(link.getAttribute('href')).toBe('/');
-  });
-});