asle/TESTING.md

ASLE Testing Guide

Overview

This document outlines the testing strategy and test structure for the ASLE project.

Smart Contract Testing

Foundry Tests

All smart contract tests are written in Solidity using Foundry.

Location: contracts/test/

Running Tests

cd contracts
forge test                    # Run all tests
forge test -vvv              # Verbose output
forge test --match-path test/LiquidityFacet.t.sol  # Specific test file
forge test --match-test testCreatePool  # Specific test

Test Coverage

Run coverage:

forge coverage

Test Files Structure

• Diamond.t.sol - Diamond deployment and facet management
• LiquidityFacet.t.sol - PMM pool creation and operations
• VaultFacet.t.sol - ERC-4626 and ERC-1155 vault tests
• ComplianceFacet.t.sol - Compliance mode and KYC/AML tests
• CCIPFacet.t.sol - Cross-chain messaging tests
• GovernanceFacet.t.sol - Proposal and voting tests
• SecurityFacet.t.sol - Pause and circuit breaker tests
• RWAFacet.t.sol - RWA tokenization tests
• Integration.t.sol - Multi-facet interaction tests
• mocks/ - Mock contracts for testing

Writing Tests

Example test structure:

contract MyFacetTest is Test {
    Diamond public diamond;
    MyFacet public facet;
    
    function setUp() public {
        // Setup diamond and facets
    }
    
    function testMyFunction() public {
        // Test implementation
        assertEq(result, expected);
    }
}

Backend Testing

Unit Tests

Location: backend/src/__tests__/

Run tests:

cd backend
npm test
npm test -- --coverage

Test Structure

• services/ - Service unit tests
• api/ - API route tests
• middleware/ - Middleware tests
• utils/ - Utility function tests

Example Test

import { ComplianceService } from '../services/compliance';

describe('ComplianceService', () => {
  it('should verify KYC', async () => {
    const service = new ComplianceService(provider, diamondAddress);
    const result = await service.verifyKYC(userAddress);
    expect(result.verified).toBe(true);
  });
});

Integration Tests

Test API endpoints:

npm run test:integration

Frontend Testing

Component Tests

Location: frontend/__tests__/

Run tests:

cd frontend
npm test
npm test -- --coverage

Testing Stack

• Jest for unit tests
• React Testing Library for component tests
• Playwright for E2E tests

Example Component Test

import { render, screen } from '@testing-library/react';
import { PoolCreator } from '../components/PoolCreator';

describe('PoolCreator', () => {
  it('renders form fields', () => {
    render(<PoolCreator />);
    expect(screen.getByLabelText('Base Token Address')).toBeInTheDocument();
  });
});

E2E Tests

Run E2E tests:

npm run test:e2e

E2E tests cover complete user workflows:

• Wallet connection
• Pool creation
• Vault deposit
• Governance voting

Test Data

Mock Data

• Contract mocks in contracts/test/mocks/
• API mocks in backend/src/__tests__/mocks/
• Frontend mocks in frontend/__tests__/mocks/

Fixtures

Test fixtures and sample data are organized by domain:

• Pool fixtures
• Vault fixtures
• Compliance fixtures
• Transaction fixtures

Continuous Integration

All tests run automatically on:

• Pull requests
• Pushes to main/develop branches
• Scheduled daily runs

See .github/workflows/ci.yml for CI configuration.

Test Coverage Goals

• Smart Contracts: >90%
• Backend Services: >80%
• Backend API: >70%
• Frontend Components: >70%
• E2E: Critical paths 100%

Debugging Tests

Foundry

forge test --debug testMyFunction
forge test -vvvv  # Maximum verbosity

Backend

npm test -- --verbose
npm test -- --grep "pattern"

Frontend

npm test -- --verbose
npm test -- --watch

Performance Testing

Load testing for API:

cd backend
npm run test:load

Contract gas optimization tests:

cd contracts
forge snapshot

Security Testing

Run security checks:

# Smart contracts
cd contracts
slither .  # If installed

# Dependencies
npm audit

Best Practices

1. Isolation: Each test should be independent
2. Cleanup: Reset state between tests
3. Naming: Clear, descriptive test names
4. Coverage: Aim for high coverage but focus on critical paths
5. Speed: Keep tests fast, use mocks where appropriate
6. Maintainability: Keep tests simple and readable