@jmruthers/pace-core 0.5.68 → 0.5.70

package/src/services/__tests__/AuthService.test.ts

@@ -0,0 +1,356 @@
+/**
+ * @file AuthService Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Services/__tests__
+ * @since 0.1.0
+ *
+ * Unit tests for AuthService class.
+ * Tests authentication operations, state management, and error handling.
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { AuthService } from '../AuthService';
+import { AuthError } from '@supabase/supabase-js';
+
+// Mock Supabase client
+const createMockSupabaseClient = () => ({
+  auth: {
+    signInWithPassword: vi.fn(),
+    signUp: vi.fn(),
+    signOut: vi.fn(),
+    resetPasswordForEmail: vi.fn(),
+    updateUser: vi.fn(),
+    refreshSession: vi.fn(),
+    getSession: vi.fn(),
+    getUser: vi.fn(),
+    onAuthStateChange: vi.fn(),
+  },
+});
+
+describe('AuthService', () => {
+  let mockSupabase: ReturnType<typeof createMockSupabaseClient>;
+  let authService: AuthService;
+
+  beforeEach(() => {
+    mockSupabase = createMockSupabaseClient();
+    authService = new AuthService(mockSupabase as any);
+  });
+
+  afterEach(() => {
+    authService.cleanup();
+    vi.clearAllMocks();
+  });
+
+  describe('Initialization', () => {
+    it('should initialize with default state', () => {
+      expect(authService.getUser()).toBeNull();
+      expect(authService.getSession()).toBeNull();
+      expect(authService.isAuthenticated()).toBe(false);
+      expect(authService.isLoading()).toBe(true);
+      expect(authService.getError()).toBeNull();
+    });
+
+    it('should initialize service when created', async () => {
+      mockSupabase.auth.getSession.mockResolvedValue({
+        data: { session: null },
+        error: null
+      });
+      mockSupabase.auth.getUser.mockResolvedValue({
+        data: { user: null },
+        error: null
+      });
+      mockSupabase.auth.onAuthStateChange.mockReturnValue({
+        data: { subscription: { unsubscribe: vi.fn() } }
+      });
+
+      await authService.initialize();
+
+      expect(mockSupabase.auth.getSession).toHaveBeenCalled();
+      expect(mockSupabase.auth.onAuthStateChange).toHaveBeenCalled();
+    });
+  });
+
+  describe('Sign In', () => {
+    it('should sign in user successfully', async () => {
+      const mockUser = { id: '1', email: 'test@example.com' };
+      const mockSession = { access_token: 'token', user: mockUser };
+
+      mockSupabase.auth.signInWithPassword.mockResolvedValue({
+        data: { user: mockUser, session: mockSession },
+        error: null
+      });
+
+      const result = await authService.signIn('test@example.com', 'password');
+
+      expect(result.user).toEqual(mockUser);
+      expect(result.session).toEqual(mockSession);
+      expect(result.error).toBeNull();
+      expect(authService.getUser()).toEqual(mockUser);
+      expect(authService.getSession()).toEqual(mockSession);
+      expect(authService.isAuthenticated()).toBe(true);
+    });
+
+    it('should handle sign in errors', async () => {
+      const mockError = new AuthError('Invalid credentials');
+
+      mockSupabase.auth.signInWithPassword.mockResolvedValue({
+        data: { user: null, session: null },
+        error: mockError
+      });
+
+      const result = await authService.signIn('test@example.com', 'wrongpassword');
+
+      expect(result.user).toBeNull();
+      expect(result.session).toBeNull();
+      expect(result.error).toEqual(mockError);
+      expect(authService.getError()).toEqual(mockError);
+      expect(authService.isAuthenticated()).toBe(false);
+    });
+
+    it('should handle missing Supabase client', async () => {
+      const serviceWithoutClient = new AuthService(null as any);
+      
+      const result = await serviceWithoutClient.signIn('test@example.com', 'password');
+
+      expect(result.error).toBeInstanceOf(AuthError);
+      expect(result.error?.message).toBe('Supabase client not available');
+    });
+  });
+
+  describe('Sign Up', () => {
+    it('should sign up user successfully', async () => {
+      const mockUser = { id: '1', email: 'test@example.com' };
+      const mockSession = { access_token: 'token', user: mockUser };
+
+      mockSupabase.auth.signUp.mockResolvedValue({
+        data: { user: mockUser, session: mockSession },
+        error: null
+      });
+
+      const result = await authService.signUp('test@example.com', 'password');
+
+      expect(result.user).toEqual(mockUser);
+      expect(result.session).toEqual(mockSession);
+      expect(result.error).toBeNull();
+      expect(authService.getUser()).toEqual(mockUser);
+      expect(authService.getSession()).toEqual(mockSession);
+      expect(authService.isAuthenticated()).toBe(true);
+    });
+
+    it('should handle sign up errors', async () => {
+      const mockError = new AuthError('Email already registered');
+
+      mockSupabase.auth.signUp.mockResolvedValue({
+        data: { user: null, session: null },
+        error: mockError
+      });
+
+      const result = await authService.signUp('test@example.com', 'password');
+
+      expect(result.user).toBeNull();
+      expect(result.session).toBeNull();
+      expect(result.error).toEqual(mockError);
+      expect(authService.getError()).toEqual(mockError);
+    });
+  });
+
+  describe('Sign Out', () => {
+    it('should sign out user successfully', async () => {
+      // First sign in a user
+      const mockUser = { id: '1', email: 'test@example.com' };
+      const mockSession = { access_token: 'token', user: mockUser };
+
+      mockSupabase.auth.signInWithPassword.mockResolvedValue({
+        data: { user: mockUser, session: mockSession },
+        error: null
+      });
+
+      await authService.signIn('test@example.com', 'password');
+      expect(authService.isAuthenticated()).toBe(true);
+
+      // Then sign out
+      mockSupabase.auth.signOut.mockResolvedValue({
+        error: null
+      });
+
+      const result = await authService.signOut();
+
+      expect(result.error).toBeNull();
+      expect(authService.getUser()).toBeNull();
+      expect(authService.getSession()).toBeNull();
+      expect(authService.isAuthenticated()).toBe(false);
+    });
+
+    it('should handle sign out errors', async () => {
+      const mockError = new AuthError('Sign out failed');
+
+      mockSupabase.auth.signOut.mockResolvedValue({
+        error: mockError
+      });
+
+      const result = await authService.signOut();
+
+      expect(result.error).toEqual(mockError);
+      expect(authService.getError()).toEqual(mockError);
+    });
+  });
+
+  describe('Password Reset', () => {
+    it('should reset password successfully', async () => {
+      mockSupabase.auth.resetPasswordForEmail.mockResolvedValue({
+        error: null
+      });
+
+      const result = await authService.resetPassword('test@example.com');
+
+      expect(result.error).toBeNull();
+      expect(mockSupabase.auth.resetPasswordForEmail).toHaveBeenCalledWith('test@example.com');
+    });
+
+    it('should handle password reset errors', async () => {
+      const mockError = new AuthError('Email not found');
+
+      mockSupabase.auth.resetPasswordForEmail.mockResolvedValue({
+        error: mockError
+      });
+
+      const result = await authService.resetPassword('test@example.com');
+
+      expect(result.error).toEqual(mockError);
+      expect(authService.getError()).toEqual(mockError);
+    });
+  });
+
+  describe('Update Password', () => {
+    it('should update password successfully', async () => {
+      mockSupabase.auth.updateUser.mockResolvedValue({
+        error: null
+      });
+
+      const result = await authService.updatePassword('newpassword');
+
+      expect(result.error).toBeNull();
+      expect(mockSupabase.auth.updateUser).toHaveBeenCalledWith({
+        password: 'newpassword'
+      });
+    });
+
+    it('should handle update password errors', async () => {
+      const mockError = new AuthError('Password too weak');
+
+      mockSupabase.auth.updateUser.mockResolvedValue({
+        error: mockError
+      });
+
+      const result = await authService.updatePassword('weak');
+
+      expect(result.error).toEqual(mockError);
+      expect(authService.getError()).toEqual(mockError);
+    });
+  });
+
+  describe('Refresh Session', () => {
+    it('should refresh session successfully', async () => {
+      mockSupabase.auth.refreshSession.mockResolvedValue({
+        error: null
+      });
+
+      const result = await authService.refreshSession();
+
+      expect(result.error).toBeNull();
+      expect(mockSupabase.auth.refreshSession).toHaveBeenCalled();
+    });
+
+    it('should handle refresh session errors', async () => {
+      const mockError = new AuthError('Session expired');
+
+      mockSupabase.auth.refreshSession.mockResolvedValue({
+        error: mockError
+      });
+
+      const result = await authService.refreshSession();
+
+      expect(result.error).toEqual(mockError);
+      expect(authService.getError()).toEqual(mockError);
+    });
+  });
+
+  describe('State Management', () => {
+    it('should notify subscribers when state changes', async () => {
+      const mockUser = { id: '1', email: 'test@example.com' };
+      const mockSession = { access_token: 'token', user: mockUser };
+
+      mockSupabase.auth.signInWithPassword.mockResolvedValue({
+        data: { user: mockUser, session: mockSession },
+        error: null
+      });
+
+      const subscriber = vi.fn();
+      const unsubscribe = authService.subscribe(subscriber);
+
+      await authService.signIn('test@example.com', 'password');
+
+      expect(subscriber).toHaveBeenCalled();
+
+      unsubscribe();
+    });
+
+    it('should cleanup subscriptions on cleanup', () => {
+      const subscriber = vi.fn();
+      authService.subscribe(subscriber);
+
+      authService.cleanup();
+
+      // After cleanup, new state changes shouldn't notify subscribers
+      const mockUser = { id: '1', email: 'test@example.com' };
+      const mockSession = { access_token: 'token', user: mockUser };
+
+      mockSupabase.auth.signInWithPassword.mockResolvedValue({
+        data: { user: mockUser, session: mockSession },
+        error: null
+      });
+
+      authService.signIn('test@example.com', 'password');
+
+      // Subscriber should not be called after cleanup
+      expect(subscriber).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle network errors', async () => {
+      const networkError = new Error('Network error');
+
+      mockSupabase.auth.signInWithPassword.mockRejectedValue(networkError);
+
+      const result = await authService.signIn('test@example.com', 'password');
+
+      expect(result.error).toBeInstanceOf(AuthError);
+      expect(result.error?.message).toBe('Network error');
+    });
+
+    it('should clear errors on successful operations', async () => {
+      // First cause an error
+      const mockError = new AuthError('Invalid credentials');
+      mockSupabase.auth.signInWithPassword.mockResolvedValue({
+        data: { user: null, session: null },
+        error: mockError
+      });
+
+      await authService.signIn('test@example.com', 'wrongpassword');
+      expect(authService.getError()).toEqual(mockError);
+
+      // Then succeed
+      const mockUser = { id: '1', email: 'test@example.com' };
+      const mockSession = { access_token: 'token', user: mockUser };
+
+      mockSupabase.auth.signInWithPassword.mockResolvedValue({
+        data: { user: mockUser, session: mockSession },
+        error: null
+      });
+
+      await authService.signIn('test@example.com', 'password');
+      expect(authService.getError()).toBeNull();
+    });
+  });
+});

package/src/services/__tests__/BaseService.test.ts

@@ -0,0 +1,314 @@
+/**
+ * @file BaseService Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Services/__tests__
+ * @since 0.1.0
+ *
+ * Unit tests for BaseService class.
+ * Tests the observable pattern implementation.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { BaseService } from '../base/BaseService';
+
+// Create a concrete implementation of BaseService for testing
+class TestService extends BaseService {
+  private _value = 0;
+
+  getValue(): number {
+    return this._value;
+  }
+
+  setValue(value: number): void {
+    this._value = value;
+    this.notify(); // Trigger notification
+  }
+
+  // Expose protected method for testing
+  testNotify(): void {
+    this.notify();
+  }
+
+  // Implement abstract methods
+  protected async doInitialize(): Promise<void> {
+    // No initialization needed for test
+  }
+
+  protected doCleanup(): void {
+    // No cleanup needed for test
+  }
+}
+
+describe('BaseService', () => {
+  let testService: TestService;
+
+  beforeEach(() => {
+    testService = new TestService();
+  });
+
+  describe('Observable Pattern', () => {
+    it('should subscribe to state changes', () => {
+      const listener = vi.fn();
+      const unsubscribe = testService.subscribe(listener);
+
+      testService.setValue(42);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+
+      unsubscribe();
+    });
+
+    it('should unsubscribe from state changes', () => {
+      const listener = vi.fn();
+      const unsubscribe = testService.subscribe(listener);
+
+      testService.setValue(42);
+      expect(listener).toHaveBeenCalledTimes(1);
+
+      unsubscribe();
+      testService.setValue(100);
+
+      expect(listener).toHaveBeenCalledTimes(1); // Should not be called after unsubscribe
+    });
+
+    it('should handle multiple subscribers', () => {
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      const listener3 = vi.fn();
+
+      const unsubscribe1 = testService.subscribe(listener1);
+      const unsubscribe2 = testService.subscribe(listener2);
+      const unsubscribe3 = testService.subscribe(listener3);
+
+      testService.setValue(42);
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect(listener3).toHaveBeenCalledTimes(1);
+
+      unsubscribe1();
+      unsubscribe2();
+      unsubscribe3();
+    });
+
+    it('should handle partial unsubscription', () => {
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      const listener3 = vi.fn();
+
+      const unsubscribe1 = testService.subscribe(listener1);
+      const unsubscribe2 = testService.subscribe(listener2);
+      const unsubscribe3 = testService.subscribe(listener3);
+
+      testService.setValue(42);
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect(listener3).toHaveBeenCalledTimes(1);
+
+      unsubscribe2(); // Unsubscribe only listener2
+
+      testService.setValue(100);
+
+      expect(listener1).toHaveBeenCalledTimes(2);
+      expect(listener2).toHaveBeenCalledTimes(1); // Should not be called
+      expect(listener3).toHaveBeenCalledTimes(2);
+
+      unsubscribe1();
+      unsubscribe3();
+    });
+
+    it('should handle duplicate subscriptions', () => {
+      const listener = vi.fn();
+
+      const unsubscribe1 = testService.subscribe(listener);
+      const unsubscribe2 = testService.subscribe(listener); // Same listener
+
+      testService.setValue(42);
+
+      expect(listener).toHaveBeenCalledTimes(2); // Called twice for duplicate subscription
+
+      unsubscribe1();
+      unsubscribe2();
+    });
+
+    it('should handle unsubscribe called multiple times', () => {
+      const listener = vi.fn();
+      const unsubscribe = testService.subscribe(listener);
+
+      testService.setValue(42);
+      expect(listener).toHaveBeenCalledTimes(1);
+
+      unsubscribe();
+      unsubscribe(); // Call unsubscribe again
+
+      testService.setValue(100);
+      expect(listener).toHaveBeenCalledTimes(1); // Should not be called
+    });
+  });
+
+  describe('Cleanup', () => {
+    it('should cleanup all subscriptions', () => {
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      const listener3 = vi.fn();
+
+      testService.subscribe(listener1);
+      testService.subscribe(listener2);
+      testService.subscribe(listener3);
+
+      testService.setValue(42);
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect(listener3).toHaveBeenCalledTimes(1);
+
+      testService.cleanup();
+
+      testService.setValue(100);
+
+      expect(listener1).toHaveBeenCalledTimes(1); // Should not be called after cleanup
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect(listener3).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle cleanup when no subscriptions exist', () => {
+      // Should not throw error
+      expect(() => testService.cleanup()).not.toThrow();
+    });
+
+    it('should handle multiple cleanup calls', () => {
+      const listener = vi.fn();
+      testService.subscribe(listener);
+
+      testService.cleanup();
+      testService.cleanup(); // Second cleanup call
+
+      // Should not throw error
+      expect(() => testService.cleanup()).not.toThrow();
+    });
+  });
+
+  describe('Notification', () => {
+    it('should notify all subscribers', () => {
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      const listener3 = vi.fn();
+
+      testService.subscribe(listener1);
+      testService.subscribe(listener2);
+      testService.subscribe(listener3);
+
+      testService.testNotify();
+
+      expect(listener1).toHaveBeenCalledTimes(1);
+      expect(listener2).toHaveBeenCalledTimes(1);
+      expect(listener3).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle notification when no subscribers exist', () => {
+      // Should not throw error
+      expect(() => testService.testNotify()).not.toThrow();
+    });
+
+    it('should handle subscriber errors gracefully', () => {
+      const errorListener = vi.fn(() => {
+        throw new Error('Subscriber error');
+      });
+      const normalListener = vi.fn();
+
+      testService.subscribe(errorListener);
+      testService.subscribe(normalListener);
+
+      // Should not throw error, and normal listener should still be called
+      expect(() => testService.testNotify()).not.toThrow();
+      expect(normalListener).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle multiple errors in subscribers', () => {
+      const errorListener1 = vi.fn(() => {
+        throw new Error('Subscriber error 1');
+      });
+      const errorListener2 = vi.fn(() => {
+        throw new Error('Subscriber error 2');
+      });
+      const normalListener = vi.fn();
+
+      testService.subscribe(errorListener1);
+      testService.subscribe(errorListener2);
+      testService.subscribe(normalListener);
+
+      // Should not throw error, and normal listener should still be called
+      expect(() => testService.testNotify()).not.toThrow();
+      expect(normalListener).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Memory Management', () => {
+    it('should not leak memory with many subscriptions', () => {
+      const listeners = Array.from({ length: 1000 }, () => vi.fn());
+      const unsubscribes = listeners.map(listener => testService.subscribe(listener));
+
+      testService.setValue(42);
+
+      // All listeners should be called
+      listeners.forEach(listener => {
+        expect(listener).toHaveBeenCalledTimes(1);
+      });
+
+      // Unsubscribe all
+      unsubscribes.forEach(unsubscribe => unsubscribe());
+
+      testService.setValue(100);
+
+      // No listeners should be called
+      listeners.forEach(listener => {
+        expect(listener).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    it('should handle rapid subscription/unsubscription', () => {
+      const listener = vi.fn();
+
+      for (let i = 0; i < 100; i++) {
+        const unsubscribe = testService.subscribe(listener);
+        testService.setValue(i);
+        unsubscribe();
+      }
+
+      expect(listener).toHaveBeenCalledTimes(100);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle null listener', () => {
+      // Should not throw error
+      expect(() => testService.subscribe(null as any)).not.toThrow();
+    });
+
+    it('should handle undefined listener', () => {
+      // Should not throw error
+      expect(() => testService.subscribe(undefined as any)).not.toThrow();
+    });
+
+    it('should handle function that returns a value', () => {
+      const listener = vi.fn(() => 'return value');
+      testService.subscribe(listener);
+
+      testService.setValue(42);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle async listener', async () => {
+      const listener = vi.fn(async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+      });
+
+      testService.subscribe(listener);
+      testService.setValue(42);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+  });
+});