@jasperoosthoek/zustand-auth-registry 0.0.1 → 0.0.2

package/src/__tests__/createAuthRegistry.test.ts

@@ -1,202 +0,0 @@
-import { createAuthRegistry } from '../createAuthRegistry';
-import { TestUser, createMockAxios } from './testHelpers';
-import { testConfigs } from './testUtils';
-
-describe('createAuthRegistry', () => {
-  interface TestModels {
-    main: TestUser;
-    admin: TestUser;
-  }
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should create a registry function', () => {
-    const getAuthStore = createAuthRegistry<TestModels>();
-    expect(typeof getAuthStore).toBe('function');
-  });
-
-  describe('store creation', () => {
-    it('should create stores with correct configuration', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      const mockAxios = createMockAxios();
-      
-      const config = {
-        axios: mockAxios,
-        loginUrl: '/auth/login',
-        logoutUrl: '/auth/logout',
-        getUserUrl: '/auth/me',
-        extractToken: (data: any) => data.auth_token
-      };
-
-      const store = getAuthStore('main', config);
-
-      expect(store).toBeDefined();
-      expect(store.config).toBeDefined();
-      expect(store.config.axios).toBe(mockAxios);
-      expect(store.config.loginUrl).toBe('/auth/login');
-      expect(store.config.logoutUrl).toBe('/auth/logout');
-      expect(store.config.getUserUrl).toBe('/auth/me');
-      expect(store.config.extractToken).toBe(config.extractToken);
-    });
-
-    it('should return same store instance for same key', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      const config = testConfigs.basic;
-
-      const store1 = getAuthStore('main', config);
-      const store2 = getAuthStore('main', config);
-
-      expect(store1).toBe(store2);
-    });
-
-    it('should create different stores for different keys', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      const config = testConfigs.basic;
-
-      const mainStore = getAuthStore('main', config);
-      const adminStore = getAuthStore('admin', config);
-
-      expect(mainStore).not.toBe(adminStore);
-      expect(mainStore.config.loginUrl).toBe(adminStore.config.loginUrl);
-      expect(mainStore.config.logoutUrl).toBe(adminStore.config.logoutUrl);
-    });
-
-    it('should validate config before store creation', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      
-      expect(() => {
-        getAuthStore('main', {
-          loginUrl: '/login',
-          logoutUrl: '/logout',
-          extractToken: (data: any) => data.token
-        } as any);
-      }).toThrow('AuthConfig: axios instance is required');
-    });
-  });
-
-  describe('store functionality', () => {
-    it('should create store with initial empty state', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      const store = getAuthStore('main', testConfigs.basic);
-
-      const state = store.getState();
-      expect(state.user).toBeNull();
-      expect(state.token).toBe('');
-      expect(state.isAuthenticated).toBe(false);
-    });
-
-    it('should create store with working setters', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      const store = getAuthStore('main', testConfigs.basic);
-
-      const { setToken, setUser } = store.getState();
-      
-      expect(typeof setToken).toBe('function');
-      expect(typeof setUser).toBe('function');
-      expect(typeof store.getState().unsetUser).toBe('function');
-    });
-
-    it('should create store with config attached', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      const config = testConfigs.basic;
-      const store = getAuthStore('main', config);
-
-      expect(store.config).toBeDefined();
-      expect(store.config.loginUrl).toBe(config.loginUrl);
-      expect(store.config.persistence.enabled).toBe(true);
-    });
-  });
-
-  describe('type safety', () => {
-    it('should enforce correct model types for keys', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      const config = testConfigs.basic;
-
-      // These should compile without errors
-      const mainStore = getAuthStore('main', config);
-      const adminStore = getAuthStore('admin', config);
-
-      expect(mainStore).toBeDefined();
-      expect(adminStore).toBeDefined();
-    });
-
-    it('should support multiple user types in same registry', () => {
-      interface MultiModel {
-        user: TestUser;
-        admin: TestUser & { permissions: string[] };
-      }
-
-      const getAuthStore = createAuthRegistry<MultiModel>();
-      const config = testConfigs.basic;
-
-      const userStore = getAuthStore('user', config);
-      const adminStore = getAuthStore('admin', config);
-
-      expect(userStore).not.toBe(adminStore);
-      expect(typeof userStore.getState().setUser).toBe('function');
-      expect(typeof adminStore.getState().setUser).toBe('function');
-    });
-  });
-
-  describe('config validation integration', () => {
-    it('should apply default persistence settings', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      const config = {
-        axios: createMockAxios(),
-        loginUrl: '/login',
-        logoutUrl: '/logout',
-        extractToken: (data: any) => data.token
-      };
-
-      const store = getAuthStore('main', config);
-
-      expect(store.config.persistence.enabled).toBe(true);
-      expect(store.config.persistence.tokenKey).toBe('token');
-      expect(store.config.persistence.userKey).toBe('user');
-    });
-
-    it('should apply default auth header format', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      const store = getAuthStore('main', testConfigs.basic);
-
-      const headerValue = store.config.formatAuthHeader('test-token');
-      expect(headerValue).toBe('Bearer test-token');
-    });
-
-    it('should preserve custom configurations', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      const store = getAuthStore('main', testConfigs.withTokenFormat);
-
-      const headerValue = store.config.formatAuthHeader('test-token');
-      expect(headerValue).toBe('Token test-token');
-    });
-  });
-
-  describe('registry isolation', () => {
-    it('should isolate different registry instances', () => {
-      const registry1 = createAuthRegistry<TestModels>();
-      const registry2 = createAuthRegistry<TestModels>();
-
-      const store1 = registry1('main', testConfigs.basic);
-      const store2 = registry2('main', testConfigs.basic);
-
-      expect(store1).not.toBe(store2);
-    });
-
-    it('should maintain store state independently', () => {
-      const getAuthStore = createAuthRegistry<TestModels>();
-      
-      const mainStore = getAuthStore('main', testConfigs.basic);
-      const adminStore = getAuthStore('admin', testConfigs.basic);
-
-      // Set user in main store
-      mainStore.getState().setUser({ id: 1, email: 'main@test.com', name: 'Main User' });
-
-      // Admin store should remain empty
-      expect(mainStore.getState().user).not.toBeNull();
-      expect(adminStore.getState().user).toBeNull();
-    });
-  });
-});

