@spacesops/wdk-react-native-core 1.0.0-beta.40

package/src/__tests__/utils/errorHandling.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Tests for errorHandling utilities
+ * 
+ * Tests service error handling patterns
+ */
+
+import { handleServiceError } from '../../utils/errorHandling'
+import { normalizeError } from '../../utils/errorUtils'
+import { logError } from '../../utils/logger'
+
+// Mock dependencies
+jest.mock('../../utils/errorUtils', () => ({
+  normalizeError: jest.fn(),
+}))
+
+jest.mock('../../utils/logger', () => ({
+  logError: jest.fn(),
+}))
+
+describe('errorHandling', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('handleServiceError', () => {
+    it('should normalize and log error', () => {
+      const error = new Error('Test error')
+      const normalizedError = new Error('Normalized error')
+      ;(normalizeError as jest.Mock).mockReturnValue(normalizedError)
+
+      expect(() => {
+        handleServiceError(error, 'TestService', 'testOperation')
+      }).toThrow('Normalized error')
+
+      expect(normalizeError).toHaveBeenCalledWith(error, false, {
+        component: 'TestService',
+        operation: 'testOperation',
+      })
+      expect(logError).toHaveBeenCalledWith('[TestService] testOperation failed:', normalizedError)
+    })
+
+    it('should include context in error normalization', () => {
+      const error = new Error('Test error')
+      const normalizedError = new Error('Normalized error')
+      ;(normalizeError as jest.Mock).mockReturnValue(normalizedError)
+
+      const context = { network: 'ethereum', accountIndex: 0 }
+
+      expect(() => {
+        handleServiceError(error, 'TestService', 'testOperation', context)
+      }).toThrow('Normalized error')
+
+      expect(normalizeError).toHaveBeenCalledWith(error, false, {
+        component: 'TestService',
+        operation: 'testOperation',
+        ...context,
+      })
+    })
+
+    it('should not sanitize errors (sanitizeLevel: false)', () => {
+      const error = new Error('Test error')
+      const normalizedError = new Error('Normalized error')
+      ;(normalizeError as jest.Mock).mockReturnValue(normalizedError)
+
+      expect(() => {
+        handleServiceError(error, 'TestService', 'testOperation')
+      }).toThrow()
+
+      expect(normalizeError).toHaveBeenCalledWith(error, false, expect.any(Object))
+    })
+
+    it('should handle non-Error objects', () => {
+      const error = 'String error'
+      const normalizedError = new Error('Normalized error')
+      ;(normalizeError as jest.Mock).mockReturnValue(normalizedError)
+
+      expect(() => {
+        handleServiceError(error, 'TestService', 'testOperation')
+      }).toThrow('Normalized error')
+
+      expect(normalizeError).toHaveBeenCalledWith(error, false, {
+        component: 'TestService',
+        operation: 'testOperation',
+      })
+    })
+
+    it('should handle null/undefined errors', () => {
+      const normalizedError = new Error('Normalized error')
+      ;(normalizeError as jest.Mock).mockReturnValue(normalizedError)
+
+      expect(() => {
+        handleServiceError(null, 'TestService', 'testOperation')
+      }).toThrow('Normalized error')
+
+      expect(normalizeError).toHaveBeenCalledWith(null, false, {
+        component: 'TestService',
+        operation: 'testOperation',
+      })
+    })
+
+    it('should always throw normalized error', () => {
+      const error = new Error('Test error')
+      const normalizedError = new Error('Normalized error')
+      ;(normalizeError as jest.Mock).mockReturnValue(normalizedError)
+
+      expect(() => {
+        handleServiceError(error, 'TestService', 'testOperation')
+      }).toThrow(normalizedError)
+
+      // Verify it throws (never returns)
+      try {
+        handleServiceError(error, 'TestService', 'testOperation')
+        fail('Should have thrown')
+      } catch (e) {
+        expect(e).toBe(normalizedError)
+      }
+    })
+
+    it('should log error with correct format', () => {
+      const error = new Error('Test error')
+      const normalizedError = new Error('Normalized error')
+      ;(normalizeError as jest.Mock).mockReturnValue(normalizedError)
+
+      expect(() => {
+        handleServiceError(error, 'MyService', 'myOperation')
+      }).toThrow()
+
+      expect(logError).toHaveBeenCalledWith('[MyService] myOperation failed:', normalizedError)
+    })
+
+    it('should handle complex error objects', () => {
+      const error = { code: 'ERR_CODE', message: 'Error message', details: { foo: 'bar' } }
+      const normalizedError = new Error('Normalized error')
+      ;(normalizeError as jest.Mock).mockReturnValue(normalizedError)
+
+      expect(() => {
+        handleServiceError(error, 'TestService', 'testOperation')
+      }).toThrow('Normalized error')
+
+      expect(normalizeError).toHaveBeenCalledWith(error, false, {
+        component: 'TestService',
+        operation: 'testOperation',
+      })
+    })
+  })
+})
+

