Testing Guide - MetaVault AI

Learn more about Mintlify

Enter your email to receive updates about new features and product releases.

Overview
Test Structure
Smart Contract Testing
Running Contract Tests
Test Configuration
Writing Contract Tests
Test Coverage
Testing with Mock Contracts
AI Agent Testing
Manual Agent Testing
Automated Agent Testing
Frontend Testing
Manual Frontend Testing
Linting and Type Checking
Integration Testing
End-to-End Test Scenario
Performance Testing
Gas Usage Analysis
Load Testing Agents
Debugging Tests
Hardhat Console
Agent Debug Logs
Frontend DevTools
Test Checklist
Continuous Integration
Common Issues
Best Practices
Next Steps

Overview

MetaVault AI includes comprehensive testing for smart contracts and provides guidelines for testing AI agents and frontend functionality.

Testing ensures the vault operates correctly and safely manages user funds. Always run tests before deploying to production.

Test Structure

The project includes tests at different levels:

Contract Tests

Unit and integration tests for smart contracts using Hardhat and Chai

Agent Testing

Manual and automated testing of AI agent behaviors

Integration Tests

End-to-end tests covering the full stack

Smart Contract Testing

Running Contract Tests

Navigate to the contracts package and run the test suite:

pnpm contracts:test

Test Configuration

The Hardhat configuration includes:

hardhat.config.ts

const config: HardhatUserConfig = {
  solidity: {
    version: "0.8.28",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200,
      },
      viaIR: true
    }
  },
  networks: {
    hardhat: {
      forking: {
        url: `https://sepolia.infura.io/v3/${process.env.INFURA_KEY}`,
      }
    }
  }
};

Tests run on a local Hardhat network that can fork Sepolia testnet for realistic testing conditions.

Writing Contract Tests

Contract tests are located in packages/contracts/test/ and use the following structure:

import { expect } from "chai";
import { ethers } from "hardhat";
import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";

describe("MetaVault", function () {
  async function deployVaultFixture() {
    const [owner, user1] = await ethers.getSigners();
    
    // Deploy contracts
    const Vault = await ethers.getContractFactory("MetaVault");
    const vault = await Vault.deploy();
    
    return { vault, owner, user1 };
  }

  it("Should allow deposits", async function () {
    const { vault, user1 } = await loadFixture(deployVaultFixture);
    // Test logic
  });
});

Test Coverage

Generate a coverage report:

cd packages/contracts
pnpm hardhat coverage

This creates a detailed coverage report showing:

Line coverage
Branch coverage
Function coverage
Statement coverage

Aim for at least 80% coverage on critical contract functionality like deposits, withdrawals, and strategy management.

Testing with Mock Contracts

MetaVault AI uses mock contracts to simulate DeFi protocols:

Deploy Mock Contracts

Deploy the complete mock environment:

pnpm contracts:deploy:local

This deploys:

Mock LINK and WETH tokens
Mock Aave Pool (simulates lending)
Mock Swap Router (simulates Uniswap)
MetaVault and strategies

Run Testing Script

Use the testing script to simulate various scenarios:

cd packages/contracts
pnpm hardhat run scripts/testing.ts --network localhost

This script can:

Simulate deposits and withdrawals
Test strategy allocations
Trigger yield accrual
Test emergency scenarios

Verify Results

Check the console output for:

Transaction confirmations
Balance changes
Strategy performance
Gas usage estimates

AI Agent Testing

Test the AI agents to ensure they manage the vault correctly:

Manual Agent Testing

Start Test Environment

Ensure all services are running:

# Terminal 1: Blockchain
pnpm dev:contracts

# Terminal 2: Deploy contracts
pnpm contracts:deploy:local

# Terminal 3: Agents
pnpm dev:agents

Test Strategy Sentinel

The Strategy Sentinel Agent monitors vault health. Test by:

Checking initial strategy state
Simulating market volatility (adjust mock prices)
Observing agent responses
Verifying rebalancing actions

