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

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

@@ -0,0 +1,152 @@
+/**
+ * Tests for validation utilities
+ */
+
+import {
+  validateNetworkConfigs,
+  validateTokenConfigs,
+  validateBalanceRefreshInterval,
+  validateRequiredMethods,
+  validateAccountIndex,
+  validateNetworkName,
+  validateTokenAddress,
+  validateBalance,
+} from '../../utils/validation'
+import type { NetworkConfigs, TokenConfigs } from '../../types'
+
+describe('validation', () => {
+  describe('validateNetworkConfigs', () => {
+    it('should not throw for valid network configs', () => {
+      const validConfigs: NetworkConfigs = {
+        ethereum: {
+          chainId: 1,
+          blockchain: 'ethereum',
+        },
+      }
+      expect(() => validateNetworkConfigs(validConfigs)).not.toThrow()
+    })
+
+    it('should throw for invalid network configs', () => {
+      expect(() => validateNetworkConfigs({} as NetworkConfigs)).toThrow()
+      expect(() => validateNetworkConfigs(null as unknown as NetworkConfigs)).toThrow()
+      expect(() => validateNetworkConfigs([] as unknown as NetworkConfigs)).toThrow()
+    })
+  })
+
+  describe('validateTokenConfigs', () => {
+    it('should not throw for valid token configs', () => {
+      const validConfigs: TokenConfigs = {
+        ethereum: {
+          native: {
+            symbol: 'ETH',
+            name: 'Ethereum',
+            decimals: 18,
+            address: null,
+          },
+          tokens: [],
+        },
+      }
+      expect(() => validateTokenConfigs(validConfigs)).not.toThrow()
+    })
+
+    it('should throw for invalid token configs', () => {
+      expect(() => validateTokenConfigs({} as TokenConfigs)).toThrow()
+      expect(() => validateTokenConfigs(null as unknown as TokenConfigs)).toThrow()
+      expect(() => validateTokenConfigs([] as unknown as TokenConfigs)).toThrow()
+    })
+  })
+
+  describe('validateBalanceRefreshInterval', () => {
+    it('should not throw for valid intervals', () => {
+      expect(() => validateBalanceRefreshInterval(0)).not.toThrow()
+      expect(() => validateBalanceRefreshInterval(1000)).not.toThrow()
+      expect(() => validateBalanceRefreshInterval(undefined)).not.toThrow()
+    })
+
+    it('should throw for invalid intervals', () => {
+      expect(() => validateBalanceRefreshInterval(-1)).toThrow()
+      expect(() => validateBalanceRefreshInterval(NaN)).toThrow()
+      expect(() => validateBalanceRefreshInterval(Infinity)).toThrow()
+      expect(() => validateBalanceRefreshInterval('1000' as unknown as number)).toThrow()
+    })
+  })
+
+  describe('validateRequiredMethods', () => {
+    it('should not throw for object with required methods', () => {
+      const obj = {
+        method1: jest.fn(),
+        method2: jest.fn(),
+      }
+      expect(() => validateRequiredMethods(obj, ['method1', 'method2'], 'TestObject')).not.toThrow()
+    })
+
+    it('should throw for object without required methods', () => {
+      const obj = {
+        method1: jest.fn(),
+      }
+      expect(() => validateRequiredMethods(obj, ['method1', 'method2'], 'TestObject')).toThrow()
+      expect(() => validateRequiredMethods(null, ['method1'], 'TestObject')).toThrow()
+      expect(() => validateRequiredMethods('string', ['method1'], 'TestObject')).toThrow()
+    })
+  })
+
+  describe('validateAccountIndex', () => {
+    it('should not throw for valid account indices', () => {
+      expect(() => validateAccountIndex(0)).not.toThrow()
+      expect(() => validateAccountIndex(1)).not.toThrow()
+      expect(() => validateAccountIndex(100)).not.toThrow()
+    })
+
+    it('should throw for invalid account indices', () => {
+      expect(() => validateAccountIndex(-1)).toThrow()
+      expect(() => validateAccountIndex(1.5)).toThrow()
+      expect(() => validateAccountIndex(NaN)).toThrow()
+    })
+  })
+
+  describe('validateNetworkName', () => {
+    it('should not throw for valid network names', () => {
+      expect(() => validateNetworkName('ethereum')).not.toThrow()
+      expect(() => validateNetworkName('polygon-mainnet')).not.toThrow()
+      expect(() => validateNetworkName('network_1')).not.toThrow()
+    })
+
+    it('should throw for invalid network names', () => {
+      expect(() => validateNetworkName('')).toThrow()
+      expect(() => validateNetworkName('  ')).toThrow()
+      expect(() => validateNetworkName('network with spaces')).toThrow()
+      expect(() => validateNetworkName('network@invalid')).toThrow()
+    })
+  })
+
+  describe('validateTokenAddress', () => {
+    it('should not throw for valid token addresses', () => {
+      expect(() => validateTokenAddress(null)).not.toThrow()
+      expect(() => validateTokenAddress('0x1234567890123456789012345678901234567890')).not.toThrow()
+      expect(() => validateTokenAddress('0xABCDEFabcdef1234567890123456789012345678')).not.toThrow()
+    })
+
+    it('should throw for invalid token addresses', () => {
+      expect(() => validateTokenAddress('invalid')).toThrow()
+      expect(() => validateTokenAddress('0x123')).toThrow()
+      expect(() => validateTokenAddress('0x123456789012345678901234567890123456789')).toThrow()
+      expect(() => validateTokenAddress('')).toThrow()
+    })
+  })
+
+  describe('validateBalance', () => {
+    it('should not throw for valid balances', () => {
+      expect(() => validateBalance('0')).not.toThrow()
+      expect(() => validateBalance('100')).not.toThrow()
+      expect(() => validateBalance('100.5')).not.toThrow()
+      expect(() => validateBalance('-100')).not.toThrow()
+    })
+
+    it('should throw for invalid balances', () => {
+      expect(() => validateBalance('')).toThrow()
+      expect(() => validateBalance('abc')).toThrow()
+      expect(() => validateBalance('100.5.5')).toThrow()
+      expect(() => validateBalance('100a')).toThrow()
+    })
+  })
+})

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

