@useavalon/avalon 0.1.5 → 0.1.6

package/src/client/tests/framework-adapter.test.ts

@@ -1,519 +0,0 @@
-/**
- * Tests for Framework HMR Adapter Interface and Registry
- * 
- * These tests verify the framework adapter interface contract and registry system.
- * Requirements: 2.1-2.7
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  type FrameworkHMRAdapter,
-  type StateSnapshot,
-  AdapterRegistry,
-  BaseFrameworkAdapter,
-} from '../framework-adapter.ts';
-
-// Mock adapter for testing
-class MockFrameworkAdapter implements FrameworkHMRAdapter {
-  readonly name = 'mock';
-  
-  canHandle(component: unknown): boolean {
-    return typeof component === 'function';
-  }
-  
-  preserveState(island: HTMLElement): StateSnapshot | null {
-    return {
-      framework: 'mock',
-      timestamp: Date.now(),
-      data: { test: 'value' },
-    };
-  }
-  
-  async update(
-    island: HTMLElement,
-    newComponent: unknown,
-    props: Record<string, unknown>
-  ): Promise<void> {
-    // Mock update
-  }
-  
-  restoreState(island: HTMLElement, state: StateSnapshot): void {
-    // Mock restore
-  }
-  
-  handleError(island: HTMLElement, error: Error): void {
-    // Mock error handling
-  }
-}
-
-// Another mock adapter for testing multiple registrations
-class AnotherMockAdapter implements FrameworkHMRAdapter {
-  readonly name = 'another';
-  
-  canHandle(component: unknown): boolean {
-    return typeof component === 'object';
-  }
-  
-  preserveState(island: HTMLElement): StateSnapshot | null {
-    return null;
-  }
-  
-  async update(
-    island: HTMLElement,
-    newComponent: unknown,
-    props: Record<string, unknown>
-  ): Promise<void> {
-    // Mock update
-  }
-  
-  restoreState(island: HTMLElement, state: StateSnapshot): void {
-    // Mock restore
-  }
-  
-  handleError(island: HTMLElement, error: Error): void {
-    // Mock error handling
-  }
-}
-
-// Concrete implementation of BaseFrameworkAdapter for testing
-class TestBaseAdapter extends BaseFrameworkAdapter {
-  readonly name = 'test-base';
-  
-  canHandle(component: unknown): boolean {
-    return true;
-  }
-  
-  async update(
-    island: HTMLElement,
-    newComponent: unknown,
-    props: Record<string, unknown>
-  ): Promise<void> {
-    // Test implementation
-  }
-}
-
-// Mock HTMLElement for testing
-class MockHTMLElement {
-  private attributes: Map<string, string> = new Map();
-  private _children: MockHTMLElement[] = [];
-  public scrollTop = 0;
-  public scrollLeft = 0;
-  public style: Record<string, string> = {};
-  
-  getAttribute(name: string): string | null {
-    return this.attributes.get(name) || null;
-  }
-  
-  setAttribute(name: string, value: string): void {
-    this.attributes.set(name, value);
-  }
-  
-  removeAttribute(name: string): void {
-    this.attributes.delete(name);
-  }
-  
-  hasAttribute(name: string): boolean {
-    return this.attributes.has(name);
-  }
-  
-  querySelector(selector: string): MockHTMLElement | null {
-    return null;
-  }
-  
-  querySelectorAll(selector: string): MockHTMLElement[] {
-    return [];
-  }
-  
-  contains(element: unknown): boolean {
-    return false;
-  }
-  
-  insertBefore(newNode: unknown, referenceNode: unknown): void {
-    // Mock implementation
-  }
-  
-  get firstChild(): unknown {
-    return null;
-  }
-  
-  dispatchEvent(event: any): boolean {
-    return true;
-  }
-}
-
-describe('FrameworkHMRAdapter - interface contract', () => {
-  it('should have all required properties and methods', () => {
-    const adapter = new MockFrameworkAdapter();
-    
-    // Verify all required properties and methods exist
-    expect(adapter.name).toBeDefined();
-    expect(typeof adapter.canHandle).toBe('function');
-    expect(typeof adapter.preserveState).toBe('function');
-    expect(typeof adapter.update).toBe('function');
-    expect(typeof adapter.restoreState).toBe('function');
-    expect(typeof adapter.handleError).toBe('function');
-  });
-});
-
-describe('FrameworkHMRAdapter - canHandle method', () => {
-  it('should handle different component types correctly', () => {
-    const adapter = new MockFrameworkAdapter();
-    
-    // Test canHandle with different component types
-    expect(adapter.canHandle(() => {})).toBe(true);
-    expect(adapter.canHandle(class {})).toBe(true);
-    expect(adapter.canHandle({})).toBe(false);
-    expect(adapter.canHandle('string')).toBe(false);
-  });
-});
-
-describe('FrameworkHMRAdapter - preserveState', () => {
-  it('should return valid snapshot', () => {
-    const adapter = new MockFrameworkAdapter();
-    const mockIsland = new MockHTMLElement() as unknown as HTMLElement;
-    
-    const snapshot = adapter.preserveState(mockIsland);
-    
-    expect(snapshot).toBeDefined();
-    expect(snapshot?.framework).toBe('mock');
-    expect(typeof snapshot?.timestamp).toBe('number');
-    expect(snapshot?.data).toBeDefined();
-  });
-});
-
-describe('FrameworkHMRAdapter - update method', () => {
-  it('should be async and return a Promise', async () => {
-    const adapter = new MockFrameworkAdapter();
-    const mockIsland = new MockHTMLElement() as unknown as HTMLElement;
-    
-    // Verify update returns a Promise
-    const result = adapter.update(mockIsland, () => {}, {});
-    expect(result).toBeDefined();
-    expect(result instanceof Promise).toBe(true);
-    
-    // Await the promise
-    await result;
-  });
-});
-
-describe('AdapterRegistry - initialization', () => {
-  it('should start empty', () => {
-    const registry = new AdapterRegistry();
-    
-    expect(registry).toBeDefined();
-    expect(registry.size).toBe(0);
-    expect(registry.getRegisteredFrameworks().length).toBe(0);
-  });
-});
-
-describe('AdapterRegistry - register adapter', () => {
-  it('should register adapter correctly', () => {
-    const registry = new AdapterRegistry();
-    const adapter = new MockFrameworkAdapter();
-    
-    registry.register('mock', adapter);
-    
-    expect(registry.size).toBe(1);
-    expect(registry.has('mock')).toBe(true);
-    expect(registry.has('MOCK')).toBe(true);
-  });
-});
-
-describe('AdapterRegistry - register multiple adapters', () => {
-  it('should handle multiple adapters', () => {
-    const registry = new AdapterRegistry();
-    const adapter1 = new MockFrameworkAdapter();
-    const adapter2 = new AnotherMockAdapter();
-    
-    registry.register('mock', adapter1);
-    registry.register('another', adapter2);
-    
-    expect(registry.size).toBe(2);
-    expect(registry.has('mock')).toBe(true);
-    expect(registry.has('another')).toBe(true);
-    
-    const frameworks = registry.getRegisteredFrameworks();
-    expect(frameworks.length).toBe(2);
-    expect(frameworks.includes('mock')).toBe(true);
-    expect(frameworks.includes('another')).toBe(true);
-  });
-});
-
-describe('AdapterRegistry - get adapter', () => {
-  it('should retrieve adapter correctly', () => {
-    const registry = new AdapterRegistry();
-    const adapter = new MockFrameworkAdapter();
-    
-    registry.register('mock', adapter);
-    
-    const retrieved = registry.get('mock');
-    expect(retrieved).toBeDefined();
-    expect(retrieved?.name).toBe('mock');
-    
-    // Test case-insensitivity
-    const retrievedUpper = registry.get('MOCK');
-    expect(retrievedUpper).toBeDefined();
-    expect(retrievedUpper?.name).toBe('mock');
-  });
-});
-
-describe('AdapterRegistry - get non-existent adapter', () => {
-  it('should return undefined for non-existent adapter', () => {
-    const registry = new AdapterRegistry();
-    
-    const retrieved = registry.get('nonexistent');
-    expect(retrieved).toBeUndefined();
-  });
-});
-
-describe('AdapterRegistry - findAdapter by component', () => {
-  it('should find correct adapter for component type', () => {
-    const registry = new AdapterRegistry();
-    const adapter1 = new MockFrameworkAdapter(); // Handles functions
-    const adapter2 = new AnotherMockAdapter(); // Handles objects
-    
-    registry.register('mock', adapter1);
-    registry.register('another', adapter2);
-    
-    // Test finding adapter for function component
-    const functionAdapter = registry.findAdapter(() => {});
-    expect(functionAdapter).toBeDefined();
-    expect(functionAdapter?.name).toBe('mock');
-    
-    // Test finding adapter for object component
-    const objectAdapter = registry.findAdapter({});
-    expect(objectAdapter).toBeDefined();
-    expect(objectAdapter?.name).toBe('another');
-    
-    // Test finding adapter for unsupported component
-    const noneAdapter = registry.findAdapter('string');
-    expect(noneAdapter).toBeUndefined();
-  });
-});
-
-describe('AdapterRegistry - unregister adapter', () => {
-  it('should unregister adapter correctly', () => {
-    const registry = new AdapterRegistry();
-    const adapter = new MockFrameworkAdapter();
-    
-    registry.register('mock', adapter);
-    expect(registry.size).toBe(1);
-    
-    const removed = registry.unregister('mock');
-    expect(removed).toBe(true);
-    expect(registry.size).toBe(0);
-    expect(registry.has('mock')).toBe(false);
-  });
-});
-
-describe('AdapterRegistry - unregister non-existent adapter', () => {
-  it('should return false when removing non-existent adapter', () => {
-    const registry = new AdapterRegistry();
-    
-    const removed = registry.unregister('nonexistent');
-    expect(removed).toBe(false);
-  });
-});
-
-describe('AdapterRegistry - clear all adapters', () => {
-  it('should clear all adapters', () => {
-    const registry = new AdapterRegistry();
-    const adapter1 = new MockFrameworkAdapter();
-    const adapter2 = new AnotherMockAdapter();
-    
-    registry.register('mock', adapter1);
-    registry.register('another', adapter2);
-    expect(registry.size).toBe(2);
-    
-    registry.clear();
-    expect(registry.size).toBe(0);
-    expect(registry.getRegisteredFrameworks().length).toBe(0);
-  });
-});
-
-describe('AdapterRegistry - validation: null adapter', () => {
-  it('should throw error for null adapter', () => {
-    const registry = new AdapterRegistry();
-    
-    expect(() => registry.register('test', null as any)).toThrow('Cannot register null/undefined adapter');
-  });
-});
-
-describe('AdapterRegistry - validation: adapter without name', () => {
-  it('should throw error for adapter without name', () => {
-    const registry = new AdapterRegistry();
-    const invalidAdapter = {
-      canHandle: () => true,
-      preserveState: () => null,
-      update: async () => {},
-      restoreState: () => {},
-      handleError: () => {},
-    } as any;
-    
-    expect(() => registry.register('test', invalidAdapter)).toThrow('must have a name property');
-  });
-});
-
-describe('AdapterRegistry - validation: adapter without canHandle', () => {
-  it('should throw error for adapter without canHandle', () => {
-    const registry = new AdapterRegistry();
-    const invalidAdapter = {
-      name: 'test',
-      preserveState: () => null,
-      update: async () => {},
-      restoreState: () => {},
-      handleError: () => {},
-    } as any;
-    
-    expect(() => registry.register('test', invalidAdapter)).toThrow('must implement canHandle method');
-  });
-});
-
-describe('AdapterRegistry - validation: adapter without preserveState', () => {
-  it('should throw error for adapter without preserveState', () => {
-    const registry = new AdapterRegistry();
-    const invalidAdapter = {
-      name: 'test',
-      canHandle: () => true,
-      update: async () => {},
-      restoreState: () => {},
-      handleError: () => {},
-    } as any;
-    
-    expect(() => registry.register('test', invalidAdapter)).toThrow('must implement preserveState method');
-  });
-});
-
-describe('AdapterRegistry - validation: adapter without update', () => {
-  it('should throw error for adapter without update', () => {
-    const registry = new AdapterRegistry();
-    const invalidAdapter = {
-      name: 'test',
-      canHandle: () => true,
-      preserveState: () => null,
-      restoreState: () => {},
-      handleError: () => {},
-    } as any;
-    
-    expect(() => registry.register('test', invalidAdapter)).toThrow('must implement update method');
-  });
-});
-
-describe('AdapterRegistry - validation: adapter without restoreState', () => {
-  it('should throw error for adapter without restoreState', () => {
-    const registry = new AdapterRegistry();
-    const invalidAdapter = {
-      name: 'test',
-      canHandle: () => true,
-      preserveState: () => null,
-      update: async () => {},
-      handleError: () => {},
-    } as any;
-    
-    expect(() => registry.register('test', invalidAdapter)).toThrow('must implement restoreState method');
-  });
-});
-
-describe('AdapterRegistry - validation: adapter without handleError', () => {
-  it('should throw error for adapter without handleError', () => {
-    const registry = new AdapterRegistry();
-    const invalidAdapter = {
-      name: 'test',
-      canHandle: () => true,
-      preserveState: () => null,
-      update: async () => {},
-      restoreState: () => {},
-    } as any;
-    
-    expect(() => registry.register('test', invalidAdapter)).toThrow('must implement handleError method');
-  });
-});
-
-describe('BaseFrameworkAdapter - default preserveState', () => {
-  it('should capture DOM state when available', () => {
-    const adapter = new TestBaseAdapter();
-    const mockIsland = new MockHTMLElement() as unknown as HTMLElement;
-    
-    const snapshot = adapter.preserveState(mockIsland);
-    
-    // Note: In test environment without DOM, preserveState may return null
-    // This is expected behavior - the adapter gracefully handles missing DOM
-    if (snapshot) {
-      expect(snapshot.framework).toBe('test-base');
-      expect(typeof snapshot.timestamp).toBe('number');
-      expect(snapshot.data).toBeDefined();
-    } else {
-      // Graceful degradation when DOM is not available
-      expect(snapshot).toBeNull();
-    }
-  });
-});
-
-describe('BaseFrameworkAdapter - default restoreState', () => {
-  it('should handle DOM state restoration', () => {
-    const adapter = new TestBaseAdapter();
-    const mockIsland = new MockHTMLElement() as unknown as HTMLElement;
-    
-    const snapshot: StateSnapshot = {
-      framework: 'test-base',
-      timestamp: Date.now(),
-      data: {},
-      dom: {
-        scrollPosition: { x: 100, y: 200 },
-      },
-    };
-    
-    // Should not throw
-    adapter.restoreState(mockIsland, snapshot);
-    
-    // Verify scroll position was restored
-    expect(mockIsland.scrollLeft).toBe(100);
-    expect(mockIsland.scrollTop).toBe(200);
-  });
-});
-
-describe('BaseFrameworkAdapter - default handleError', () => {
-  it('should add error indicator', () => {
-    const adapter = new TestBaseAdapter();
-    const mockIsland = new MockHTMLElement() as unknown as HTMLElement;
-    const error = new Error('Test error');
-    
-    // In test environment without DOM, handleError may fail
-    // This is expected - the adapter requires DOM APIs
-    try {
-      adapter.handleError(mockIsland, error);
-      
-      // If it succeeds, verify error attributes were set
-      expect(mockIsland.getAttribute('data-hmr-error')).toBe('true');
-      expect(mockIsland.getAttribute('data-hmr-error-message')).toBe('Test error');
-    } catch (e) {
-      // Expected in test environment without DOM
-      // Accept any error - the important thing is it doesn't crash silently
-      expect(e).toBeDefined();
-    }
-  });
-});
-
-describe('StateSnapshot - structure validation', () => {
-  it('should have correct structure', () => {
-    const snapshot: StateSnapshot = {
-      framework: 'test',
-      timestamp: Date.now(),
-      data: { key: 'value' },
-      dom: {
-        scrollPosition: { x: 0, y: 100 },
-        focusedElement: '#input',
-        formValues: { name: 'test' },
-      },
-    };
-    
-    // Verify structure
-    expect(typeof snapshot.framework).toBe('string');
-    expect(typeof snapshot.timestamp).toBe('number');
-    expect(typeof snapshot.data).toBe('object');
-    expect(snapshot.dom).toBeDefined();
-    expect(snapshot.dom?.scrollPosition).toBeDefined();
-    expect(snapshot.dom?.focusedElement).toBeDefined();
-    expect(snapshot.dom?.formValues).toBeDefined();
-  });
-});

package/src/client/tests/hmr-coordinator.test.ts

@@ -1,176 +0,0 @@
-/**
- * Tests for HMR Coordinator
- * 
- * These tests verify the core HMR infrastructure functionality.
- */
-
-import { describe, it, expect } from 'vitest';
-import { HMRCoordinator, type FrameworkHMRAdapter, type StateSnapshot } from '../hmr-coordinator.ts';
-
-// Mock DOM environment for testing
-class MockHTMLElement {
-  private attributes: Map<string, string> = new Map();
-  private _children: MockHTMLElement[] = [];
-  
-  getAttribute(name: string): string | null {
-    return this.attributes.get(name) || null;
-  }
-  
-  setAttribute(name: string, value: string): void {
-    this.attributes.set(name, value);
-  }
-  
-  removeAttribute(name: string): void {
-    this.attributes.delete(name);
-  }
-  
-  hasAttribute(name: string): boolean {
-    return this.attributes.has(name);
-  }
-  
-  querySelector(selector: string): MockHTMLElement | null {
-    return null;
-  }
-  
-  dispatchEvent(event: any): boolean {
-    return true;
-  }
-}
-
-// Mock adapter for testing
-class MockFrameworkAdapter implements FrameworkHMRAdapter {
-  readonly name = 'mock';
-  
-  canHandle(component: unknown): boolean {
-    return true;
-  }
-  
-  preserveState(island: HTMLElement): StateSnapshot | null {
-    return {
-      framework: 'mock',
-      timestamp: Date.now(),
-      data: { test: 'value' },
-    };
-  }
-  
-  async update(
-    island: HTMLElement,
-    newComponent: unknown,
-    props: Record<string, unknown>
-  ): Promise<void> {
-    // Mock update
-  }
-  
-  restoreState(island: HTMLElement, state: StateSnapshot): void {
-    // Mock restore
-  }
-  
-  handleError(island: HTMLElement, error: Error): void {
-    // Mock error handling
-  }
-}
-
-describe('HMRCoordinator - initialization', () => {
-  it('should create coordinator', () => {
-    const coordinator = new HMRCoordinator();
-    expect(coordinator).toBeDefined();
-  });
-});
-
-describe('HMRCoordinator - adapter registration', () => {
-  it('should register adapter', () => {
-    const coordinator = new HMRCoordinator();
-    const adapter = new MockFrameworkAdapter();
-    
-    coordinator.registerAdapter('mock', adapter);
-    
-    // Verify adapter was registered (indirectly through behavior)
-    expect(coordinator).toBeDefined();
-  });
-});
-
-describe('HMRCoordinator - path normalization', () => {
-  it('should have expected methods', () => {
-    const coordinator = new HMRCoordinator();
-    
-    // Test that coordinator can be created and is functional
-    // Path normalization is tested indirectly through the implementation
-    expect(coordinator).toBeDefined();
-    
-    // Verify the coordinator has the expected methods
-    expect(typeof coordinator.initialize).toBe('function');
-    expect(typeof coordinator.registerAdapter).toBe('function');
-    expect(typeof coordinator.findAffectedIslands).toBe('function');
-  });
-});
-
-describe('HMRCoordinator - island module detection', () => {
-  it('should have findAffectedIslands method', () => {
-    const coordinator = new HMRCoordinator();
-    
-    // Test that coordinator can handle different path formats
-    // Without DOM, we can't test actual island discovery, but we can verify the method exists
-    expect(coordinator.findAffectedIslands).toBeDefined();
-    expect(typeof coordinator.findAffectedIslands).toBe('function');
-  });
-});
-
-describe('HMRCoordinator - update payload handling', () => {
-  it('should have handleUpdate method', async () => {
-    const coordinator = new HMRCoordinator();
-    
-    // Test update payload structure without DOM
-    // Verify coordinator can handle the payload structure
-    // In a real browser environment with DOM, this would trigger updates
-    expect(coordinator.handleUpdate).toBeDefined();
-    expect(typeof coordinator.handleUpdate).toBe('function');
-  });
-});
-
-describe('HMRCoordinator - state snapshot structure', () => {
-  it('should create valid snapshot', () => {
-    const adapter = new MockFrameworkAdapter();
-    const mockIsland = new MockHTMLElement() as unknown as HTMLElement;
-    
-    const snapshot = adapter.preserveState(mockIsland);
-    
-    expect(snapshot).toBeDefined();
-    expect(snapshot?.framework).toBe('mock');
-    expect(typeof snapshot?.timestamp).toBe('number');
-    expect(snapshot?.data).toBeDefined();
-  });
-});
-
-describe('HMRCoordinator - error handling', () => {
-  it('should handle errors without throwing', () => {
-    const adapter = new MockFrameworkAdapter();
-    const mockIsland = new MockHTMLElement() as unknown as HTMLElement;
-    const error = new Error('Test error');
-    
-    // Should not throw when handling errors
-    adapter.handleError(mockIsland, error);
-    
-    expect(adapter).toBeDefined();
-  });
-});
-
-describe('HMRCoordinator - module update types', () => {
-  it('should handle all update types', async () => {
-    const coordinator = new HMRCoordinator();
-    
-    // Test different update types
-    const updateTypes = [
-      { type: 'update' as const, shouldProcess: true },
-      { type: 'full-reload' as const, shouldProcess: false },
-      { type: 'prune' as const, shouldProcess: false },
-      { type: 'error' as const, shouldProcess: false },
-    ];
-    
-    for (const { type, shouldProcess } of updateTypes) {
-      // Verify coordinator can handle all payload types
-      expect(coordinator.handleUpdate).toBeDefined();
-    }
-    
-    expect(coordinator).toBeDefined();
-  });
-});