Monitor agent logs for decisions:

🛡️ Strategy Sentinel: Checking vault health...
📊 LTV Ratio: 65%
⚠️  High volatility detected
🔄 Rebalancing portfolio...
✅ Rebalance complete

Test Chat Agent

Test the user-facing chat agent:

# Send test request to chat endpoint
curl -X POST http://localhost:3002/chat \
  -H "Content-Type: application/json" \
  -d '{
    "message": "What is my vault balance?",
    "userAddress": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
  }'

Test various queries:

Balance inquiries
Deposit/withdrawal requests
Strategy information
Market conditions

Test Yield Simulator

Simulate yield generation:

# Call yield simulator endpoint
curl -X POST http://localhost:3001/simulate-yield \
  -H "Content-Type: application/json" \
  -d '{
    "amount": "1000",
    "duration": "30"
  }'

Automated Agent Testing

Test automation capabilities:

cd packages/agents/defi-portfolio
pnpm run automate:cron

The automation will:

Run every 5 minutes (configurable)
Monitor strategy health
Check liquidation risks
Perform rebalancing if needed
Harvest and compound yields

Automated testing should only run on test networks. Never run automation on mainnet without thorough testing.

Frontend Testing

Manual Frontend Testing

Start Development Server

cd packages/frontend
pnpm dev

Access at http://localhost:3000

Test Wallet Connection

Connect MetaMask to localhost network
Import test account from Hardhat
Connect wallet through UI
Verify account displays correctly

Test Core Functions

Test the main user flows:Deposit Flow:

Navigate to deposit interface
Enter amount to deposit
Approve token spending (if needed)
Confirm deposit transaction
Verify balance updates

Withdrawal Flow:

Navigate to withdrawal interface
Enter amount to withdraw
Confirm withdrawal transaction
Verify balance updates

Chat Interface:

Open chat widget
Send test messages
Verify AI responses
Test different query types

Test Strategy Display

Verify strategy information displays correctly:

Strategy names and descriptions
Current allocations
APY/returns
Risk levels
Historical performance

Linting and Type Checking

Run code quality checks:

cd packages/frontend

# Run ESLint
pnpm lint

# Type check with TypeScript
pnpm tsc --noEmit

Integration Testing

Test the complete system working together:

End-to-End Test Scenario

Setup

Start all services:

pnpm dev:all

Deploy contracts and update environment variables.

User Deposit

Connect wallet to frontend
Approve LINK token spending
Deposit 1000 LINK tokens
Verify:
- Transaction confirms
- Vault balance increases
- User receives vault shares
- Frontend updates balance

Strategy Allocation

Check initial strategy allocations
Verify funds distributed correctly
Monitor agent logs for allocation decisions
Confirm strategies receive funds

Yield Generation

Wait for yield to accrue (or simulate)
Check updated vault value
Verify yield calculation
Test harvest functionality

Agent Actions

Trigger agent automation
Monitor rebalancing decisions
Verify risk management
Check strategy adjustments

User Withdrawal

Request withdrawal through frontend
Verify:
- Transaction confirms
- Correct amount withdrawn
- Vault shares burned
- Strategies unwind if needed
- User receives tokens

Performance Testing

Test system performance and gas usage:

Gas Usage Analysis

cd packages/contracts
pnpm hardhat test --gas-report

This generates a gas report showing:

Gas per function call
Average gas costs
Deployment costs

Optimize functions with high gas usage. The Solidity optimizer is enabled with 200 runs, balancing deployment and execution costs.

Load Testing Agents

Test agent performance under load:

# Send multiple concurrent requests
for i in {1..10}; do
  curl -X POST http://localhost:3002/chat \
    -H "Content-Type: application/json" \
    -d '{"message": "What is the vault TVL?"}' &
done
wait

Monitor:

Response times
Memory usage
CPU utilization
Error rates

Debugging Tests

Hardhat Console

Debug contracts interactively:

cd packages/contracts
pnpm hardhat console --network localhost