@@ -0,0 +1,195 @@
+/**
+ * Tests for wallet utility functions
+ */
+
+import {
+  getWalletAddresses,
+  createBaseWalletStore,
+} from '../../utils/walletUtils'
+import { getWorkletStore } from '../../store/workletStore'
+import { getWalletStore } from '../../store/walletStore'
+import { AccountService } from '../../services/accountService'
+
+// Mock stores and services
+jest.mock('../../store/workletStore', () => ({
+  getWorkletStore: jest.fn(),
+}))
+
+jest.mock('../../store/walletStore', () => ({
+  getWalletStore: jest.fn(),
+}))
+
+jest.mock('../../services/accountService', () => ({
+  AccountService: {
+    callAccountMethod: jest.fn(),
+  },
+}))
+
+describe('walletUtils', () => {
+  let mockWalletStore: any
+  let mockWorkletStore: any
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    mockWalletStore = {
+      getState: jest.fn(() => ({
+        addresses: {},
+        activeWalletId: 'test-wallet-1',
+      })),
+    }
+
+    mockWorkletStore = {
+      getState: jest.fn(() => ({
+        isInitialized: true,
+      })),
+    }
+
+    ;(getWalletStore as jest.Mock).mockReturnValue(mockWalletStore)
+    ;(getWorkletStore as jest.Mock).mockReturnValue(mockWorkletStore)
+  })
+
+  describe('getWalletAddresses', () => {
+    it('should return empty object when no addresses exist', () => {
+      const result = getWalletAddresses(mockWalletStore, 0)
+      expect(result).toEqual({})
+    })
+
+    it('should return addresses for specific account index', () => {
+      mockWalletStore.getState = jest.fn(() => ({
+        addresses: {
+          'test-wallet-1': {
+            ethereum: {
+              0: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+            },
+            polygon: {
+              0: '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+            },
+          },
+        },
+        activeWalletId: 'test-wallet-1',
+      }))
+
+      const result = getWalletAddresses(mockWalletStore, 0)
+      expect(result).toEqual({
+        ethereum: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+        polygon: '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+      })
+    })
+
+    it('should only return addresses for specified account index', () => {
+      mockWalletStore.getState = jest.fn(() => ({
+        addresses: {
+          'test-wallet-1': {
+            ethereum: {
+              0: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+              1: '0x942d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+            },
+          },
+        },
+        activeWalletId: 'test-wallet-1',
+      }))
+
+      const result = getWalletAddresses(mockWalletStore, 0)
+      expect(result).toEqual({
+        ethereum: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+      })
+      expect(result.ethereum).not.toBe('0x942d35Cc6634C0532925a3b844Bc9e7595f0bEb0')
+    })
+
+    it('should handle missing account index gracefully', () => {
+      mockWalletStore.getState = jest.fn(() => ({
+        addresses: {
+          'test-wallet-1': {
+            ethereum: {
+              0: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+            },
+          },
+        },
+        activeWalletId: 'test-wallet-1',
+      }))
+
+      const result = getWalletAddresses(mockWalletStore, 1)
+      expect(result).toEqual({})
+    })
+
+    it('should handle undefined network addresses', () => {
+      mockWalletStore.getState = jest.fn(() => ({
+        addresses: {
+          'test-wallet-1': {
+            ethereum: undefined,
+            polygon: {
+              0: '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+            },
+          },
+        },
+        activeWalletId: 'test-wallet-1',
+      }))
+
+      const result = getWalletAddresses(mockWalletStore, 0)
+      expect(result).toEqual({
+        polygon: '0x842d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+      })
+    })
+  })
+
+  describe('createBaseWalletStore', () => {
+    it('should create wallet store with callAccountMethod', async () => {
+      const mockResult = { balance: '100' }
+      ;(AccountService.callAccountMethod as jest.Mock).mockResolvedValue(
+        mockResult
+      )
+
+      const store = createBaseWalletStore()
+      const result = await store.callAccountMethod('ethereum', 0, 'getBalance')
+
+      expect(result).toBe(mockResult)
+      expect(AccountService.callAccountMethod).toHaveBeenCalledWith(
+        'ethereum',
+        0,
+        'getBalance',
+        undefined
+      )
+    })
+
+    it('should create wallet store with isWalletInitialized', () => {
+      const store = createBaseWalletStore()
+      const isInitialized = store.isWalletInitialized()
+
+      expect(isInitialized).toBe(true)
+      expect(getWorkletStore).toHaveBeenCalled()
+    })
+
+    it('should create wallet store with getWalletAddresses', () => {
+      mockWalletStore.getState = jest.fn(() => ({
+        addresses: {
+          'test-wallet-1': {
+            ethereum: {
+              0: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+            },
+          },
+        },
+        activeWalletId: 'test-wallet-1',
+      }))
+
+      const store = createBaseWalletStore()
+      const addresses = store.getWalletAddresses(0)
+
+      expect(addresses).toEqual({
+        ethereum: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+      })
+    })
+
+    it('should return false for isWalletInitialized when not initialized', () => {
+      mockWorkletStore.getState = jest.fn(() => ({
+        isInitialized: false,
+      }))
+
+      const store = createBaseWalletStore()
+      const isInitialized = store.isWalletInitialized()
+
+      expect(isInitialized).toBe(false)
+    })
+  })
+})
+