@oxyhq/services 5.5.8 → 5.6.0

package/src/__tests__/backend-middleware.test.ts

@@ -1,209 +0,0 @@
-/**
- * Integration test for refactored authentication system
- * Tests the backend middleware functionality
- */
-
-import { OxyServices } from '../../core';
-
-describe('Authentication System Integration', () => {
-  let oxyServices: OxyServices;
-  let mockReq: any;
-  let mockRes: any;
-  let mockNext: any;
-
-  beforeEach(() => {
-    oxyServices = new OxyServices({
-      baseURL: 'https://api.test.com'
-    });
-
-    // Mock Express request/response objects
-    mockReq = {
-      headers: {},
-      user: undefined,
-      userId: undefined,
-      accessToken: undefined
-    };
-
-    mockRes = {
-      status: jest.fn().mockReturnThis(),
-      json: jest.fn().mockReturnThis()
-    };
-
-    mockNext = jest.fn();
-  });
-
-  describe('Middleware Creation', () => {
-    test('should create authentication middleware', () => {
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      expect(typeof middleware).toBe('function');
-      expect(middleware.length).toBe(3); // req, res, next
-    });
-
-    test('should create middleware with custom options', () => {
-      const customErrorHandler = jest.fn();
-      const middleware = oxyServices.createAuthenticateTokenMiddleware({
-        loadFullUser: false,
-        onError: customErrorHandler
-      });
-      
-      expect(typeof middleware).toBe('function');
-    });
-  });
-
-  describe('Token Validation', () => {
-    test('should handle missing token', async () => {
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      
-      await middleware(mockReq, mockRes, mockNext);
-      
-      expect(mockRes.status).toHaveBeenCalledWith(401);
-      expect(mockRes.json).toHaveBeenCalledWith({
-        message: 'Access token required',
-        code: 'MISSING_TOKEN'
-      });
-      expect(mockNext).not.toHaveBeenCalled();
-    });
-
-    test('should handle invalid token format', async () => {
-      mockReq.headers.authorization = 'InvalidFormat token123';
-      
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      await middleware(mockReq, mockRes, mockNext);
-      
-      expect(mockRes.status).toHaveBeenCalledWith(401);
-      expect(mockNext).not.toHaveBeenCalled();
-    });
-
-    test('should extract token from Bearer header', async () => {
-      mockReq.headers.authorization = 'Bearer valid.jwt.token';
-      
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      await middleware(mockReq, mockRes, mockNext);
-      
-      // Note: This will fail validation since it's not a real token,
-      // but we can verify the token was extracted
-      expect(mockRes.status).toHaveBeenCalled();
-    });
-  });
-
-  describe('Standalone Token Validation', () => {
-    test('should validate empty token', async () => {
-      const result = await oxyServices.authenticateToken('');
-      
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('Token is required');
-      expect(result.userId).toBeUndefined();
-      expect(result.user).toBeUndefined();
-    });
-
-    test('should validate invalid token', async () => {
-      const result = await oxyServices.authenticateToken('invalid.jwt.token');
-      
-      expect(result.valid).toBe(false);
-      expect(result.error).toBeTruthy();
-      expect(result.userId).toBeUndefined();
-      expect(result.user).toBeUndefined();
-    });
-
-    test('should handle validation errors gracefully', async () => {
-      const result = await oxyServices.authenticateToken('malformed-token');
-      
-      expect(result.valid).toBe(false);
-      expect(result.error).toMatch(/validation failed|Invalid/i);
-    });
-  });
-
-  describe('Custom Error Handling', () => {
-    test('should use custom error handler when provided', async () => {
-      const customErrorHandler = jest.fn();
-      const middleware = oxyServices.createAuthenticateTokenMiddleware({
-        onError: customErrorHandler
-      });
-      
-      await middleware(mockReq, mockRes, mockNext);
-      
-      expect(customErrorHandler).toHaveBeenCalledWith({
-        message: 'Access token required',
-        code: 'MISSING_TOKEN',
-        status: 401
-      });
-      expect(mockRes.status).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('Backend Integration Example', () => {
-    test('should work with Express.js route patterns', () => {
-      // Simulate Express.js app setup
-      const mockApp = {
-        get: jest.fn(),
-        post: jest.fn(),
-        use: jest.fn()
-      };
-
-      // Create middleware
-      const authenticateToken = oxyServices.createAuthenticateTokenMiddleware({
-        loadFullUser: true
-      });
-
-      // Simulate route registration
-      mockApp.get('/api/protected', authenticateToken, (req: any, res: any) => {
-        res.json({ 
-          message: 'Access granted',
-          user: req.user,
-          userId: req.userId 
-        });
-      });
-
-      expect(mockApp.get).toHaveBeenCalledWith(
-        '/api/protected',
-        authenticateToken,
-        expect.any(Function)
-      );
-    });
-
-    test('should provide consistent interface for different auth patterns', () => {
-      // Pattern 1: Middleware
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      expect(typeof middleware).toBe('function');
-
-      // Pattern 2: Standalone validation
-      const validateToken = oxyServices.authenticateToken.bind(oxyServices);
-      expect(typeof validateToken).toBe('function');
-
-      // Pattern 3: Direct service methods
-      expect(typeof oxyServices.getAccessToken).toBe('function');
-      expect(typeof oxyServices.setTokens).toBe('function');
-      expect(typeof oxyServices.clearTokens).toBe('function');
-    });
-  });
-
-  describe('Zero-Config Setup Verification', () => {
-    test('should work with minimal configuration', () => {
-      // This simulates the zero-config setup promise
-      const minimalSetup = () => {
-        // Backend: Just create OxyServices and use middleware
-        const services = new OxyServices({ baseURL: 'https://api.example.com' });
-        const authMiddleware = services.createAuthenticateTokenMiddleware();
-        
-        return { services, authMiddleware };
-      };
-
-      const { services, authMiddleware } = minimalSetup();
-      
-      expect(services).toBeInstanceOf(OxyServices);
-      expect(typeof authMiddleware).toBe('function');
-      expect(services.getBaseURL()).toBe('https://api.example.com');
-    });
-
-    test('should support runtime configuration changes', () => {
-      const services = new OxyServices({ baseURL: 'https://dev-api.com' });
-      
-      expect(services.getBaseURL()).toBe('https://dev-api.com');
-      
-      // Simulate runtime change to production
-      services.setBaseURL('https://prod-api.com');
-      
-      expect(services.getBaseURL()).toBe('https://prod-api.com');
-    });
-  });
-});

package/src/__tests__/polyfills.test.ts

@@ -1,30 +0,0 @@
-/**
- * Test file to verify FormData polyfill functionality
- */
-
-import { getFormDataConstructor } from '../utils/polyfills';
-
-describe('FormData Polyfill Tests', () => {
-  it('should provide FormData constructor', () => {
-    const FormDataConstructor = getFormDataConstructor();
-    expect(FormDataConstructor).toBeDefined();
-    expect(typeof FormDataConstructor).toBe('function');
-  });
-
-  it('should create FormData instance successfully', () => {
-    const FormDataConstructor = getFormDataConstructor();
-    const formData = new FormDataConstructor();
-    expect(formData).toBeDefined();
-    expect(typeof formData.append).toBe('function');
-  });
-
-  it('should handle form data append operations', () => {
-    const FormDataConstructor = getFormDataConstructor();
-    const formData = new FormDataConstructor();
-    
-    // Should not throw
-    expect(() => {
-      formData.append('test', 'value');
-    }).not.toThrow();
-  });
-});

package/src/__tests__/setup.ts

@@ -1,43 +0,0 @@
-import '@testing-library/jest-dom';
-
-// Mock React Native APIs
-global.jest = require('jest');
-
-// Mock Dimensions
-jest.mock('react-native', () => {
-  const RN = jest.requireActual('react-native');
-  return {
-    ...RN,
-    Dimensions: {
-      get: jest.fn().mockReturnValue({ width: 375, height: 800 }),
-    },
-    Platform: {
-      OS: 'web',
-      select: (options: any) => options.web || options.default,
-    },
-  };
-});
-
-// Mock AsyncStorage
-jest.mock('@react-native-async-storage/async-storage', () =>
-  require('@react-native-async-storage/async-storage/jest/async-storage-mock')
-);
-
-// Mock react-native-gesture-handler
-jest.mock('react-native-gesture-handler', () => {
-  const View = require('react-native').View;
-  return {
-    ScrollView: View,
-    PanGestureHandler: View,
-    TapGestureHandler: View,
-    FlingGestureHandler: View,
-    PinchGestureHandler: View,
-    RotationGestureHandler: View,
-    State: {},
-    PanResponder: {
-      create: jest.fn(() => ({
-        panHandlers: {},
-      })),
-    },
-  };
-});

package/src/__tests__/ui/hooks/useAuthFetch.test.ts

@@ -1,70 +0,0 @@
-/**
- * Tests for refactored useAuthFetch hook
- */
-
-import { OxyServices } from '../../../core';
-
-describe('useAuthFetch', () => {
-  let oxyServices: OxyServices;
-
-  beforeEach(() => {
-    oxyServices = new OxyServices({
-      baseURL: 'https://api.test.com'
-    });
-  });
-
-  describe('OxyServices integration', () => {
-    test('should set and get base URL', () => {
-      expect(oxyServices.getBaseURL()).toBe('https://api.test.com');
-      
-      oxyServices.setBaseURL('https://new-api.test.com');
-      expect(oxyServices.getBaseURL()).toBe('https://new-api.test.com');
-    });
-
-    test('should throw error for empty base URL', () => {
-      expect(() => oxyServices.setBaseURL('')).toThrow('Base URL cannot be empty');
-    });
-
-    test('should handle token validation methods', () => {
-      // Test that core methods exist
-      expect(typeof oxyServices.getAccessToken).toBe('function');
-      expect(typeof oxyServices.setTokens).toBe('function');
-      expect(typeof oxyServices.clearTokens).toBe('function');
-      expect(typeof oxyServices.refreshTokens).toBe('function');
-    });
-  });
-
-  describe('URL resolution', () => {
-    test('should resolve relative URLs correctly', () => {
-      // This tests the logic that would be used in resolveURL function
-      const baseURL = 'https://api.test.com';
-      
-      // Test relative URL with leading slash
-      const relativeUrl = '/api/users';
-      const expectedUrl = `${baseURL}${relativeUrl}`;
-      expect(expectedUrl).toBe('https://api.test.com/api/users');
-      
-      // Test relative URL without leading slash
-      const relativeUrl2 = 'api/users';
-      const expectedUrl2 = `${baseURL}/${relativeUrl2}`;
-      expect(expectedUrl2).toBe('https://api.test.com/api/users');
-      
-      // Test absolute URL (should remain unchanged)
-      const absoluteUrl = 'https://other-api.test.com/api/users';
-      expect(absoluteUrl).toBe('https://other-api.test.com/api/users');
-    });
-  });
-
-  describe('Authentication middleware compatibility', () => {
-    test('should create middleware function', () => {
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      expect(typeof middleware).toBe('function');
-    });
-
-    test('should validate tokens', async () => {
-      const result = await oxyServices.authenticateToken('invalid-token');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBeTruthy();
-    });
-  });
-});

package/src/__tests__/ui/hooks/useOxyFollow.test.tsx

@@ -1,92 +0,0 @@
-import { renderHook } from '@testing-library/react-native';
-import { Provider } from 'react-redux';
-import { configureStore } from '@reduxjs/toolkit';
-import { useOxyFollow } from '../../../ui/hooks/useOxyFollow';
-import { setupOxyStore } from '../../../ui/store/setupOxyStore';
-import { OxyContextProvider } from '../../../ui/context/OxyContext';
-import React from 'react';
-
-// Mock OxyServices
-const mockOxyServices = {
-  getFollowStatus: jest.fn(),
-  followUser: jest.fn(),
-  unfollowUser: jest.fn(),
-};
-
-const createTestStore = () => {
-  return configureStore({
-    reducer: {
-      ...setupOxyStore(),
-    },
-  });
-};
-
-const createWrapper = (store: ReturnType<typeof createTestStore>) => {
-  return ({ children }: { children: React.ReactNode }) => (
-    <Provider store={store}>
-      <OxyContextProvider oxyServices={mockOxyServices}>
-        {children}
-      </OxyContextProvider>
-    </Provider>
-  );
-};
-
-describe('useOxyFollow', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  test('should work with external store containing Oxy reducers', () => {
-    const store = createTestStore();
-    const wrapper = createWrapper(store);
-
-    const { result } = renderHook(() => useOxyFollow('user1'), { wrapper });
-
-    expect(result.current).toHaveProperty('isFollowing');
-    expect(result.current).toHaveProperty('isLoading');
-    expect(result.current).toHaveProperty('error');
-    expect(result.current).toHaveProperty('toggleFollow');
-    expect(result.current).toHaveProperty('setFollowStatus');
-    expect(result.current).toHaveProperty('fetchStatus');
-    expect(result.current).toHaveProperty('clearError');
-  });
-
-  test('should support multiple users mode', () => {
-    const store = createTestStore();
-    const wrapper = createWrapper(store);
-
-    const { result } = renderHook(() => useOxyFollow(['user1', 'user2']), { wrapper });
-
-    expect(result.current).toHaveProperty('followData');
-    expect(result.current).toHaveProperty('toggleFollowForUser');
-    expect(result.current).toHaveProperty('setFollowStatusForUser');
-    expect(result.current).toHaveProperty('fetchStatusForUser');
-    expect(result.current).toHaveProperty('fetchAllStatuses');
-    expect(result.current).toHaveProperty('clearErrorForUser');
-    expect(result.current).toHaveProperty('isAnyLoading');
-    expect(result.current).toHaveProperty('hasAnyError');
-    expect(result.current).toHaveProperty('allFollowing');
-    expect(result.current).toHaveProperty('allNotFollowing');
-  });
-
-  test('should integrate with custom app reducers', () => {
-    const store = configureStore({
-      reducer: {
-        ...setupOxyStore(),
-        customApp: (state = { feature: 'enabled' }) => state,
-      },
-    });
-
-    const wrapper = createWrapper(store);
-
-    const { result } = renderHook(() => useOxyFollow('user1'), { wrapper });
-
-    // Should still work with Oxy features
-    expect(result.current.isFollowing).toBe(false);
-    expect(result.current.isLoading).toBe(false);
-
-    // Custom app state should also be accessible in the store
-    const state = store.getState();
-    expect(state.customApp.feature).toBe('enabled');
-  });
-});

package/src/__tests__/ui/screens/AccountSettingsScreen.test.tsx

@@ -1,112 +0,0 @@
-import React from 'react';
-import { render, fireEvent, waitFor } from '@testing-library/react-native';
-import AccountSettingsScreen from '../../../ui/screens/AccountSettingsScreen';
-import { OxyContextProvider } from '../../../ui/context/OxyContext';
-import { OxyServices } from '../../../core';
-
-// Mock the OxyContext
-jest.mock('../../../ui/context/OxyContext', () => ({
-  useOxy: jest.fn(() => ({
-    user: {
-      id: '123',
-      username: 'testuser',
-      email: 'test@example.com',
-      bio: 'Test bio',
-      avatar: { url: 'https://example.com/avatar.jpg' }
-    },
-    oxyServices: {
-      updateProfile: jest.fn(() => Promise.resolve({
-        id: '123',
-        username: 'testuser',
-        email: 'test@example.com'
-      }))
-    },
-    isLoading: false
-  })),
-  OxyContextProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>
-}));
-
-// Mock the Avatar component
-jest.mock('../../../ui/components/Avatar', () => 'Avatar');
-
-describe('AccountSettingsScreen', () => {
-  const mockOxyServices = {
-    updateProfile: jest.fn(() => Promise.resolve({
-      id: '123',
-      username: 'testuser',
-      email: 'test@example.com'
-    }))
-  } as unknown as OxyServices;
-
-  const defaultProps = {
-    goBack: jest.fn(),
-    theme: 'light' as const,
-    navigate: jest.fn(),
-    oxyServices: mockOxyServices,
-  };
-
-  it('renders correctly with default props', () => {
-    const { getByText, getByTestId } = render(
-      <AccountSettingsScreen {...defaultProps} />
-    );
-    
-    // Check if the screen title is rendered
-    expect(getByText('Account Settings')).toBeTruthy();
-    
-    // Check if profile form is rendered by default
-    expect(getByTestId('username-input')).toBeTruthy();
-    expect(getByTestId('email-input')).toBeTruthy();
-    expect(getByTestId('bio-input')).toBeTruthy();
-  });
-
-  it('switches between tabs correctly', async () => {
-    const { getByText, queryByTestId } = render(
-      <AccountSettingsScreen {...defaultProps} />
-    );
-    
-    // Initially on profile tab
-    expect(queryByTestId('username-input')).toBeTruthy();
-    
-    // Switch to password tab
-    fireEvent.press(getByText('Password'));
-    expect(queryByTestId('current-password-input')).toBeTruthy();
-    expect(queryByTestId('username-input')).toBeFalsy();
-    
-    // Switch to notifications tab
-    fireEvent.press(getByText('Notifications'));
-    expect(queryByTestId('email-notifications-switch')).toBeTruthy();
-    expect(queryByTestId('current-password-input')).toBeFalsy();
-    
-    // Switch back to profile tab
-    fireEvent.press(getByText('Profile'));
-    expect(queryByTestId('username-input')).toBeTruthy();
-    expect(queryByTestId('email-notifications-switch')).toBeFalsy();
-  });
-
-  it('validates profile form inputs', async () => {
-    const { getByText, getByTestId } = render(
-      <AccountSettingsScreen {...defaultProps} />
-    );
-    
-    // Clear username (which is required)
-    fireEvent.changeText(getByTestId('username-input'), '');
-    
-    // Try to save with empty username
-    fireEvent.press(getByTestId('save-profile-button'));
-    
-    // Should display error message
-    await waitFor(() => {
-      expect(getByText('Username is required')).toBeTruthy();
-    });
-  });
-
-  it('opens with the specified activeTab', () => {
-    const { queryByTestId } = render(
-      <AccountSettingsScreen {...defaultProps} activeTab="password" />
-    );
-    
-    // Should be on password tab
-    expect(queryByTestId('current-password-input')).toBeTruthy();
-    expect(queryByTestId('username-input')).toBeFalsy();
-  });
-});

package/src/__tests__/ui/store/setupOxyStore.test.ts

@@ -1,50 +0,0 @@
-import { configureStore } from '@reduxjs/toolkit';
-import { setupOxyStore, oxyReducers } from '../../../ui/store/setupOxyStore';
-import { authSlice, followSlice } from '../../../ui/store/slices';
-
-describe('setupOxyStore', () => {
-  test('should return all Oxy reducers', () => {
-    const reducers = setupOxyStore();
-    
-    expect(reducers).toHaveProperty('auth');
-    expect(reducers).toHaveProperty('follow');
-    expect(reducers.auth).toBe(authSlice.reducer);
-    expect(reducers.follow).toBe(followSlice.reducer);
-  });
-
-  test('should work with configureStore', () => {
-    const store = configureStore({
-      reducer: {
-        ...setupOxyStore(),
-        customReducer: (state = { test: true }) => state,
-      },
-    });
-
-    const state = store.getState();
-    expect(state).toHaveProperty('auth');
-    expect(state).toHaveProperty('follow');
-    expect(state).toHaveProperty('customReducer');
-    expect(state.customReducer.test).toBe(true);
-  });
-
-  test('should support tree-shaking with pick method', () => {
-    const authOnly = setupOxyStore.pick('auth');
-    expect(authOnly).toHaveProperty('auth');
-    expect(authOnly).not.toHaveProperty('follow');
-
-    const followOnly = setupOxyStore.pick('follow');
-    expect(followOnly).toHaveProperty('follow');
-    expect(followOnly).not.toHaveProperty('auth');
-
-    const both = setupOxyStore.pick('auth', 'follow');
-    expect(both).toHaveProperty('auth');
-    expect(both).toHaveProperty('follow');
-  });
-
-  test('should export individual reducers', () => {
-    expect(oxyReducers).toHaveProperty('auth');
-    expect(oxyReducers).toHaveProperty('follow');
-    expect(oxyReducers.auth).toBe(authSlice.reducer);
-    expect(oxyReducers.follow).toBe(followSlice.reducer);
-  });
-});