package/src/__tests__/testHelpers.ts

@@ -1,92 +0,0 @@
-import { act } from '@testing-library/react';
-
-// Mock axios instance for auth testing
-export const createMockAxios = () => ({
-  get: jest.fn(),
-  post: jest.fn(),
-  put: jest.fn(),
-  patch: jest.fn(), 
-  delete: jest.fn(),
-  defaults: {
-    headers: {
-      common: {} as Record<string, string>
-    }
-  },
-  interceptors: {
-    request: { use: jest.fn(), eject: jest.fn() },
-    response: { use: jest.fn(), eject: jest.fn() }
-  }
-});
-
-// Mock user types for testing
-export interface TestUser {
-  id: number;
-  email: string;
-  name: string;
-  role?: string;
-}
-
-export const mockUser: TestUser = {
-  id: 1,
-  email: 'test@example.com',
-  name: 'Test User',
-  role: 'admin'
-};
-
-// Mock API responses
-export const mockLoginResponse = {
-  auth_token: 'mock-jwt-token-12345',
-  user: mockUser
-};
-
-// Mock storage for persistence testing
-export const createMockStorage = () => {
-  const storage: Record<string, string> = {};
-  return {
-    getItem: jest.fn((key: string) => storage[key] || null),
-    setItem: jest.fn((key: string, value: string) => { storage[key] = value; }),
-    removeItem: jest.fn((key: string) => { delete storage[key]; }),
-    clear: jest.fn(() => Object.keys(storage).forEach(key => delete storage[key]))
-  };
-};
-
-// Helper for async operations in tests
-export const waitFor = (condition: () => boolean, timeout: number = 5000) => {
-  return new Promise<void>((resolve, reject) => {
-    const startTime = Date.now();
-    const check = () => {
-      if (condition()) resolve();
-      else if (Date.now() - startTime > timeout) reject(new Error('Timeout'));
-      else setTimeout(check, 10);
-    };
-    check();
-  });
-};
-
-// Helper for simulating user actions
-export const simulateUserAction = async (action: () => Promise<void> | void) => {
-  await act(async () => {
-    await action();
-  });
-};
-
-// Mock error creator for testing error handling
-export const createMockError = (message: string, status: number = 400) => {
-  const error = new Error(message);
-  (error as any).response = { status, data: { detail: message } };
-  return error;
-};
-
-// Helper for testing auth header formats
-export const extractAuthHeader = (mockAxios: any): string | undefined => {
-  return mockAxios.defaults.headers.common['Authorization'];
-};
-
-// Helper to reset all mocks
-export const resetAllMocks = () => {
-  jest.clearAllMocks();
-  (window.localStorage.getItem as jest.Mock).mockClear();
-  (window.localStorage.setItem as jest.Mock).mockClear();
-  (window.localStorage.removeItem as jest.Mock).mockClear();
-  (window.localStorage.clear as jest.Mock).mockClear();
-};

