@jasperoosthoek/zustand-auth-registry 0.0.1

package/src/__tests__/createAuthRegistry.test.ts

@@ -0,0 +1,202 @@
+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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,142 @@
+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;
+};