package/src/__tests__/utils/errorUtils.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Tests for error utility functions
+ */
+
+import {
+  normalizeError,
+  getErrorMessage,
+  isErrorType,
+  createContextualError,
+  sanitizeErrorMessage,
+  SanitizationLevel,
+} from '../../utils/errorUtils'
+
+describe('errorUtils', () => {
+  describe('normalizeError', () => {
+    it('should normalize Error instances', () => {
+      const error = new Error('Test error')
+      const normalized = normalizeError(error, false)
+      expect(normalized).toBeInstanceOf(Error)
+      expect(normalized.message).toBe('Test error')
+    })
+
+    it('should normalize string errors', () => {
+      const normalized = normalizeError('String error', false)
+      expect(normalized).toBeInstanceOf(Error)
+      expect(normalized.message).toBe('String error')
+    })
+
+    it('should normalize object with message property', () => {
+      const error = { message: 'Object error' }
+      const normalized = normalizeError(error, false)
+      expect(normalized).toBeInstanceOf(Error)
+      expect(normalized.message).toBe('Object error')
+    })
+
+    it('should normalize other values', () => {
+      const normalized = normalizeError(123, false)
+      expect(normalized).toBeInstanceOf(Error)
+      expect(normalized.message).toBe('123')
+    })
+
+    it('should preserve error name and stack', () => {
+      const error = new TypeError('Type error')
+      error.stack = 'stack trace'
+      const normalized = normalizeError(error, false)
+      expect(normalized.name).toBe('TypeError')
+      expect(normalized.stack).toBe('stack trace')
+    })
+
+    it('should sanitize error messages in production', () => {
+      const originalEnv = process.env.NODE_ENV
+      process.env.NODE_ENV = 'production'
+      
+      const error = new Error('Error with 0x1234567890123456789012345678901234567890')
+      const normalized = normalizeError(error, true)
+      expect(normalized.message).not.toContain('0x1234567890123456789012345678901234567890')
+      
+      process.env.NODE_ENV = originalEnv
+    })
+
+    it('should use SanitizationLevel enum', () => {
+      const error = new Error('Error with 0x1234567890123456789012345678901234567890')
+      
+      const none = normalizeError(error, SanitizationLevel.NONE)
+      expect(none.message).toContain('0x1234567890123456789012345678901234567890')
+      
+      const dev = normalizeError(error, SanitizationLevel.DEVELOPMENT)
+      expect(dev.message).toContain('0x1234')
+      
+      const prod = normalizeError(error, SanitizationLevel.PRODUCTION)
+      expect(prod.message).not.toContain('0x1234567890123456789012345678901234567890')
+    })
+
+    it('should handle boolean sanitize parameter for backward compatibility', () => {
+      const error = new Error('Error with 0x1234567890123456789012345678901234567890')
+      
+      const sanitized = normalizeError(error, true)
+      expect(sanitized.message).not.toContain('0x1234567890123456789012345678901234567890')
+      
+      const notSanitized = normalizeError(error, false)
+      expect(notSanitized.message).toContain('0x1234567890123456789012345678901234567890')
+    })
+
+    it('should sanitize stack traces based on level', () => {
+      const error = new Error('Test error')
+      error.stack = 'Error: Test error\n    at file:///path/to/sensitive/key.js:1:1'
+      
+      const prod = normalizeError(error, SanitizationLevel.PRODUCTION)
+      expect(prod.stack).not.toContain('/path/to/sensitive/key.js')
+      
+      const none = normalizeError(error, SanitizationLevel.NONE)
+      expect(none.stack).toContain('/path/to/sensitive/key.js')
+    })
+  })
+
+  describe('getErrorMessage', () => {
+    it('should extract message from Error', () => {
+      const error = new Error('Test error')
+      expect(getErrorMessage(error)).toBe('Test error')
+    })
+
+    it('should extract message from string', () => {
+      expect(getErrorMessage('String error')).toBe('String error')
+    })
+
+    it('should extract message from object', () => {
+      expect(getErrorMessage({ message: 'Object error' })).toBe('Object error')
+    })
+  })
+
+  describe('isErrorType', () => {
+    it('should return true for matching error type', () => {
+      const error = new TypeError('Type error')
+      expect(isErrorType(error, 'TypeError')).toBe(true)
+    })
+
+    it('should return false for non-matching error type', () => {
+      const error = new TypeError('Type error')
+      expect(isErrorType(error, 'ReferenceError')).toBe(false)
+    })
+
+    it('should return false for non-Error values', () => {
+      expect(isErrorType('string', 'Error')).toBe(false)
+      expect(isErrorType(null, 'Error')).toBe(false)
+    })
+  })
+
+  describe('createContextualError', () => {
+    it('should create error with message', () => {
+      const error = createContextualError('Test error')
+      expect(error).toBeInstanceOf(Error)
+      expect(error.message).toBe('Test error')
+    })
+
+    it('should create error with context', () => {
+      const context = { operation: 'test', component: 'TestComponent' }
+      const error = createContextualError('Test error', context)
+      expect(error).toBeInstanceOf(Error)
+      expect((error as Error & { context: typeof context }).context).toEqual(context)
+    })
+  })
+
+  describe('sanitizeErrorMessage', () => {
+    it('should sanitize sensitive patterns in production', () => {
+      const message = 'Error with encryptionKey: 0x1234567890123456789012345678901234567890'
+      const sanitized = sanitizeErrorMessage(message, false)
+      expect(sanitized).not.toContain('0x1234567890123456789012345678901234567890')
+      expect(sanitized).toContain('[encryption data]')
+    })
+
+    it('should preserve more info in development', () => {
+      const message = 'Error with 0x1234567890123456789012345678901234567890'
+      const sanitized = sanitizeErrorMessage(message, true)
+      expect(sanitized).toContain('0x1234')
+      expect(sanitized).toContain('7890')
+    })
+
+    it('should not sanitize safe patterns', () => {
+      const message = 'Error with publicKey: 0x1234567890123456789012345678901234567890'
+      const sanitized = sanitizeErrorMessage(message, false)
+      expect(sanitized).toContain('publicKey')
+    })
+
+    it('should handle mnemonic phrases', () => {
+      const message = 'Error with mnemonic: word1 word2 word3 word4 word5 word6 word7 word8 word9 word10 word11 word12'
+      const sanitized = sanitizeErrorMessage(message, false)
+      expect(sanitized).toContain('[mnemonic phrase]')
+    })
+  })
+})