package/src/__tests__/testUtils.ts

@@ -1,142 +0,0 @@
-import { TestUser, createMockAxios, mockUser } from './testHelpers';
-
-// Extended test user types for complex scenarios
-export interface ExtendedTestUser extends TestUser {
-  permissions?: string[];
-  lastLogin?: string;
-  isActive?: boolean;
-}
-
-export const mockUsers: ExtendedTestUser[] = [
-  {
-    id: 1,
-    email: 'admin@example.com',
-    name: 'Admin User',
-    role: 'admin',
-    permissions: ['read', 'write', 'delete'],
-    isActive: true
-  },
-  {
-    id: 2,
-    email: 'user@example.com', 
-    name: 'Regular User',
-    role: 'user',
-    permissions: ['read'],
-    isActive: true
-  },
-  {
-    id: 3,
-    email: 'inactive@example.com',
-    name: 'Inactive User',
-    role: 'user',
-    permissions: [],
-    isActive: false
-  }
-];
-
-// Different auth configurations for testing
-export const createTestAuthConfig = (overrides: any = {}) => ({
-  axios: createMockAxios(),
-  loginUrl: '/auth/login',
-  logoutUrl: '/auth/logout',
-  getUserUrl: '/auth/me',
-  extractToken: (data: any) => data.auth_token,
-  ...overrides
-});
-
-// Mock responses for different scenarios
-export const mockResponses = {
-  loginSuccess: { 
-    data: { 
-      auth_token: 'mock-jwt-token-12345',
-      user: mockUser 
-    } 
-  },
-  loginFailure: { 
-    response: { 
-      status: 401, 
-      data: { detail: 'Invalid credentials' } 
-    } 
-  },
-  userSuccess: { 
-    data: mockUser 
-  },
-  userFailure: { 
-    response: { 
-      status: 403, 
-      data: { detail: 'Unauthorized' } 
-    } 
-  },
-  logoutSuccess: { 
-    data: { message: 'Logged out successfully' } 
-  },
-  logoutFailure: { 
-    response: { 
-      status: 500, 
-      data: { detail: 'Server error' } 
-    } 
-  }
-};
-
-// Test auth configurations for different scenarios
-export const testConfigs = {
-  basic: createTestAuthConfig(),
-  withTokenFormat: createTestAuthConfig({
-    formatAuthHeader: (token: string) => `Token ${token}`
-  }),
-  withoutGetUser: createTestAuthConfig({
-    getUserUrl: undefined
-  }),
-  withCustomStorage: createTestAuthConfig({
-    persistence: {
-      enabled: true,
-      storage: window.sessionStorage,
-      tokenKey: 'custom_token',
-      userKey: 'custom_user'
-    }
-  }),
-  withoutPersistence: createTestAuthConfig({
-    persistence: {
-      enabled: false
-    }
-  }),
-  withCallbacks: createTestAuthConfig({
-    onError: jest.fn(),
-    onLogin: jest.fn(),
-    onLogout: jest.fn()
-  })
-};
-
-// Helper to create error objects that match Axios error structure
-export const createAxiosError = (message: string, status: number = 400, code?: string) => {
-  const error = new Error(message) as any;
-  error.response = {
-    status,
-    data: { detail: message },
-    statusText: getStatusText(status)
-  };
-  error.isAxiosError = true;
-  if (code) error.code = code;
-  return error;
-};
-
-// Helper to get HTTP status text
-const getStatusText = (status: number): string => {
-  const statusTexts: Record<number, string> = {
-    200: 'OK',
-    201: 'Created',
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    403: 'Forbidden',
-    404: 'Not Found',
-    500: 'Internal Server Error'
-  };
-  return statusTexts[status] || 'Unknown';
-};
-
-// Helper to simulate storage quota exceeded
-export const createStorageQuotaError = () => {
-  const error = new Error('QuotaExceededError');
-  error.name = 'QuotaExceededError';
-  return error;
-};