// Example: Check vault state
const Vault = await ethers.getContractFactory("MetaVault");
const vault = await Vault.attach("0x...");
const balance = await vault.totalAssets();
console.log("Total assets:", balance.toString());

Agent Debug Logs

Enable detailed logging:

# In packages/agents/defi-portfolio/.env
ADK_DEBUG="true"

Logs will show:

Tool invocations
Agent decisions
State changes
Error traces

Frontend DevTools

Use browser developer tools:

Console for errors and warnings
Network tab for API calls
React DevTools for component state
MetaMask for transaction details

Test Checklist

Before deploying or major changes:

Contract Tests

Agent Tests

Strategy Sentinel monitors correctly
Chat Agent responds appropriately
Yield Simulator generates accurate projections
Automation runs without errors
Error handling works

Frontend Tests

Integration Tests

Full deposit-to-withdrawal flow works
Agents interact with contracts correctly
Frontend displays accurate data
Error states handled gracefully
Multi-user scenarios work

Continuous Integration

Set up CI/CD for automated testing:

.github/workflows/test.yml

name: Test Suite

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: pnpm/action-setup@v2
      - uses: actions/setup-node@v3
        with:
          node-version: 18
          cache: 'pnpm'
      
      - run: pnpm install
      - run: pnpm contracts:test
      - run: pnpm build:frontend
      - run: pnpm build:agents

Common Issues

Tests failing after contract changes

Recompile contracts and regenerate types:

cd packages/contracts
pnpm hardhat clean
pnpm hardhat compile

Agent tests timing out

Ensure:

Contracts are deployed
RPC URL is correct
OpenRouter API key is valid
Increase timeout in test config

Frontend tests fail on CI

Common causes:

Missing environment variables
Node version mismatch
Cache issues

Use consistent Node.js version and clear cache:

pnpm store prune

Gas usage too high

Optimize contracts:

Use memory instead of storage where possible
Batch operations
Optimize loops
Use events instead of storage for historical data

Best Practices

Test Isolation

Each test should be independent and not rely on previous test state

Clear Assertions

Use descriptive test names and clear assertion messages

Test Edge Cases

Test boundary conditions, zero values, and error states

Mock External Calls

Use mocks for external protocols to ensure consistent test results

Next Steps

Architecture

Understand the system architecture

Smart Contracts

Learn about the smart contract design

Running Locally

Vault Contract

⌘I

Build docs developers (and LLMs) love

Get started for free Talk to us

Setup

Smart Contracts

Frontend

AI Agents

​Overview

​Test Structure

Contract Tests

Agent Testing

Integration Tests

​Smart Contract Testing

​Running Contract Tests

​Test Configuration

​Writing Contract Tests

​Test Coverage

​Testing with Mock Contracts

​AI Agent Testing

​Manual Agent Testing

​Automated Agent Testing

​Frontend Testing

​Manual Frontend Testing

​Linting and Type Checking

​Integration Testing

​End-to-End Test Scenario

​Performance Testing

​Gas Usage Analysis

​Load Testing Agents

​Debugging Tests

​Hardhat Console

​Agent Debug Logs

​Frontend DevTools

​Test Checklist

​Continuous Integration

​Common Issues

​Best Practices

Test Isolation

Clear Assertions

Test Edge Cases

Mock External Calls

​Next Steps

Architecture

Smart Contracts

Build docs developers (and LLMs) love

Overview

Test Structure

Smart Contract Testing

Running Contract Tests

Test Configuration

Writing Contract Tests

Test Coverage

Testing with Mock Contracts

AI Agent Testing

Manual Agent Testing

Automated Agent Testing

Frontend Testing

Manual Frontend Testing

Linting and Type Checking

Integration Testing

End-to-End Test Scenario

Performance Testing

Gas Usage Analysis

Load Testing Agents

Debugging Tests

Hardhat Console

Agent Debug Logs

Frontend DevTools

Test Checklist

Continuous Integration

Common Issues

Best Practices

Next Steps