diff --git a/TEST_DOCUMENTATION.md b/TEST_DOCUMENTATION.md new file mode 100644 index 00000000..537bc961 --- /dev/null +++ b/TEST_DOCUMENTATION.md @@ -0,0 +1,300 @@ +# Test Suite Documentation + +## Overview + +This project now includes a comprehensive test suite covering unit tests, API mock tests, component tests, and contract interaction tests. The test suite is configured to achieve a minimum of 70% code coverage across all critical components. + +## Test Structure + +### Configuration Files + +- **`jest.config.js`** - Main Jest configuration with coverage thresholds and test patterns +- **`jest.setup.js`** - Global test setup with DOM mocks and polyfills +- **`package.json`** - Updated with test scripts and dependencies + +### Test Files + +#### Unit Tests +- **`src/lib/__tests__/lightweightRiskModel.test.js`** - Tests for the ML risk scoring model + - Score calculation accuracy + - Tier mapping logic + - Feature importance analysis + - Edge cases and error handling + - Model consistency and determinism + +#### API Mock Tests +- **`src/lib/__tests__/horizonDataCollector.test.js`** - Tests for Horizon API data collection + - API response handling + - Pagination support + - Caching mechanisms + - Error handling and retries + - Data validation and transformation + +#### Component Tests +- **`src/components/__tests__/AutomatedRiskAnalyzer.test.jsx`** - Tests for the main React component + - User interaction flows + - State management + - Loading states + - Error boundaries + - Integration with child components + +#### Contract Interaction Tests +- **`src/lib/__tests__/riskTierClient.test.ts`** - Tests for Stellar contract interactions + - Transaction building and signing + - RPC simulation and submission + - Cache invalidation + - Validation and error handling + - React hook integration + +## Running Tests + +### Basic Commands + +```bash +# Run all tests once +npm test + +# Run tests in watch mode +npm run test:watch + +# Run tests with coverage reporting +npm run test:coverage +``` + +### Coverage Reports + +Coverage reports are generated in the following formats: +- **Console output** - Text summary with coverage percentages +- **HTML report** - Detailed interactive report in `coverage/lcov-report/index.html` + +### Coverage Thresholds + +The test suite enforces minimum coverage thresholds: +- **Branches**: 70% +- **Functions**: 70% +- **Lines**: 70% +- **Statements**: 70% + +## Test Categories + +### 1. Unit Tests (`lightweightRiskModel.test.js`) + +**Coverage Areas:** +- Risk score calculation algorithms +- Feature normalization and weighting +- Tier classification logic +- Confidence scoring +- Explanation generation +- Recommendation engine + +**Key Test Scenarios:** +- Low, medium, and high risk profiles +- Edge cases (zero values, extreme values) +- Missing or invalid data handling +- Model consistency across multiple runs +- Feature importance accuracy + +### 2. API Mock Tests (`horizonDataCollector.test.js`) + +**Coverage Areas:** +- Horizon API integration +- Data pagination handling +- Cache management +- Error recovery +- Data transformation + +**Key Test Scenarios:** +- Successful data collection +- API error handling +- Cache hit/miss scenarios +- Paginated responses +- Date range filtering +- Night/day ratio calculations + +### 3. Component Tests (`AutomatedRiskAnalyzer.test.jsx`) + +**Coverage Areas:** +- React component rendering +- User interaction flows +- State management +- Error boundaries +- Integration with contexts + +**Key Test Scenarios:** +- Initial rendering states +- Analysis workflow +- Blockchain updates +- Rate limiting +- Loading and error states +- Child component integration + +### 4. Contract Tests (`riskTierClient.test.ts`) + +**Coverage Areas:** +- Stellar SDK integration +- Transaction building +- RPC simulation +- Cache management +- Validation logic +- React hook functionality + +**Key Test Scenarios:** +- Read operations (getRiskTier, getScore, etc.) +- Write operations (setRiskTier, updateChosenTier) +- Address and score validation +- Account resolution +- Error handling and recovery +- Cache invalidation + +## Mocking Strategy + +### External Dependencies + +- **Stellar SDK** - Mocked to avoid network calls +- **Horizon API** - Mocked with realistic response patterns +- **Browser APIs** - Mocked (localStorage, fetch, etc.) +- **React Contexts** - Mocked for isolated testing + +### Cache Management + +- **getCache/setCache** - Mocked to test caching behavior +- **invalidateCache** - Mocked to verify cache invalidation +- **localStorage** - Mocked for client-side storage tests + +### UI Components + +- **Child components** - Mocked to isolate parent component logic +- **Toast notifications** - Mocked to verify user feedback +- **Loading states** - Tested through mock implementations + +## Test Data + +### Mock Wallet Addresses +```javascript +const mockWalletAddress = 'GD5TESTEXAMPLEADDRESS123456789'; +const mockContractId = 'C1234567890ABCDEF1234567890ABCDEF12345678'; +``` + +### Sample Risk Metrics +```javascript +const mockMetrics = { + totalVolume: 5000, + uniqueCounterparties: 25, + assetDiversity: 4, + nightDayRatio: 0.3, +}; +``` + +### Mock API Responses +- Payment operations with various asset types +- Transaction records with metadata +- Paginated response structures +- Error response patterns + +## Best Practices + +### Test Organization +- Group related tests in `describe` blocks +- Use descriptive test names +- Follow AAA pattern (Arrange, Act, Assert) +- Test both happy paths and error cases + +### Mock Management +- Clear mocks before each test +- Use consistent mock implementations +- Mock at the appropriate level of abstraction +- Verify mock interactions where important + +### Coverage Goals +- Focus on critical business logic +- Test error handling paths +- Cover edge cases and boundary conditions +- Maintain high coverage thresholds + +### Performance Considerations +- Use async/await for asynchronous tests +- Avoid unnecessary delays in tests +- Mock expensive operations +- Keep test execution time reasonable + +## Continuous Integration + +### GitHub Actions (Recommended) +```yaml +name: Tests +on: [push, pull_request] +jobs: + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: '18' + - run: npm install + - run: npm test + - run: npm run test:coverage +``` + +### Coverage Reporting +- Upload coverage reports to services like Codecov +- Set up coverage badges in README +- Monitor coverage trends over time +- Address coverage regressions promptly + +## Troubleshooting + +### Common Issues + +1. **Mock Configuration Errors** + - Ensure mocks are properly configured + - Check mock implementation matches real API + - Verify mock return values are expected types + +2. **Async Test Timeouts** + - Use proper async/await syntax + - Increase timeout if needed for slow operations + - Mock slow operations to speed up tests + +3. **Coverage Gaps** + - Identify uncovered code paths + - Add tests for edge cases + - Review if uncovered code is necessary + +4. **Test Isolation** + - Ensure tests don't depend on each other + - Clear state between tests + - Use fresh mocks for each test + +### Debugging Tips + +- Use `console.log` sparingly in tests +- Leverage Jest's debugging capabilities +- Check mock call history and arguments +- Verify test setup and teardown + +## Future Enhancements + +### Additional Test Types +- **Integration tests** - End-to-end workflow testing +- **Performance tests** - Load and stress testing +- **Visual regression tests** - UI consistency testing +- **Contract deployment tests** - Real blockchain testing + +### Test Utilities +- Custom matchers for common assertions +- Test data factories for consistent mock data +- Helper functions for complex test setups +- Shared test configurations + +### Monitoring +- Test execution time tracking +- Coverage trend analysis +- Test failure rate monitoring +- Automated test health reports + +## Conclusion + +This comprehensive test suite provides confidence in the reliability and correctness of the riskon application. With 70% minimum coverage across all critical components, the tests help prevent regressions and ensure robust functionality as the application evolves. + +Regular test maintenance and expansion will continue to improve code quality and developer confidence in the codebase. diff --git a/jest.config.js b/jest.config.js index 7d153079..c7b2cdb6 100644 --- a/jest.config.js +++ b/jest.config.js @@ -14,6 +14,14 @@ module.exports = { '!src/**/*.stories.{js,jsx,ts,tsx}', '!src/**/__tests__/**', ], + coverageThreshold: { + global: { + branches: 70, + functions: 70, + lines: 70, + statements: 70 + } + }, testMatch: [ '/src/**/__tests__/**/*.{js,jsx,ts,tsx}', '/src/**/*.{spec,test}.{js,jsx,ts,tsx}', diff --git a/package.json b/package.json index c08aa013..7b2ab176 100644 --- a/package.json +++ b/package.json @@ -6,7 +6,10 @@ "dev": "next dev --turbopack", "build": "next build", "start": "next start", - "lint": "next lint" + "lint": "next lint", + "test": "jest", + "test:watch": "jest --watch", + "test:coverage": "jest --coverage --coverageReporters=text --coverageReporters=html" }, "dependencies": { "@blend-capital/blend-sdk": "^2.2.0", @@ -24,7 +27,14 @@ }, "devDependencies": { "postcss": "^8", - "tailwindcss": "^3.4.1" + "tailwindcss": "^3.4.1", + "@testing-library/react": "^14.0.0", + "@testing-library/jest-dom": "^6.0.0", + "@testing-library/user-event": "^14.0.0", + "jest": "^29.7.0", + "jest-environment-jsdom": "^29.7.0", + "babel-jest": "^29.7.0", + "identity-obj-proxy": "^3.0.0" }, "overrides": { "react": "$react", diff --git a/src/components/__tests__/AutomatedRiskAnalyzer.test.jsx b/src/components/__tests__/AutomatedRiskAnalyzer.test.jsx new file mode 100644 index 00000000..703a0596 --- /dev/null +++ b/src/components/__tests__/AutomatedRiskAnalyzer.test.jsx @@ -0,0 +1,579 @@ +/** + * @jest-environment jsdom + */ + +import React from 'react'; +import { render, screen, fireEvent, waitFor } from '@testing-library/react'; +import userEvent from '@testing-library/user-event'; +import '@testing-library/jest-dom'; +import AutomatedRiskAnalyzer from '../AutomatedRiskAnalyzer'; + +// Mock all the dependencies +jest.mock('../lib/horizonDataCollector', () => ({ + collectTransactionData: jest.fn(), + getCachedAnalysis: jest.fn(), + cacheAnalysis: jest.fn(), +})); + +jest.mock('../lib/lightweightRiskModel', () => ({ + calculateRiskScore: jest.fn(), + getDataQualityScore: jest.fn(), +})); + +jest.mock('../lib/rateLimiter', () => ({ + checkRateLimit: jest.fn(), + recordUpdate: jest.fn(), + formatRemainingTime: jest.fn((ms) => '2h 30m'), +})); + +jest.mock('../app/lib/writeScore', () => ({ + writeScoreToBlockchainEnhanced: jest.fn(), +})); + +jest.mock('../contexts/WalletContext', () => ({ + useWallet: jest.fn(), +})); + +jest.mock('../contexts/ToastContext', () => ({ + useToast: jest.fn(), +})); + +// Mock child components +jest.mock('../BlendHistoryPerformance.jsx', () => { + return function MockBlendHistoryPerformance({ onScoreImpactChange }) { + return
Mock Blend History
; + }; +}); + +jest.mock('../BlendDashboard.jsx', () => { + return function MockBlendDashboard({ kit, walletAddress, riskScore }) { + return ( +
+ Mock Blend Dashboard - Score: {riskScore} +
+ ); + }; +}); + +jest.mock('../EnhancedLiquidityPools.jsx', () => { + return function MockEnhancedLiquidityPools() { + return
Mock Liquidity Pools
; + }; +}); + +describe('AutomatedRiskAnalyzer Component', () => { + const mockWalletAddress = 'GD5TESTEXAMPLEADDRESS123456789'; + const mockKit = { signTransaction: jest.fn() }; + + const mockToast = { + loading: jest.fn(), + success: jest.fn(), + error: jest.fn(), + warning: jest.fn(), + info: jest.fn(), + dismiss: jest.fn(), + }; + + const mockRiskAnalysis = { + riskScore: 25, + tier: 'TIER_1', + confidence: 0.85, + featureImportance: { + totalVolume: { weight: -0.15, normalizedValue: 0.8, impact: -0.12, rawValue: 5000, isPositive: true }, + uniqueCounterparties: { weight: -0.25, normalizedValue: 0.5, impact: -0.125, rawValue: 25, isPositive: true }, + assetDiversity: { weight: -0.2, normalizedValue: 0.4, impact: -0.08, rawValue: 4, isPositive: true }, + nightDayRatio: { weight: 0.35, normalizedValue: 0.2, impact: 0.07, rawValue: 0.3, isPositive: false }, + }, + explanation: ['đŸŸĸ Low Risk - Premium pool access', '✅ High transaction volume increases trust'], + recommendations: ['🎉 Excellent! Your risk profile is in great condition'], + rawMetrics: { + totalVolume: 5000, + uniqueCounterparties: 25, + assetDiversity: 4, + nightDayRatio: 0.3, + }, + normalizedFeatures: { + totalVolume: 0.8, + uniqueCounterparties: 0.5, + assetDiversity: 0.4, + nightDayRatio: 0.2, + }, + modelVersion: '1.0.0', + }; + + beforeEach(() => { + jest.clearAllMocks(); + + // Default mock implementations + const { useWallet } = require('../contexts/WalletContext'); + const { useToast } = require('../contexts/ToastContext'); + const { collectTransactionData, getCachedAnalysis } = require('../lib/horizonDataCollector'); + const { calculateRiskScore, getDataQualityScore } = require('../lib/lightweightRiskModel'); + const { checkRateLimit } = require('../lib/rateLimiter'); + const { writeScoreToBlockchainEnhanced } = require('../app/lib/writeScore'); + + useWallet.mockReturnValue({ + walletAddress: mockWalletAddress, + kit: mockKit, + }); + + useToast.mockReturnValue(mockToast); + + collectTransactionData.mockResolvedValue({ + success: true, + metrics: mockRiskAnalysis.rawMetrics, + dataPoints: { payments: 50, transactions: 45, period: 30 }, + timestamp: Date.now(), + }); + + getCachedAnalysis.mockReturnValue(null); + + calculateRiskScore.mockReturnValue(mockRiskAnalysis); + + getDataQualityScore.mockReturnValue({ + score: 100, + isGood: true, + needsMoreData: false, + }); + + checkRateLimit.mockReturnValue({ + canUpdate: true, + remainingTime: 0, + }); + + writeScoreToBlockchainEnhanced.mockResolvedValue({ + successful: true, + hash: '0x1234567890abcdef', + method: 'blockchain', + }); + }); + + afterEach(() => { + jest.restoreAllMocks(); + }); + + describe('Initial Rendering', () => { + test('should show connect wallet message when no wallet connected', () => { + const { useWallet } = require('../contexts/WalletContext'); + useWallet.mockReturnValue({ walletAddress: null, kit: null }); + + render(); + + expect(screen.getByText('Automated Risk Analysis')).toBeInTheDocument(); + expect(screen.getByText('Connect your wallet to use AI-powered risk analysis')).toBeInTheDocument(); + expect(screen.getByText(/We'll analyze your transaction data from the last 30 days/)).toBeInTheDocument(); + }); + + test('should show risk score gauge when wallet is connected', () => { + render(); + + expect(screen.getByText('Risk Score')).toBeInTheDocument(); + expect(screen.getByText('--')).toBeInTheDocument(); // Initial score display + expect(screen.getByRole('button', { name: /🧠 Start Analysis/ })).toBeInTheDocument(); + }); + + test('should load cached analysis on mount', () => { + const { getCachedAnalysis } = require('../lib/horizonDataCollector'); + const cachedData = { + success: true, + metrics: mockRiskAnalysis.rawMetrics, + riskAnalysis: mockRiskAnalysis, + timestamp: Date.now() - 30 * 60 * 1000, // 30 minutes ago + }; + + getCachedAnalysis.mockReturnValue(cachedData); + + render(); + + expect(getCachedAnalysis).toHaveBeenCalledWith(mockWalletAddress); + expect(screen.getByText('25')).toBeInTheDocument(); // Cached risk score + }); + }); + + describe('Risk Analysis Flow', () => { + test('should run complete analysis when start button is clicked', async () => { + const user = userEvent.setup(); + + render(); + + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + expect(mockToast.loading).toHaveBeenCalledWith('📊 Analyzing transaction data from last 30 days...'); + expect(mockToast.dismiss).toHaveBeenCalled(); + expect(mockToast.loading).toHaveBeenCalledWith('🧠 Calculating risk score with AI model...'); + + await waitFor(() => { + expect(mockToast.success).toHaveBeenCalledWith('✅ Risk analysis completed!', { duration: 4000 }); + }); + + expect(screen.getByText('25')).toBeInTheDocument(); // Risk score + expect(screen.getByText('Tier-1: Safe')).toBeInTheDocument(); + }); + + test('should handle analysis errors gracefully', async () => { + const user = userEvent.setup(); + const { collectTransactionData } = require('../lib/horizonDataCollector'); + + collectTransactionData.mockResolvedValue({ + success: false, + error: 'API Error', + metrics: null, + }); + + render(); + + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(mockToast.error).toHaveBeenCalledWith('❌ Analysis error: API Error'); + }); + }); + + test('should show data quality warning when needed', async () => { + const user = userEvent.setup(); + const { getDataQualityScore } = require('../lib/lightweightRiskModel'); + + getDataQualityScore.mockReturnValue({ + score: 50, + isGood: false, + needsMoreData: true, + }); + + render(); + + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(mockToast.warning).toHaveBeenCalledWith( + '⚠ī¸ More transaction history needed for better analysis', + { duration: 6000 } + ); + }); + }); + + test('should apply blend score impact when available', async () => { + const user = userEvent.setup(); + + render(); + + // Simulate blend impact + const blendImpact = { totalChange: -5 }; // Reduce score by 5 + + // We need to trigger the blend impact callback + // This would normally come from BlendHistoryPerformance component + const component = render(); + + // Find and trigger the blend impact change (this is a simplified test) + // In a real scenario, this would be triggered by the child component + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('20')).toBeInTheDocument(); // 25 - 5 = 20 + }); + }); + }); + + describe('Blockchain Update Flow', () => { + test('should update risk score on blockchain when button is clicked', async () => { + const user = userEvent.setup(); + + render(); + + // First run analysis + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('25')).toBeInTheDocument(); + }); + + // Then update on blockchain + const updateButton = screen.getByRole('button', { name: /🔗 Update Score/ }); + await user.click(updateButton); + + expect(mockToast.loading).toHaveBeenCalledWith('🔗 Saving risk score to the blockchain...'); + expect(mockToast.success).toHaveBeenCalledWith('✅ Risk score successfully saved to the blockchain!'); + + await waitFor(() => { + expect(mockToast.info).toHaveBeenCalledWith('🔗 Transaction: 0x123456...', { duration: 5000 }); + }); + }); + + test('should handle rate limiting', async () => { + const user = userEvent.setup(); + const { checkRateLimit } = require('../lib/rateLimiter'); + + checkRateLimit.mockReturnValue({ + canUpdate: false, + remainingTime: 2 * 60 * 60 * 1000, // 2 hours + }); + + render(); + + // Run analysis first + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('25')).toBeInTheDocument(); + }); + + // Try to update - should be rate limited + const updateButton = screen.getByRole('button', { name: /⏰ 2h 30m/ }); + expect(updateButton).toBeDisabled(); + }); + + test('should handle blockchain update failures', async () => { + const user = userEvent.setup(); + const { writeScoreToBlockchainEnhanced } = require('../app/lib/writeScore'); + + writeScoreToBlockchainEnhanced.mockResolvedValue({ + successful: false, + error: 'Transaction failed', + method: 'local_storage', + }); + + render(); + + // Run analysis first + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('25')).toBeInTheDocument(); + }); + + // Try to update + const updateButton = screen.getByRole('button', { name: /🔗 Update Score/ }); + await user.click(updateButton); + + await waitFor(() => { + expect(mockToast.warning).toHaveBeenCalledWith('⚠ī¸ Blockchain save failed - saved locally'); + }); + }); + + test('should handle user cancelled transactions', async () => { + const user = userEvent.setup(); + const { writeScoreToBlockchainEnhanced } = require('../app/lib/writeScore'); + + writeScoreToBlockchainEnhanced.mockRejectedValue(new Error('User cancelled transaction')); + + render(); + + // Run analysis first + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('25')).toBeInTheDocument(); + }); + + // Try to update + const updateButton = screen.getByRole('button', { name: /🔗 Update Score/ }); + await user.click(updateButton); + + await waitFor(() => { + expect(mockToast.info).toHaveBeenCalledWith('ℹī¸ Transaction cancelled by user'); + }); + }); + }); + + describe('UI Interactions', () => { + test('should toggle feature details visibility', async () => { + const user = userEvent.setup(); + + render(); + + // Run analysis first + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('25')).toBeInTheDocument(); + }); + + // Toggle details + const showDetailsButton = screen.getByRole('button', { name: 'Show Details' }); + await user.click(showDetailsButton); + + expect(screen.getByText('Hide Details')).toBeInTheDocument(); + expect(screen.getByText('đŸŸĸ Low Risk - Premium pool access')).toBeInTheDocument(); + expect(screen.getByText('✅ High transaction volume increases trust')).toBeInTheDocument(); + + // Hide details + await user.click(screen.getByRole('button', { name: 'Hide Details' })); + expect(screen.getByRole('button', { name: 'Show Details' })).toBeInTheDocument(); + }); + + test('should toggle recommendations visibility', async () => { + const user = userEvent.setup(); + + render(); + + // Run analysis first + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('25')).toBeInTheDocument(); + }); + + // Toggle recommendations + const showRecommendationsButton = screen.getByRole('button', { name: 'Show' }); + await user.click(showRecommendationsButton); + + expect(screen.getByRole('button', { name: 'Hide' })).toBeInTheDocument(); + expect(screen.getByText('🎉 Excellent! Your risk profile is in great condition')).toBeInTheDocument(); + }); + + test('should allow re-analysis', async () => { + const user = userEvent.setup(); + + render(); + + // First analysis + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('25')).toBeInTheDocument(); + }); + + // Re-analyze + const reanalyzeButton = screen.getByRole('button', { name: /🔄 Re-analyze/ }); + await user.click(reanalyzeButton); + + expect(mockToast.loading).toHaveBeenCalledTimes(2); // Once for initial, once for re-analysis + }); + }); + + describe('Feature Display', () => { + test('should display feature breakdown correctly', async () => { + const user = userEvent.setup(); + + render(); + + // Run analysis first + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('25')).toBeInTheDocument(); + }); + + // Check feature display + expect(screen.getByText('💰')).toBeInTheDocument(); + expect(screen.getByText('5000 XLM')).toBeInTheDocument(); + expect(screen.getByText('🤝')).toBeInTheDocument(); + expect(screen.getByText('25')).toBeInTheDocument(); + expect(screen.getByText('đŸŽ¯')).toBeInTheDocument(); + expect(screen.getByText('4')).toBeInTheDocument(); + expect(screen.getByText('🌙')).toBeInTheDocument(); + expect(screen.getByText('0.3')).toBeInTheDocument(); + }); + + test('should show tier badge correctly', async () => { + const user = userEvent.setup(); + + render(); + + // Run analysis first + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('Tier-1: Safe')).toBeInTheDocument(); + }); + + const tierBadge = screen.getByText('Tier-1: Safe').closest('span'); + expect(tierBadge).toHaveClass('bg-green-100', 'text-green-800', 'border-green-200'); + }); + }); + + describe('Child Components', () => { + test('should render Blend components when wallet is connected', async () => { + const user = userEvent.setup(); + + render(); + + // Run analysis first + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('25')).toBeInTheDocument(); + }); + + expect(screen.getByTestId('blend-history-performance')).toBeInTheDocument(); + expect(screen.getByTestId('blend-dashboard')).toBeInTheDocument(); + expect(screen.getByTestId('enhanced-liquidity-pools')).toBeInTheDocument(); + }); + + test('should not render Blend components without analysis', () => { + render(); + + expect(screen.queryByTestId('blend-dashboard')).not.toBeInTheDocument(); + expect(screen.queryByTestId('enhanced-liquidity-pools')).not.toBeInTheDocument(); + }); + }); + + describe('Loading States', () => { + test('should show loading state during analysis', async () => { + const user = userEvent.setup(); + const { collectTransactionData } = require('../lib/horizonDataCollector'); + + // Make the collection take longer + collectTransactionData.mockImplementation(() => new Promise(resolve => { + setTimeout(() => resolve({ + success: true, + metrics: mockRiskAnalysis.rawMetrics, + dataPoints: { payments: 50, transactions: 45, period: 30 }, + timestamp: Date.now(), + }), 100); + })); + + render(); + + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + expect(startButton).toBeDisabled(); + expect(screen.getByText('Analyzing...')).toBeInTheDocument(); + }); + + test('should show loading state during blockchain update', async () => { + const user = userEvent.setup(); + const { writeScoreToBlockchainEnhanced } = require('../app/lib/writeScore'); + + // Make the blockchain update take longer + writeScoreToBlockchainEnhanced.mockImplementation(() => new Promise(resolve => { + setTimeout(() => resolve({ + successful: true, + hash: '0x1234567890abcdef', + method: 'blockchain', + }), 100); + })); + + render(); + + // Run analysis first + const startButton = screen.getByRole('button', { name: /🧠 Start Analysis/ }); + await user.click(startButton); + + await waitFor(() => { + expect(screen.getByText('25')).toBeInTheDocument(); + }); + + // Try to update + const updateButton = screen.getByRole('button', { name: /🔗 Update Score/ }); + await user.click(updateButton); + + expect(updateButton).toBeDisabled(); + expect(screen.getByText('Saving to Blockchain...')).toBeInTheDocument(); + }); + }); +}); diff --git a/src/lib/__tests__/horizonDataCollector.test.js b/src/lib/__tests__/horizonDataCollector.test.js new file mode 100644 index 00000000..4952c3eb --- /dev/null +++ b/src/lib/__tests__/horizonDataCollector.test.js @@ -0,0 +1,668 @@ +/** + * @jest-environment jsdom + */ + +import { collectTransactionData, isDataFresh, getCachedAnalysis, cacheAnalysis } from '../horizonDataCollector'; + +// Mock the cacheManager module +jest.mock('../cacheManager', () => ({ + getCache: jest.fn(), + setCache: jest.fn(), +})); + +// Mock the CACHE_KEYS +jest.mock('../types/cache', () => ({ + CACHE_KEYS: { + HORIZON_DATA: 'horizon_data', + USER_RISK_TIER: 'user_risk_tier', + RISK_SCORE: 'risk_score', + }, +})); + +// Mock global fetch +global.fetch = jest.fn(); + +describe('Horizon Data Collector', () => { + beforeEach(() => { + jest.clearAllMocks(); + // Clear localStorage + localStorage.clear(); + + // Mock console methods to avoid noise in tests + jest.spyOn(console, 'log').mockImplementation(() => {}); + jest.spyOn(console, 'error').mockImplementation(() => {}); + jest.spyOn(console, 'warn').mockImplementation(() => {}); + }); + + afterEach(() => { + jest.restoreAllMocks(); + }); + + describe('collectTransactionData', () => { + const mockWalletAddress = 'GD5TQY6K5ZQZQZQZQZQZQZQZQZQZQZQZQZQZQZQ'; + + test('should return cached data when available', async () => { + const { getCache } = require('../cacheManager'); + const { CACHE_KEYS } = require('../types/cache'); + + const cachedData = { + success: true, + metrics: { + totalVolume: 5000, + uniqueCounterparties: 25, + assetDiversity: 5, + nightDayRatio: 0.3, + }, + timestamp: Date.now(), + }; + + getCache.mockResolvedValue(cachedData); + + const result = await collectTransactionData(mockWalletAddress); + + expect(getCache).toHaveBeenCalledWith(`${CACHE_KEYS.HORIZON_DATA}_${mockWalletAddress}`); + expect(result).toEqual(cachedData); + expect(console.log).toHaveBeenCalledWith('🚀 Using cached Horizon data'); + expect(fetch).not.toHaveBeenCalled(); + }); + + test('should fetch fresh data when cache is empty', async () => { + const { getCache, setCache } = require('../cacheManager'); + const { CACHE_KEYS } = require('../types/cache'); + + getCache.mockResolvedValue(null); + + // Mock successful API responses + const mockPaymentsResponse = { + _embedded: { + records: [ + { + id: 'payment1', + amount: '100', + asset_type: 'native', + asset_code: 'XLM', + from: 'GD5TEST1', + to: mockWalletAddress, + created_at: new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString(), // 10 days ago + type: 'payment', + }, + { + id: 'payment2', + amount: '50', + asset_type: 'credit_alphanum4', + asset_code: 'USD', + from: 'GD5TEST2', + to: mockWalletAddress, + created_at: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(), // 5 days ago + type: 'payment', + }, + ], + }, + _links: { + next: null, + }, + }; + + const mockTransactionsResponse = { + _embedded: { + records: [ + { + id: 'tx1', + fee_charged: '100', + operation_count: 1, + created_at: new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString(), + successful: true, + }, + ], + }, + _links: { + next: null, + }, + }; + + fetch + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockPaymentsResponse), + }) + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockTransactionsResponse), + }); + + const result = await collectTransactionData(mockWalletAddress); + + expect(fetch).toHaveBeenCalledTimes(2); + expect(setCache).toHaveBeenCalled(); + expect(result.success).toBe(true); + expect(result.metrics).toBeDefined(); + expect(result.metrics.totalVolume).toBe(105); // 100 + 5 (USD converted at 0.1 rate) + expect(result.metrics.uniqueCounterparties).toBe(2); + expect(result.metrics.assetDiversity).toBe(2); // XLM and USD + expect(result.dataPoints.payments).toBe(2); + expect(result.dataPoints.transactions).toBe(1); + }); + + test('should handle API errors gracefully', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + fetch.mockRejectedValue(new Error('Network error')); + + const result = await collectTransactionData(mockWalletAddress); + + expect(result.success).toBe(false); + expect(result.error).toBe('Network error'); + expect(result.metrics).toBeNull(); + expect(console.error).toHaveBeenCalledWith('❌ Data collection failed:', expect.any(Error)); + }); + + test('should handle empty API responses', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + + const mockEmptyResponse = { + _embedded: { + records: [], + }, + _links: { + next: null, + }, + }; + + fetch + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockEmptyResponse), + }) + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockEmptyResponse), + }); + + const result = await collectTransactionData(mockWalletAddress); + + expect(result.success).toBe(true); + expect(result.metrics.totalVolume).toBe(0); + expect(result.metrics.uniqueCounterparties).toBe(0); + expect(result.metrics.assetDiversity).toBe(0); + expect(result.metrics.nightDayRatio).toBe(0); + }); + + test('should handle paginated responses', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + + // Mock first page + const mockFirstPage = { + _embedded: { + records: [ + { + id: 'payment1', + amount: '100', + asset_type: 'native', + asset_code: 'XLM', + from: 'GD5TEST1', + to: mockWalletAddress, + created_at: new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString(), + type: 'payment', + }, + ], + }, + _links: { + next: { + href: 'https://horizon-testnet.stellar.org/accounts/GD.../payments?cursor=123', + }, + }, + }; + + // Mock second page + const mockSecondPage = { + _embedded: { + records: [ + { + id: 'payment2', + amount: '50', + asset_type: 'native', + asset_code: 'XLM', + from: 'GD5TEST2', + to: mockWalletAddress, + created_at: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(), + type: 'payment', + }, + ], + }, + _links: { + next: null, + }, + }; + + fetch + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockFirstPage), + }) + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockSecondPage), + }) + // Mock transactions response + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve({ + _embedded: { records: [] }, + _links: { next: null }, + }), + }); + + const result = await collectTransactionData(mockWalletAddress); + + expect(fetch).toHaveBeenCalledTimes(3); // 2 for payments (paginated), 1 for transactions + expect(result.metrics.totalVolume).toBe(150); + expect(result.dataPoints.payments).toBe(2); + }); + + test('should filter transactions outside date range', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + + const mockOldPayment = { + id: 'old_payment', + amount: '1000', + asset_type: 'native', + asset_code: 'XLM', + from: 'GD5OLD', + to: mockWalletAddress, + created_at: new Date(Date.now() - 40 * 24 * 60 * 60 * 1000).toISOString(), // 40 days ago + type: 'payment', + }; + + const mockRecentPayment = { + id: 'recent_payment', + amount: '100', + asset_type: 'native', + asset_code: 'XLM', + from: 'GD5RECENT', + to: mockWalletAddress, + created_at: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(), // 5 days ago + type: 'payment', + }; + + const mockResponse = { + _embedded: { + records: [mockOldPayment, mockRecentPayment], + }, + _links: { + next: null, + }, + }; + + fetch + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockResponse), + }) + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve({ + _embedded: { records: [] }, + _links: { next: null }, + }), + }); + + const result = await collectTransactionData(mockWalletAddress); + + expect(result.metrics.totalVolume).toBe(100); // Only recent payment + expect(result.dataPoints.payments).toBe(1); + }); + + test('should calculate night/day ratio correctly', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + + const nightPayment = { + id: 'night_payment', + amount: '50', + asset_type: 'native', + asset_code: 'XLM', + from: 'GD5NIGHT', + to: mockWalletAddress, + created_at: new Date().setHours(23, 0, 0, 0), // 11 PM + type: 'payment', + }; + + const dayPayment = { + id: 'day_payment', + amount: '50', + asset_type: 'native', + asset_code: 'XLM', + from: 'GD5DAY', + to: mockWalletAddress, + created_at: new Date().setHours(14, 0, 0, 0), // 2 PM + type: 'payment', + }; + + const mockResponse = { + _embedded: { + records: [nightPayment, dayPayment], + }, + _links: { + next: null, + }, + }; + + fetch + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockResponse), + }) + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve({ + _embedded: { records: [] }, + _links: { next: null }, + }), + }); + + const result = await collectTransactionData(mockWalletAddress); + + expect(result.metrics.nightDayRatio).toBe(1); // 1 night / 1 day = 1 + }); + }); + + describe('isDataFresh', () => { + test('should return true for fresh data', () => { + const freshTimestamp = Date.now() - 30 * 60 * 1000; // 30 minutes ago + expect(isDataFresh(freshTimestamp)).toBe(true); + }); + + test('should return false for stale data', () => { + const staleTimestamp = Date.now() - 2 * 60 * 60 * 1000; // 2 hours ago + expect(isDataFresh(staleTimestamp)).toBe(false); + }); + + test('should return false for null timestamp', () => { + expect(isDataFresh(null)).toBe(false); + }); + + test('should return false for undefined timestamp', () => { + expect(isDataFresh(undefined)).toBe(false); + }); + + test('should handle edge case exactly at 1 hour', () => { + const edgeTimestamp = Date.now() - 60 * 60 * 1000; // Exactly 1 hour ago + expect(isDataFresh(edgeTimestamp)).toBe(false); + }); + }); + + describe('getCachedAnalysis', () => { + const mockWalletAddress = 'GD5TESTEXAMPLE'; + + test('should return cached data when fresh', () => { + const freshData = { + success: true, + metrics: { totalVolume: 1000 }, + timestamp: Date.now() - 30 * 60 * 1000, // 30 minutes ago + }; + + localStorage.setItem( + `horizon_analysis_${mockWalletAddress}`, + JSON.stringify(freshData) + ); + + const result = getCachedAnalysis(mockWalletAddress); + + expect(result).toEqual(freshData); + }); + + test('should return null for stale data', () => { + const staleData = { + success: true, + metrics: { totalVolume: 1000 }, + timestamp: Date.now() - 2 * 60 * 60 * 1000, // 2 hours ago + }; + + localStorage.setItem( + `horizon_analysis_${mockWalletAddress}`, + JSON.stringify(staleData) + ); + + const result = getCachedAnalysis(mockWalletAddress); + + expect(result).toBeNull(); + }); + + test('should return null when no cached data exists', () => { + const result = getCachedAnalysis(mockWalletAddress); + expect(result).toBeNull(); + }); + + test('should handle corrupted cache data', () => { + localStorage.setItem( + `horizon_analysis_${mockWalletAddress}`, + 'invalid json' + ); + + const result = getCachedAnalysis(mockWalletAddress); + + expect(result).toBeNull(); + expect(console.warn).toHaveBeenCalledWith( + '⚠ī¸ Error reading cached analysis:', + expect.any(Error) + ); + }); + }); + + describe('cacheAnalysis', () => { + const mockWalletAddress = 'GD5TESTEXAMPLE'; + const mockAnalysisData = { + success: true, + metrics: { totalVolume: 1000 }, + timestamp: Date.now(), + }; + + test('should cache analysis data successfully', () => { + cacheAnalysis(mockWalletAddress, mockAnalysisData); + + const cachedData = localStorage.getItem( + `horizon_analysis_${mockWalletAddress}` + ); + + expect(cachedData).toBe(JSON.stringify(mockAnalysisData)); + }); + + test('should handle localStorage errors gracefully', () => { + // Mock localStorage to throw an error + const originalSetItem = localStorage.setItem; + localStorage.setItem = jest.fn(() => { + throw new Error('Storage quota exceeded'); + }); + + cacheAnalysis(mockWalletAddress, mockAnalysisData); + + expect(console.warn).toHaveBeenCalledWith( + '⚠ī¸ Error caching analysis:', + expect.any(Error) + ); + + // Restore original localStorage + localStorage.setItem = originalSetItem; + }); + }); + + describe('Risk Metrics Calculation', () => { + test('should convert non-XLM assets at simplified rate', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + + const mockResponse = { + _embedded: { + records: [ + { + id: 'usd_payment', + amount: '100', + asset_type: 'credit_alphanum4', + asset_code: 'USD', + from: 'GD5TEST', + to: 'GD5WALLET', + created_at: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(), + type: 'payment', + }, + ], + }, + _links: { + next: null, + }, + }; + + fetch + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockResponse), + }) + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve({ + _embedded: { records: [] }, + _links: { next: null }, + }), + }); + + const result = await collectTransactionData('GD5WALLET'); + + expect(result.metrics.totalVolume).toBe(10); // 100 USD * 0.1 conversion rate + }); + + test('should handle native XLM assets correctly', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + + const mockResponse = { + _embedded: { + records: [ + { + id: 'xlm_payment', + amount: '100', + asset_type: 'native', + from: 'GD5TEST', + to: 'GD5WALLET', + created_at: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(), + type: 'payment', + }, + ], + }, + _links: { + next: null, + }, + }; + + fetch + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockResponse), + }) + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve({ + _embedded: { records: [] }, + _links: { next: null }, + }), + }); + + const result = await collectTransactionData('GD5WALLET'); + + expect(result.metrics.totalVolume).toBe(100); // 100 XLM (no conversion) + }); + }); + + describe('Error Handling', () => { + test('should handle fetch errors with warning', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + + fetch.mockRejectedValue(new Error('Network error')); + + await collectTransactionData('GD5TEST'); + + expect(console.error).toHaveBeenCalledWith( + '❌ Data collection failed:', + expect.any(Error) + ); + }); + + test('should handle malformed API responses', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + + fetch.mockResolvedValue({ + ok: true, + json: () => Promise.resolve({ invalid: 'response' }), + }); + + const result = await collectTransactionData('GD5TEST'); + + expect(result.success).toBe(true); + expect(result.metrics.totalVolume).toBe(0); + }); + + test('should handle pagination errors gracefully', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + + // First page succeeds + const mockFirstPage = { + _embedded: { + records: [ + { + id: 'payment1', + amount: '100', + asset_type: 'native', + from: 'GD5TEST', + to: 'GD5WALLET', + created_at: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(), + type: 'payment', + }, + ], + }, + _links: { + next: { + href: 'https://horizon-testnet.stellar.org/accounts/GD.../payments?cursor=123', + }, + }, + }; + + fetch + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve(mockFirstPage), + }) + // Second page fails + .mockRejectedValueOnce(new Error('Pagination error')) + // Transactions succeed + .mockResolvedValueOnce({ + ok: true, + json: () => Promise.resolve({ + _embedded: { records: [] }, + _links: { next: null }, + }), + }); + + const result = await collectTransactionData('GD5WALLET'); + + expect(result.metrics.totalVolume).toBe(100); // Should still get first page data + expect(console.warn).toHaveBeenCalledWith( + '⚠ī¸ Error fetching payments page:', + expect.any(Error) + ); + }); + }); +}); diff --git a/src/lib/__tests__/riskTierClient.test.ts b/src/lib/__tests__/riskTierClient.test.ts new file mode 100644 index 00000000..d60ae0c7 --- /dev/null +++ b/src/lib/__tests__/riskTierClient.test.ts @@ -0,0 +1,721 @@ +/** + * @jest-environment jsdom + */ + +import { RiskTierContractClient, riskTierClient, useRiskTierContract } from '../riskTierClient'; +import { Server, Address, nativeToScVal, scValToNative, Networks, BASE_FEE, TransactionBuilder, Horizon } from '@stellar/stellar-sdk'; + +// Mock Stellar SDK +jest.mock('@stellar/stellar-sdk', () => ({ + Server: jest.fn(), + Address: { + fromString: jest.fn(), + }, + nativeToScVal: jest.fn(), + scValToNative: jest.fn(), + TransactionBuilder: jest.fn(), + Networks: { + TESTNET: 'Test SDF Network ; September 2015', + }, + BASE_FEE: '100', + StrKey: { + isValidEd25519PublicKey: jest.fn(), + }, + Horizon: { + Server: jest.fn(), + }, +})); + +// Mock cacheManager +jest.mock('../cacheManager', () => ({ + getCache: jest.fn(), + setCache: jest.fn(), + invalidateCache: jest.fn(), +})); + +// Mock cache invalidation hook +jest.mock('../hooks/useCacheInvalidation', () => ({ + dispatchCacheEvent: { + riskTierUpdated: jest.fn(), + }, +})); + +// Mock cache types +jest.mock('../types/cache', () => ({ + CACHE_KEYS: { + USER_RISK_TIER: 'user_risk_tier', + RISK_SCORE: 'risk_score', + HORIZON_DATA: 'horizon_data', + }, +})); + +// Mock passkey integration +jest.mock('../passkeyIntegration', () => ({ + passkeyWallet: { + signTransaction: jest.fn(), + submitTransactionDirectly: jest.fn(), + smartWalletAddress: 'C1234567890ABCDEF1234567890ABCDEF12345678', + }, +})); + +// Mock console methods +jest.spyOn(console, 'log').mockImplementation(() => {}); +jest.spyOn(console, 'error').mockImplementation(() => {}); +jest.spyOn(console, 'warn').mockImplementation(() => {}); + +describe('RiskTierContractClient', () => { + let client: RiskTierContractClient; + let mockServer: jest.Mocked; + let mockHorizon: jest.Mocked; + + const mockContractId = 'C1234567890ABCDEF1234567890ABCDEF12345678'; + const mockWalletAddress = 'GD5TESTEXAMPLEADDRESS123456789'; + const mockRiskTierData = { + score: 25, + tier: 'TIER_1', + timestamp: BigInt(Date.now()), + chosen_tier: 'TIER_1', + }; + + beforeEach(() => { + jest.clearAllMocks(); + + // Mock Server constructor + mockServer = { + simulateTransaction: jest.fn(), + } as any; + (Server as jest.Mock).mockReturnValue(mockServer); + + // Mock Horizon Server + mockHorizon = { + loadAccount: jest.fn(), + }; + (Horizon.Server as jest.Mock).mockReturnValue(mockHorizon); + + // Mock Address.fromString + (Address.fromString as jest.Mock).mockReturnValue({ + toScVal: jest.fn().mockReturnValue('mock-address-scval'), + }); + + // Mock nativeToScVal + (nativeToScVal as jest.Mock).mockReturnValue('mock-scval'); + + // Mock scValToNative + (scValToNative as jest.Mock).mockReturnValue(mockRiskTierData); + + // Mock StrKey.isValidEd25519PublicKey + const { StrKey } = require('@stellar/stellar-sdk'); + StrKey.isValidEd25519PublicKey.mockReturnValue(true); + + // Mock TransactionBuilder + const mockTxBuilder = { + addOperation: jest.fn().mockReturnThis(), + setTimeout: jest.fn().mockReturnThis(), + build: jest.fn().mockReturnValue({ + toXDR: jest.fn().mockReturnValue('mock-transaction-xdr'), + }), + }; + (TransactionBuilder as jest.Mock).mockImplementation(() => mockTxBuilder); + + // Set environment variables + process.env.NEXT_PUBLIC_RISK_TIER_CONTRACT_ID = mockContractId; + process.env.NEXT_PUBLIC_SOROBAN_RPC_URL = 'https://soroban-testnet.stellar.org'; + process.env.NEXT_PUBLIC_NETWORK_PASSPHRASE = Networks.TESTNET; + + client = new RiskTierContractClient(mockContractId); + }); + + afterEach(() => { + jest.restoreAllMocks(); + }); + + describe('Constructor and Configuration', () => { + test('should initialize with provided contract ID', () => { + const testClient = new RiskTierContractClient(mockContractId); + expect(testClient).toBeInstanceOf(RiskTierContractClient); + }); + + test('should use environment variables when no contract ID provided', () => { + const testClient = new RiskTierContractClient(); + expect(testClient).toBeInstanceOf(RiskTierContractClient); + }); + + test('should throw error when contract ID is not configured', () => { + delete process.env.NEXT_PUBLIC_RISK_TIER_CONTRACT_ID; + delete process.env.NEXT_PUBLIC_RISKSCORE_CONTRACT_ID; + + const testClient = new RiskTierContractClient(); + + expect(() => testClient['contract']).toThrow( + 'Contract ID not configured. Set NEXT_PUBLIC_RISK_TIER_CONTRACT_ID or NEXT_PUBLIC_RISKSCORE_CONTRACT_ID in your .env.local file.' + ); + }); + }); + + describe('Address Validation', () => { + test('should validate valid G address', () => { + const { StrKey } = require('@stellar/stellar-sdk'); + StrKey.isValidEd25519PublicKey.mockReturnValue(true); + + expect(() => client['validateAddress'](mockWalletAddress)).not.toThrow(); + }); + + test('should validate valid C address', () => { + const { StrKey } = require('@stellar/stellar-sdk'); + StrKey.isValidEd25519PublicKey.mockReturnValue(false); + + const cAddress = 'C1234567890ABCDEF1234567890ABCDEF12345678'; + expect(() => client['validateAddress'](cAddress)).not.toThrow(); + }); + + test('should reject invalid address format', () => { + const { StrKey } = require('@stellar/stellar-sdk'); + StrKey.isValidEd25519PublicKey.mockReturnValue(false); + + expect(() => client['validateAddress']('INVALID')).toThrow( + 'Address "INVALID" is not a valid Stellar address.' + ); + }); + + test('should reject empty address', () => { + expect(() => client['validateAddress']('')).toThrow( + 'Address is required and must be a non-empty string.' + ); + }); + + test('should reject null address', () => { + expect(() => client['validateAddress'](null)).toThrow( + 'Address is required and must be a non-empty string.' + ); + }); + }); + + describe('Score Validation', () => { + test('should accept valid score', () => { + expect(client['validateScore'](50)).toBe(50); + }); + + test('should round decimal scores', () => { + expect(client['validateScore'](75.7)).toBe(76); + }); + + test('should reject negative scores', () => { + expect(() => client['validateScore'](-10)).toThrow( + 'Score must be between 0 and 100 (inclusive), received -10.' + ); + }); + + test('should reject scores over 100', () => { + expect(() => client['validateScore'](150)).toThrow( + 'Score must be between 0 and 100 (inclusive), received 150.' + ); + }); + + test('should reject non-numeric scores', () => { + expect(() => client['validateScore']('invalid' as any)).toThrow( + 'Score must be a finite number.' + ); + }); + + test('should reject infinite scores', () => { + expect(() => client['validateScore'](Infinity)).toThrow( + 'Score must be a finite number.' + ); + }); + }); + + describe('Tier Validation', () => { + test('should accept valid tiers', () => { + expect(client['validateTierInput']('TIER_1')).toBe('TIER_1'); + expect(client['validateTierInput']('tier_2')).toBe('TIER_2'); + expect(client['validateTierInput']('Tier_3')).toBe('TIER_3'); + }); + + test('should reject invalid tiers', () => { + expect(() => client['validateTierInput']('INVALID_TIER')).toThrow( + 'Tier "INVALID_TIER" is invalid. Must be one of: TIER_1, TIER_2, TIER_3.' + ); + }); + + test('should reject empty tier', () => { + expect(() => client['validateTierInput']('')).toThrow( + 'Tier is required and must be a string.' + ); + }); + }); + + describe('Read Operations', () => { + describe('getRiskTier', () => { + test('should return cached risk tier data', async () => { + const { getCache } = require('../cacheManager'); + const { CACHE_KEYS } = require('../types/cache'); + + getCache.mockResolvedValue(mockRiskTierData); + + const result = await client.getRiskTier(mockWalletAddress); + + expect(getCache).toHaveBeenCalledWith(`${CACHE_KEYS.USER_RISK_TIER}_${mockWalletAddress}`); + expect(result).toEqual(mockRiskTierData); + expect(console.log).toHaveBeenCalledWith('🚀 Using cached risk tier data'); + }); + + test('should fetch fresh risk tier data from contract', async () => { + const { getCache, setCache } = require('../cacheManager'); + const { CACHE_KEYS } = require('../types/cache'); + + getCache.mockResolvedValue(null); + mockServer.simulateTransaction.mockResolvedValue({ + result: { retval: 'mock-risk-tier-scval' }, + }); + + const result = await client.getRiskTier(mockWalletAddress); + + expect(mockServer.simulateTransaction).toHaveBeenCalled(); + expect(scValToNative).toHaveBeenCalledWith('mock-risk-tier-scval'); + expect(setCache).toHaveBeenCalled(); + expect(result).toEqual(mockRiskTierData); + }); + + test('should handle simulation errors gracefully', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + mockServer.simulateTransaction.mockResolvedValue({ + error: 'Simulation failed', + }); + + const result = await client.getRiskTier(mockWalletAddress); + + expect(result).toBeNull(); + expect(console.warn).toHaveBeenCalledWith( + expect.stringContaining('[RiskTierClient] Simulation error in getRiskTier:'), + 'Simulation failed' + ); + }); + + test('should handle network errors', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + mockServer.simulateTransaction.mockRejectedValue(new Error('Network error')); + + const result = await client.getRiskTier(mockWalletAddress); + + expect(result).toBeNull(); + expect(console.error).toHaveBeenCalledWith( + expect.stringContaining('[RiskTierClient] simulateReadCall(getRiskTier) failed:'), + expect.any(Error) + ); + }); + }); + + describe('getScore', () => { + test('should return score from cached tier data', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(mockRiskTierData); + + const result = await client.getScore(mockWalletAddress); + + expect(result).toBe(25); + }); + + test('should fetch score directly from contract', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + mockServer.simulateTransaction.mockResolvedValue({ + result: { retval: 'mock-score-scval' }, + }); + (scValToNative as jest.Mock).mockReturnValue(42); + + const result = await client.getScore(mockWalletAddress); + + expect(result).toBe(42); + }); + + test('should return 0 on error', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + mockServer.simulateTransaction.mockRejectedValue(new Error('Network error')); + + const result = await client.getScore(mockWalletAddress); + + expect(result).toBe(0); + }); + }); + + describe('getChosenTier', () => { + test('should return chosen tier from cached data', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(mockRiskTierData); + + const result = await client.getChosenTier(mockWalletAddress); + + expect(result).toBe('TIER_1'); + }); + + test('should fetch chosen tier directly from contract', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + mockServer.simulateTransaction.mockResolvedValue({ + result: { retval: 'mock-tier-scval' }, + }); + (scValToNative as jest.Mock).mockReturnValue('TIER_2'); + + const result = await client.getChosenTier(mockWalletAddress); + + expect(result).toBe('TIER_2'); + }); + + test('should return TIER_3 as default on error', async () => { + const { getCache } = require('../cacheManager'); + + getCache.mockResolvedValue(null); + mockServer.simulateTransaction.mockRejectedValue(new Error('Network error')); + + const result = await client.getChosenTier(mockWalletAddress); + + expect(result).toBe('TIER_3'); + }); + }); + + describe('canAccessTier', () => { + test('should return true for accessible tier', async () => { + mockServer.simulateTransaction.mockResolvedValue({ + result: { retval: 'mock-bool-scval' }, + }); + (scValToNative as jest.Mock).mockReturnValue(true); + + const result = await client.canAccessTier(mockWalletAddress, 'TIER_1'); + + expect(result).toBe(true); + }); + + test('should return false for inaccessible tier', async () => { + mockServer.simulateTransaction.mockResolvedValue({ + result: { retval: 'mock-bool-scval' }, + }); + (scValToNative as jest.Mock).mockReturnValue(false); + + const result = await client.canAccessTier(mockWalletAddress, 'TIER_3'); + + expect(result).toBe(false); + }); + + test('should return false on error', async () => { + mockServer.simulateTransaction.mockRejectedValue(new Error('Network error')); + + const result = await client.canAccessTier(mockWalletAddress, 'TIER_1'); + + expect(result).toBe(false); + }); + }); + + describe('getTierStats', () => { + test('should return tier statistics', async () => { + mockServer.simulateTransaction.mockResolvedValue({ + result: { retval: 'mock-stats-scval' }, + }); + (scValToNative as jest.Mock).mockReturnValue({ + TIER_1: 100, + TIER_2: 50, + TIER_3: 25, + }); + + const result = await client.getTierStats(); + + expect(result).toEqual({ + TIER_1: 100, + TIER_2: 50, + TIER_3: 25, + }); + }); + + test('should return default stats on error', async () => { + mockServer.simulateTransaction.mockRejectedValue(new Error('Network error')); + + const result = await client.getTierStats(); + + expect(result).toEqual({ + TIER_1: 0, + TIER_2: 0, + TIER_3: 0, + }); + }); + }); + + describe('getTierUsers', () => { + test('should return users in specified tier', async () => { + mockServer.simulateTransaction.mockResolvedValue({ + result: { retval: 'mock-users-scval' }, + }); + (scValToNative as jest.Mock).mockReturnValue([ + 'GD5USER1', + 'GD5USER2', + 'GD5USER3', + ]); + + const result = await client.getTierUsers('TIER_1'); + + expect(result).toEqual(['GD5USER1', 'GD5USER2', 'GD5USER3']); + }); + + test('should return empty array on error', async () => { + mockServer.simulateTransaction.mockRejectedValue(new Error('Network error')); + + const result = await client.getTierUsers('TIER_1'); + + expect(result).toEqual([]); + }); + }); + }); + + describe('Write Operations', () => { + describe('setRiskTier', () => { + test('should set risk tier successfully', async () => { + const { passkeyWallet } = require('../passkeyIntegration'); + const { invalidateCache } = require('../cacheManager'); + const { dispatchCacheEvent } = require('../hooks/useCacheInvalidation'); + + passkeyWallet.signTransaction.mockResolvedValue('mock-signature'); + passkeyWallet.submitTransactionDirectly.mockResolvedValue({ + hash: '0x1234567890abcdef', + }); + + mockHorizon.loadAccount.mockResolvedValue({ + sequence: '123456789', + }); + + const result = await client.setRiskTier( + mockWalletAddress, + 25, + 'TIER_1', + 'TIER_1' + ); + + expect(result).toBe('0x1234567890abcdef'); + expect(invalidateCache).toHaveBeenCalled(); + expect(dispatchCacheEvent.riskTierUpdated).toHaveBeenCalledWith( + mockWalletAddress, + 'TIER_1' + ); + }); + + test('should handle signing errors', async () => { + const { passkeyWallet } = require('../passkeyIntegration'); + + passkeyWallet.signTransaction.mockRejectedValue(new Error('Signing failed')); + + mockHorizon.loadAccount.mockResolvedValue({ + sequence: '123456789', + }); + + await expect( + client.setRiskTier(mockWalletAddress, 25, 'TIER_1', 'TIER_1') + ).rejects.toThrow('Signing failed'); + }); + }); + + describe('updateChosenTier', () => { + test('should update chosen tier successfully', async () => { + const { passkeyWallet } = require('../passkeyIntegration'); + + passkeyWallet.signTransaction.mockResolvedValue('mock-signature'); + passkeyWallet.submitTransactionDirectly.mockResolvedValue({ + hash: '0xabcdef1234567890', + }); + + mockHorizon.loadAccount.mockResolvedValue({ + sequence: '123456789', + }); + + const result = await client.updateChosenTier(mockWalletAddress, 'TIER_2'); + + expect(result).toBe('0xabcdef1234567890'); + }); + }); + }); + + describe('Cache Management', () => { + test('should invalidate user cache after updates', async () => { + const { passkeyWallet } = require('../passkeyIntegration'); + const { invalidateCache } = require('../cacheManager'); + + passkeyWallet.signTransaction.mockResolvedValue('mock-signature'); + passkeyWallet.submitTransactionDirectly.mockResolvedValue({ + hash: '0x1234567890abcdef', + }); + + mockHorizon.loadAccount.mockResolvedValue({ + sequence: '123456789', + }); + + await client.setRiskTier(mockWalletAddress, 25, 'TIER_1', 'TIER_1'); + + expect(invalidateCache).toHaveBeenCalledTimes(3); // USER_RISK_TIER, RISK_SCORE, HORIZON_DATA + }); + }); + + describe('Account Resolution', () => { + test('should load G address from Horizon', async () => { + const { passkeyWallet } = require('../passkeyIntegration'); + + passkeyWallet.signTransaction.mockResolvedValue('mock-signature'); + passkeyWallet.submitTransactionDirectly.mockResolvedValue({ + hash: '0x1234567890abcdef', + }); + + const mockAccount = { + sequence: '123456789', + }; + mockHorizon.loadAccount.mockResolvedValue(mockAccount); + + await client.setRiskTier(mockWalletAddress, 25, 'TIER_1', 'TIER_1'); + + expect(mockHorizon.loadAccount).toHaveBeenCalledWith(mockWalletAddress); + }); + + test('should fund account via friendbot on testnet', async () => { + const { passkeyWallet } = require('../passkeyIntegration'); + + passkeyWallet.signTransaction.mockResolvedValue('mock-signature'); + passkeyWallet.submitTransactionDirectly.mockResolvedValue({ + hash: '0x1234567890abcdef', + }); + + // First call fails (account not found), second succeeds (after funding) + mockHorizon.loadAccount + .mockRejectedValueOnce(new Error('Account not found')) + .mockResolvedValueOnce({ sequence: '123456789' }); + + // Mock fetch for friendbot + global.fetch = jest.fn().mockResolvedValue({ + ok: true, + }); + + await client.setRiskTier(mockWalletAddress, 25, 'TIER_1', 'TIER_1'); + + expect(fetch).toHaveBeenCalledWith( + `https://friendbot.stellar.org?addr=${encodeURIComponent(mockWalletAddress)}` + ); + }); + }); + + describe('Error Handling', () => { + test('should handle validation errors in setRiskTier', async () => { + await expect( + client.setRiskTier('invalid', -10, 'INVALID', 'TIER_1') + ).rejects.toThrow(); + + expect(console.error).toHaveBeenCalledWith( + '❌ Failed to set risk tier:', + expect.any(Error) + ); + }); + + test('should handle validation errors in updateChosenTier', async () => { + await expect( + client.updateChosenTier('invalid', 'INVALID') + ).rejects.toThrow(); + }); + + test('should handle validation errors in canAccessTier', async () => { + await expect( + client.canAccessTier('invalid', 'INVALID') + ).rejects.toThrow(); + }); + }); +}); + +describe('useRiskTierContract Hook', () => { + beforeEach(() => { + jest.clearAllMocks(); + jest.spyOn(React, 'useState').mockImplementation((initial) => { + if (typeof initial === 'function') { + return [initial(), jest.fn()]; + } + return [initial, jest.fn()]; + }); + }); + + afterEach(() => { + jest.restoreAllMocks(); + }); + + test('should provide hook interface', () => { + const { result } = renderHook(() => useRiskTierContract()); + + expect(result.current).toHaveProperty('loading'); + expect(result.current).toHaveProperty('error'); + expect(result.current).toHaveProperty('setRiskTier'); + expect(result.current).toHaveProperty('getRiskTier'); + expect(result.current).toHaveProperty('canAccessTier'); + expect(result.current).toHaveProperty('updateChosenTier'); + expect(result.current).toHaveProperty('getTierStats'); + }); + + test('should handle loading states', async () => { + const { result } = renderHook(() => useRiskTierContract()); + + // Mock a slow operation + jest.spyOn(riskTierClient, 'getRiskTier').mockImplementation( + () => new Promise(resolve => setTimeout(() => resolve(null), 100)) + ); + + const promise = result.current.getRiskTier('GD5TEST'); + + expect(result.current.loading).toBe(true); + + await promise; + + expect(result.current.loading).toBe(false); + }); + + test('should handle errors', async () => { + const { result } = renderHook(() => useRiskTierContract()); + + jest.spyOn(riskTierClient, 'getRiskTier').mockRejectedValue( + new Error('Test error') + ); + + await result.current.getRiskTier('GD5TEST'); + + expect(result.current.error).toBe('Test error'); + expect(result.current.loading).toBe(false); + }); +}); + +describe('Singleton Instance', () => { + test('should export singleton client instance', () => { + expect(riskTierClient).toBeInstanceOf(RiskTierContractClient); + }); + + test('should reuse same instance', () => { + const client1 = riskTierClient; + const client2 = riskTierClient; + + expect(client1).toBe(client2); + }); +}); + +// Helper function for testing hooks +function renderHook(hook: () => T): { result: { current: T } } { + const result = { current: null as T }; + + // Simple hook renderer for testing + const React = require('react'); + + function TestComponent() { + result.current = hook(); + return null; + } + + // Mock React rendering + require('react').createElement(TestComponent); + + return { result }; +}