@hua-labs/hua-ux 0.1.0-alpha.0.1

package/src/framework/__tests__/components/ErrorBoundary.test.tsx

@@ -0,0 +1,146 @@
+/**
+ * @hua-labs/hua-ux/framework - ErrorBoundary Component Tests
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import React from 'react';
+import { ErrorBoundary } from '../../components/ErrorBoundary';
+
+// 에러를 발생시키는 컴포넌트
+function ThrowError({ shouldThrow = false }: { shouldThrow?: boolean }) {
+  if (shouldThrow) {
+    throw new Error('Test error');
+  }
+  return <div>No error</div>;
+}
+
+describe('ErrorBoundary', () => {
+  beforeEach(() => {
+    // console.error를 모킹하여 테스트 중 에러 로그 방지
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should render children when no error occurs', () => {
+    render(
+      <ErrorBoundary>
+        <ThrowError shouldThrow={false} />
+      </ErrorBoundary>
+    );
+
+    expect(screen.getByText('No error')).toBeInTheDocument();
+  });
+
+  it('should render default fallback when error occurs', () => {
+    render(
+      <ErrorBoundary>
+        <ThrowError shouldThrow={true} />
+      </ErrorBoundary>
+    );
+
+    expect(screen.getByText(/오류가 발생했습니다|An error occurred/)).toBeInTheDocument();
+  });
+
+  it('should render custom fallback when provided', () => {
+    const customFallback = <div>Custom error message</div>;
+
+    render(
+      <ErrorBoundary fallback={customFallback}>
+        <ThrowError shouldThrow={true} />
+      </ErrorBoundary>
+    );
+
+    expect(screen.getByText('Custom error message')).toBeInTheDocument();
+  });
+
+  it('should call onError callback when error occurs', () => {
+    const onError = vi.fn();
+
+    render(
+      <ErrorBoundary onError={onError}>
+        <ThrowError shouldThrow={true} />
+      </ErrorBoundary>
+    );
+
+    expect(onError).toHaveBeenCalled();
+    expect(onError).toHaveBeenCalledWith(
+      expect.any(Error),
+      expect.objectContaining({
+        componentStack: expect.any(String),
+      })
+    );
+  });
+
+  it('should support function fallback with error and reset', () => {
+    const fallbackFn = vi.fn((error, reset) => (
+      <div>
+        <p>Error: {error.message}</p>
+        <button onClick={reset}>Reset</button>
+      </div>
+    ));
+
+    render(
+      <ErrorBoundary fallback={fallbackFn}>
+        <ThrowError shouldThrow={true} />
+      </ErrorBoundary>
+    );
+
+    expect(fallbackFn).toHaveBeenCalled();
+    expect(fallbackFn).toHaveBeenCalledWith(
+      expect.any(Error),
+      expect.any(Function)
+    );
+  });
+
+  it('should reset error state when reset is called', () => {
+    const fallbackFn = (error: Error, reset: () => void) => (
+      <div>
+        <p>Error: {error.message}</p>
+        <button onClick={reset}>Reset</button>
+      </div>
+    );
+
+    const { rerender } = render(
+      <ErrorBoundary fallback={fallbackFn}>
+        <ThrowError shouldThrow={true} />
+      </ErrorBoundary>
+    );
+
+    expect(screen.getByText(/Error: Test error/)).toBeInTheDocument();
+
+    // Reset 버튼 클릭 시뮬레이션
+    const resetButton = screen.getByText('Reset');
+    resetButton.click();
+
+    // 에러가 리셋되어 children이 다시 렌더링되어야 함
+    rerender(
+      <ErrorBoundary fallback={fallbackFn}>
+        <ThrowError shouldThrow={false} />
+      </ErrorBoundary>
+    );
+
+    expect(screen.getByText('No error')).toBeInTheDocument();
+  });
+
+  it('should call onReset callback when reset is called', () => {
+    const onReset = vi.fn();
+    const fallbackFn = (error: Error, reset: () => void) => (
+      <button onClick={reset}>Reset</button>
+    );
+
+    render(
+      <ErrorBoundary fallback={fallbackFn} onReset={onReset}>
+        <ThrowError shouldThrow={true} />
+      </ErrorBoundary>
+    );
+
+    const resetButton = screen.getByText('Reset');
+    resetButton.click();
+
+    expect(onReset).toHaveBeenCalled();
+  });
+});

package/src/framework/__tests__/config/defineConfig.test.ts

@@ -0,0 +1,138 @@
+/**
+ * @hua-labs/hua-ux/framework - Config Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { defineConfig, getConfig, setConfig, resetConfig } from '../../config';
+import type { HuaUxConfig } from '../../types';
+
+describe('defineConfig', () => {
+  it('should create config with preset', () => {
+    const config = defineConfig({
+      preset: 'product',
+    });
+
+    expect(config).toBeDefined();
+    expect(config.preset).toBe('product');
+  });
+
+  it('should create config with custom settings', () => {
+    const config = defineConfig({
+      i18n: {
+        defaultLanguage: 'ko',
+        supportedLanguages: ['ko', 'en'],
+        namespaces: ['common'],
+      },
+    });
+
+    expect(config.i18n).toBeDefined();
+    expect(config.i18n?.defaultLanguage).toBe('ko');
+    expect(config.i18n?.supportedLanguages).toEqual(['ko', 'en']);
+  });
+
+  it('should merge preset with custom settings', () => {
+    const config = defineConfig({
+      preset: 'product',
+      motion: {
+        enableAnimations: false,
+      },
+    });
+
+    expect(config.preset).toBe('product');
+    expect(config.motion?.enableAnimations).toBe(false);
+  });
+});
+
+describe('getConfig', () => {
+  beforeEach(() => {
+    resetConfig();
+  });
+
+  afterEach(() => {
+    resetConfig();
+  });
+
+  it('should return default config when no config is set', () => {
+    resetConfig();
+    const config = getConfig();
+
+    expect(config).toBeDefined();
+    // jsdom 환경에서는 window가 정의되어 있어 기본값(product preset)이 반환됨
+    // getConfig는 항상 설정을 반환하므로 motion, i18n 등이 정의되어 있어야 함
+    expect(config.motion).toBeDefined();
+    expect(config.i18n).toBeDefined();
+  });
+
+  it('should return set config', () => {
+    resetConfig();
+    const customConfig = defineConfig({
+      preset: 'marketing',
+    });
+
+    setConfig(customConfig);
+    const config = getConfig();
+
+    // setConfig 후에는 설정된 config가 반환되어야 함
+    expect(config.preset).toBe('marketing');
+  });
+});
+
+describe('setConfig', () => {
+  beforeEach(() => {
+    resetConfig();
+  });
+
+  afterEach(() => {
+    resetConfig();
+  });
+
+  it('should set config', () => {
+    resetConfig();
+    const customConfig = defineConfig({
+      preset: 'marketing',
+    });
+
+    setConfig(customConfig);
+    const config = getConfig();
+
+    expect(config.preset).toBe('marketing');
+  });
+
+  it('should override previous config', () => {
+    resetConfig();
+    const config1 = defineConfig({ preset: 'product' });
+    const config2 = defineConfig({ preset: 'marketing' });
+
+    setConfig(config1);
+    expect(getConfig().preset).toBe('product');
+
+    setConfig(config2);
+    expect(getConfig().preset).toBe('marketing');
+  });
+});
+
+describe('resetConfig', () => {
+  beforeEach(() => {
+    resetConfig();
+  });
+
+  afterEach(() => {
+    resetConfig();
+  });
+
+  it('should reset config to default', () => {
+    resetConfig();
+    const customConfig = defineConfig({
+      preset: 'marketing',
+    });
+
+    setConfig(customConfig);
+    expect(getConfig().preset).toBe('marketing');
+
+    resetConfig();
+    const defaultConfig = getConfig();
+
+    // 기본값으로 리셋됨 (product preset)
+    expect(defaultConfig.preset).toBeDefined();
+  });
+});

package/src/framework/__tests__/hooks/useMotion.test.ts

@@ -0,0 +1,105 @@
+/**
+ * @hua-labs/hua-ux/framework - useMotion Hook Tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { useMotion } from '../../hooks/useMotion';
+
+// motion-core의 useUnifiedMotion 모킹
+const mockMotionResult = {
+  ref: { current: null },
+  style: { opacity: 0 },
+  isVisible: false,
+  isAnimating: false,
+  progress: 0,
+  start: vi.fn(),
+  reset: vi.fn(),
+  stop: vi.fn(),
+};
+
+vi.mock('@hua-labs/motion-core', () => ({
+  useUnifiedMotion: vi.fn(() => mockMotionResult),
+}));
+
+describe('useMotion', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should call useUnifiedMotion with correct options', async () => {
+    const { useUnifiedMotion } = await import('@hua-labs/motion-core');
+
+    renderHook(() =>
+      useMotion({
+        type: 'fadeIn',
+        duration: 600,
+        delay: 100,
+        easing: 'ease-in-out',
+      })
+    );
+
+    expect(useUnifiedMotion).toHaveBeenCalledWith({
+      type: 'fadeIn',
+      duration: 600,
+      delay: 100,
+      easing: 'ease-in-out',
+      autoStart: undefined,
+    });
+  });
+
+  it('should return motion result', () => {
+    const { result } = renderHook(() =>
+      useMotion({
+        type: 'fadeIn',
+        duration: 600,
+      })
+    );
+
+    expect(result.current).toBeDefined();
+    expect(result.current.ref).toBeDefined();
+    expect(result.current.start).toBeDefined();
+    expect(result.current.reset).toBeDefined();
+    expect(result.current.stop).toBeDefined();
+  });
+
+  it('should pass all motion types to useUnifiedMotion', async () => {
+    const { useUnifiedMotion } = await import('@hua-labs/motion-core');
+
+    const types = ['fadeIn', 'slideUp', 'slideLeft', 'slideRight', 'scaleIn', 'bounceIn'] as const;
+
+    for (const type of types) {
+      vi.clearAllMocks();
+      renderHook(() =>
+        useMotion({
+          type,
+          duration: 600,
+        })
+      );
+
+      expect(useUnifiedMotion).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type,
+        })
+      );
+    }
+  });
+
+  it('should handle autoStart option', async () => {
+    const { useUnifiedMotion } = await import('@hua-labs/motion-core');
+
+    renderHook(() =>
+      useMotion({
+        type: 'fadeIn',
+        duration: 600,
+        autoStart: true,
+      })
+    );
+
+    expect(useUnifiedMotion).toHaveBeenCalledWith(
+      expect.objectContaining({
+        autoStart: true,
+      })
+    );
+  });
+});

package/src/framework/__tests__/seo/geo/generateGEOMetadata.test.ts

@@ -0,0 +1,207 @@
+/**
+ * @hua-labs/hua-ux/framework - GEO Metadata Generator Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { generateGEOMetadata, createAIContext } from '../../../seo/geo/generateGEOMetadata';
+import type { GEOConfig } from '../../../seo/geo/types';
+
+describe('generateGEOMetadata', () => {
+  const baseConfig: GEOConfig = {
+    name: 'Test App',
+    description: 'A test application',
+  };
+
+  it('should generate basic metadata', () => {
+    const result = generateGEOMetadata(baseConfig);
+
+    expect(result).toBeDefined();
+    expect(result.meta).toBeDefined();
+    expect(result.jsonLd).toBeDefined();
+    expect(result.openGraph).toBeDefined();
+    expect(result.twitter).toBeDefined();
+  });
+
+  it('should include description in meta tags', () => {
+    const result = generateGEOMetadata(baseConfig);
+
+    const descriptionMeta = result.meta.find((m) => m.name === 'description');
+    expect(descriptionMeta).toBeDefined();
+    expect(descriptionMeta?.content).toBe('A test application');
+  });
+
+  it('should include keywords when provided', () => {
+    const config: GEOConfig = {
+      ...baseConfig,
+      keywords: ['react', 'nextjs', 'typescript'],
+    };
+
+    const result = generateGEOMetadata(config);
+
+    const keywordsMeta = result.meta.find((m) => m.name === 'keywords');
+    expect(keywordsMeta).toBeDefined();
+    expect(keywordsMeta?.content).toBe('react, nextjs, typescript');
+  });
+
+  it('should include version when provided', () => {
+    const config: GEOConfig = {
+      ...baseConfig,
+      version: '1.0.0',
+    };
+
+    const result = generateGEOMetadata(config);
+
+    const versionMeta = result.meta.find((m) => m.name === 'software:version');
+    expect(versionMeta).toBeDefined();
+    expect(versionMeta?.content).toBe('1.0.0');
+  });
+
+  it('should include application category when provided', () => {
+    const config: GEOConfig = {
+      ...baseConfig,
+      applicationCategory: 'UX Framework',
+    };
+
+    const result = generateGEOMetadata(config);
+
+    const categoryMeta = result.meta.find((m) => m.name === 'software:category');
+    expect(categoryMeta).toBeDefined();
+    expect(categoryMeta?.content).toBe('UX Framework');
+  });
+
+  it('should handle multiple application categories', () => {
+    const config: GEOConfig = {
+      ...baseConfig,
+      applicationCategory: ['UX Framework', 'Developer Tool'],
+    };
+
+    const result = generateGEOMetadata(config);
+
+    const categoryMeta = result.meta.find((m) => m.name === 'software:category');
+    expect(categoryMeta).toBeDefined();
+    expect(categoryMeta?.content).toBe('UX Framework, Developer Tool');
+  });
+
+  it('should include programming language when provided', () => {
+    const config: GEOConfig = {
+      ...baseConfig,
+      programmingLanguage: 'TypeScript',
+    };
+
+    const result = generateGEOMetadata(config);
+
+    const languageMeta = result.meta.find((m) => m.name === 'software:language');
+    expect(languageMeta).toBeDefined();
+    expect(languageMeta?.content).toBe('TypeScript');
+  });
+
+  it('should generate Open Graph tags', () => {
+    const result = generateGEOMetadata(baseConfig);
+
+    expect(result.openGraph).toBeDefined();
+    expect(result.openGraph?.length).toBeGreaterThan(0);
+
+    const ogTitle = result.openGraph?.find((og) => og.property === 'og:title');
+    expect(ogTitle).toBeDefined();
+    expect(ogTitle?.content).toBe('Test App');
+  });
+
+  it('should generate Twitter Card tags', () => {
+    const result = generateGEOMetadata(baseConfig);
+
+    expect(result.twitter).toBeDefined();
+    expect(result.twitter?.length).toBeGreaterThan(0);
+
+    const twitterCard = result.twitter?.find((t) => t.name === 'twitter:card');
+    expect(twitterCard).toBeDefined();
+    expect(twitterCard?.content).toBe('summary_large_image');
+  });
+
+  it('should include URL in Open Graph when provided', () => {
+    const config: GEOConfig = {
+      ...baseConfig,
+      url: 'https://example.com',
+    };
+
+    const result = generateGEOMetadata(config);
+
+    const ogUrl = result.openGraph?.find((og) => og.property === 'og:url');
+    expect(ogUrl).toBeDefined();
+    expect(ogUrl?.content).toBe('https://example.com');
+  });
+
+  it('should generate JSON-LD structured data', () => {
+    const result = generateGEOMetadata(baseConfig);
+
+    expect(result.jsonLd).toBeDefined();
+    expect(result.jsonLd.length).toBeGreaterThan(0);
+
+    const jsonLd = result.jsonLd[0];
+    expect(jsonLd['@context']).toBe('https://schema.org');
+    expect(jsonLd['@type']).toBe('SoftwareApplication');
+    expect(jsonLd.name).toBe('Test App');
+    expect(jsonLd.description).toBe('A test application');
+  });
+});
+
+describe('createAIContext', () => {
+  it('should create basic context', () => {
+    const config: GEOConfig = {
+      name: 'Test App',
+      description: 'A test application',
+    };
+
+    const context = createAIContext(config);
+
+    expect(context).toContain('Test App');
+    expect(context).toContain('A test application');
+  });
+
+  it('should include features when provided', () => {
+    const config: GEOConfig = {
+      name: 'Test App',
+      description: 'A test application',
+      features: ['i18n', 'Motion', 'Accessibility'],
+    };
+
+    const context = createAIContext(config);
+
+    expect(context).toContain('Key features include: i18n, Motion, Accessibility');
+  });
+
+  it('should include use cases when provided', () => {
+    const config: GEOConfig = {
+      name: 'Test App',
+      description: 'A test application',
+      useCases: ['Multilingual apps', 'Accessible UX'],
+    };
+
+    const context = createAIContext(config);
+
+    expect(context).toContain('Common use cases: Multilingual apps, Accessible UX');
+  });
+
+  it('should include programming language when provided', () => {
+    const config: GEOConfig = {
+      name: 'Test App',
+      description: 'A test application',
+      programmingLanguage: ['TypeScript', 'React'],
+    };
+
+    const context = createAIContext(config);
+
+    expect(context).toContain('Built with: TypeScript, React');
+  });
+
+  it('should include software requirements when provided', () => {
+    const config: GEOConfig = {
+      name: 'Test App',
+      description: 'A test application',
+      softwareRequirements: ['Node.js 18+', 'React 19+'],
+    };
+
+    const context = createAIContext(config);
+
+    expect(context).toContain('Requires: Node.js 18+, React 19+');
+  });
+});