package/src/__tests__/utils/initializationState.test.ts

@@ -0,0 +1,337 @@
+/**
+ * Tests for initializationState utilities
+ * 
+ * Tests worklet initialization state machine helpers
+ */
+
+import {
+  InitializationStatus,
+  AppStatus,
+  isErrorStatus,
+  isReadyStatus,
+  isInProgressStatus,
+  isAppInProgressStatus,
+  isAppReadyStatus,
+  hasWorkletStarted,
+  canLoadWallet,
+  hasWorkletStartedApp,
+  canLoadWalletApp,
+  getStatusMessage,
+  getAppStatusMessage,
+  getWorkletStatus,
+  getCombinedStatus,
+} from '../../utils/initializationState'
+
+describe('initializationState', () => {
+  describe('isErrorStatus', () => {
+    it('should return true for ERROR status', () => {
+      expect(isErrorStatus(InitializationStatus.ERROR)).toBe(true)
+    })
+
+    it('should return false for non-error statuses', () => {
+      expect(isErrorStatus(InitializationStatus.IDLE)).toBe(false)
+      expect(isErrorStatus(InitializationStatus.STARTING_WORKLET)).toBe(false)
+      expect(isErrorStatus(InitializationStatus.WORKLET_READY)).toBe(false)
+    })
+  })
+
+  describe('isReadyStatus', () => {
+    it('should return true for WORKLET_READY status', () => {
+      expect(isReadyStatus(InitializationStatus.WORKLET_READY)).toBe(true)
+    })
+
+    it('should return false for non-ready statuses', () => {
+      expect(isReadyStatus(InitializationStatus.IDLE)).toBe(false)
+      expect(isReadyStatus(InitializationStatus.STARTING_WORKLET)).toBe(false)
+      expect(isReadyStatus(InitializationStatus.ERROR)).toBe(false)
+    })
+  })
+
+  describe('isInProgressStatus', () => {
+    it('should return true for STARTING_WORKLET status', () => {
+      expect(isInProgressStatus(InitializationStatus.STARTING_WORKLET)).toBe(true)
+    })
+
+    it('should return false for non-in-progress statuses', () => {
+      expect(isInProgressStatus(InitializationStatus.IDLE)).toBe(false)
+      expect(isInProgressStatus(InitializationStatus.WORKLET_READY)).toBe(false)
+      expect(isInProgressStatus(InitializationStatus.ERROR)).toBe(false)
+    })
+  })
+
+  describe('isAppInProgressStatus', () => {
+    it('should return true for in-progress app statuses', () => {
+      expect(isAppInProgressStatus(AppStatus.STARTING_WORKLET)).toBe(true)
+      expect(isAppInProgressStatus(AppStatus.LOADING_WALLET)).toBe(true)
+    })
+
+    it('should return false for non-in-progress app statuses', () => {
+      expect(isAppInProgressStatus(AppStatus.IDLE)).toBe(false)
+      expect(isAppInProgressStatus(AppStatus.WORKLET_READY)).toBe(false)
+      expect(isAppInProgressStatus(AppStatus.READY)).toBe(false)
+      expect(isAppInProgressStatus(AppStatus.ERROR)).toBe(false)
+    })
+  })
+
+  describe('isAppReadyStatus', () => {
+    it('should return true for READY app status', () => {
+      expect(isAppReadyStatus(AppStatus.READY)).toBe(true)
+    })
+
+    it('should return false for non-ready app statuses', () => {
+      expect(isAppReadyStatus(AppStatus.IDLE)).toBe(false)
+      expect(isAppReadyStatus(AppStatus.STARTING_WORKLET)).toBe(false)
+      expect(isAppReadyStatus(AppStatus.WORKLET_READY)).toBe(false)
+      expect(isAppReadyStatus(AppStatus.LOADING_WALLET)).toBe(false)
+      expect(isAppReadyStatus(AppStatus.ERROR)).toBe(false)
+    })
+  })
+
+  describe('hasWorkletStarted', () => {
+    it('should return true for WORKLET_READY status', () => {
+      expect(hasWorkletStarted(InitializationStatus.WORKLET_READY)).toBe(true)
+    })
+
+    it('should return true for ERROR status', () => {
+      expect(hasWorkletStarted(InitializationStatus.ERROR)).toBe(true)
+    })
+
+    it('should return false for IDLE and STARTING_WORKLET statuses', () => {
+      expect(hasWorkletStarted(InitializationStatus.IDLE)).toBe(false)
+      expect(hasWorkletStarted(InitializationStatus.STARTING_WORKLET)).toBe(false)
+    })
+  })
+
+  describe('canLoadWallet', () => {
+    it('should return true for WORKLET_READY status', () => {
+      expect(canLoadWallet(InitializationStatus.WORKLET_READY)).toBe(true)
+    })
+
+    it('should return false for other statuses', () => {
+      expect(canLoadWallet(InitializationStatus.IDLE)).toBe(false)
+      expect(canLoadWallet(InitializationStatus.STARTING_WORKLET)).toBe(false)
+      expect(canLoadWallet(InitializationStatus.ERROR)).toBe(false)
+    })
+  })
+
+  describe('hasWorkletStartedApp', () => {
+    it('should return true for app statuses where worklet has started', () => {
+      expect(hasWorkletStartedApp(AppStatus.WORKLET_READY)).toBe(true)
+      expect(hasWorkletStartedApp(AppStatus.LOADING_WALLET)).toBe(true)
+      expect(hasWorkletStartedApp(AppStatus.READY)).toBe(true)
+      expect(hasWorkletStartedApp(AppStatus.ERROR)).toBe(true)
+    })
+
+    it('should return false for IDLE and STARTING_WORKLET app statuses', () => {
+      expect(hasWorkletStartedApp(AppStatus.IDLE)).toBe(false)
+      expect(hasWorkletStartedApp(AppStatus.STARTING_WORKLET)).toBe(false)
+    })
+  })
+
+  describe('canLoadWalletApp', () => {
+    it('should return true for app statuses where wallet can be loaded', () => {
+      expect(canLoadWalletApp(AppStatus.WORKLET_READY)).toBe(true)
+      expect(canLoadWalletApp(AppStatus.LOADING_WALLET)).toBe(true)
+      expect(canLoadWalletApp(AppStatus.READY)).toBe(true)
+    })
+
+    it('should return false for other app statuses', () => {
+      expect(canLoadWalletApp(AppStatus.IDLE)).toBe(false)
+      expect(canLoadWalletApp(AppStatus.STARTING_WORKLET)).toBe(false)
+      expect(canLoadWalletApp(AppStatus.ERROR)).toBe(false)
+    })
+  })
+
+  describe('getStatusMessage', () => {
+    it('should return correct message for IDLE', () => {
+      expect(getStatusMessage(InitializationStatus.IDLE)).toBe('Not started')
+    })
+
+    it('should return correct message for STARTING_WORKLET', () => {
+      expect(getStatusMessage(InitializationStatus.STARTING_WORKLET)).toBe('Starting worklet...')
+    })
+
+    it('should return correct message for WORKLET_READY', () => {
+      expect(getStatusMessage(InitializationStatus.WORKLET_READY)).toBe('Worklet ready - can load wallets')
+    })
+
+    it('should return correct message for ERROR', () => {
+      expect(getStatusMessage(InitializationStatus.ERROR)).toBe('Worklet error')
+    })
+  })
+
+  describe('getAppStatusMessage', () => {
+    it('should return correct message for IDLE', () => {
+      expect(getAppStatusMessage(AppStatus.IDLE)).toBe('Not started')
+    })
+
+    it('should return correct message for STARTING_WORKLET', () => {
+      expect(getAppStatusMessage(AppStatus.STARTING_WORKLET)).toBe('Starting worklet...')
+    })
+
+    it('should return correct message for WORKLET_READY', () => {
+      expect(getAppStatusMessage(AppStatus.WORKLET_READY)).toBe('Worklet ready - can load wallets')
+    })
+
+    it('should return correct message for LOADING_WALLET', () => {
+      expect(getAppStatusMessage(AppStatus.LOADING_WALLET)).toBe('Loading wallet...')
+    })
+
+    it('should return correct message for READY', () => {
+      expect(getAppStatusMessage(AppStatus.READY)).toBe('Ready')
+    })
+
+    it('should return correct message for ERROR', () => {
+      expect(getAppStatusMessage(AppStatus.ERROR)).toBe('Error')
+    })
+  })
+
+  describe('getWorkletStatus', () => {
+    it('should return ERROR when error is present', () => {
+      const status = getWorkletStatus({
+        isWorkletStarted: false,
+        isLoading: false,
+        error: 'Test error',
+      })
+
+      expect(status).toBe(InitializationStatus.ERROR)
+    })
+
+    it('should return STARTING_WORKLET when loading', () => {
+      const status = getWorkletStatus({
+        isWorkletStarted: false,
+        isLoading: true,
+        error: null,
+      })
+
+      expect(status).toBe(InitializationStatus.STARTING_WORKLET)
+    })
+
+    it('should return IDLE when not started and not loading', () => {
+      const status = getWorkletStatus({
+        isWorkletStarted: false,
+        isLoading: false,
+        error: null,
+      })
+
+      expect(status).toBe(InitializationStatus.IDLE)
+    })
+
+    it('should return WORKLET_READY when started', () => {
+      const status = getWorkletStatus({
+        isWorkletStarted: true,
+        isLoading: false,
+        error: null,
+      })
+
+      expect(status).toBe(InitializationStatus.WORKLET_READY)
+    })
+  })
+
+  describe('getCombinedStatus', () => {
+    it('should return ERROR when worklet has error', () => {
+      const status = getCombinedStatus(
+        {
+          isWorkletStarted: false,
+          isLoading: false,
+          error: 'Worklet error',
+        },
+        { type: 'not_loaded' }
+      )
+
+      expect(status).toBe(AppStatus.ERROR)
+    })
+
+    it('should return STARTING_WORKLET when worklet is loading', () => {
+      const status = getCombinedStatus(
+        {
+          isWorkletStarted: false,
+          isLoading: true,
+          error: null,
+        },
+        { type: 'not_loaded' }
+      )
+
+      expect(status).toBe(AppStatus.STARTING_WORKLET)
+    })
+
+    it('should return IDLE when worklet not started', () => {
+      const status = getCombinedStatus(
+        {
+          isWorkletStarted: false,
+          isLoading: false,
+          error: null,
+        },
+        { type: 'not_loaded' }
+      )
+
+      expect(status).toBe(AppStatus.IDLE)
+    })
+
+    it('should return WORKLET_READY when worklet ready but wallet not loaded', () => {
+      const status = getCombinedStatus(
+        {
+          isWorkletStarted: true,
+          isLoading: false,
+          error: null,
+        },
+        { type: 'not_loaded' }
+      )
+
+      expect(status).toBe(AppStatus.WORKLET_READY)
+    })
+
+    it('should return LOADING_WALLET when wallet is checking', () => {
+      const status = getCombinedStatus(
+        {
+          isWorkletStarted: true,
+          isLoading: false,
+          error: null,
+        },
+        { type: 'checking' as const }
+      )
+
+      expect(status).toBe(AppStatus.LOADING_WALLET)
+    })
+
+    it('should return LOADING_WALLET when wallet is loading', () => {
+      const status = getCombinedStatus(
+        {
+          isWorkletStarted: true,
+          isLoading: false,
+          error: null,
+        },
+        { type: 'loading' as const }
+      )
+
+      expect(status).toBe(AppStatus.LOADING_WALLET)
+    })
+
+    it('should return READY when wallet is ready', () => {
+      const status = getCombinedStatus(
+        {
+          isWorkletStarted: true,
+          isLoading: false,
+          error: null,
+        },
+        { type: 'ready' as const }
+      )
+
+      expect(status).toBe(AppStatus.READY)
+    })
+
+    it('should return ERROR when wallet has error', () => {
+      const status = getCombinedStatus(
+        {
+          isWorkletStarted: true,
+          isLoading: false,
+          error: null,
+        },
+        { type: 'error' as const }
+      )
+
+      expect(status).toBe(AppStatus.ERROR)
+    })
+  })
+})
+