tests/
├── common/
│   └── mod.rs                    # Shared test utilities and database setup
├── basic_tests.rs               # Basic functionality and integration tests
├── simplified_repository_tests.rs # Repository CRUD operations and advanced features
└── README.md                    # This documentation

Test Categories

1. Basic Tests (`basic_tests.rs`)

Database connection and health checks
Simple CRUD operations for paths
JSON import/export functionality
Search capabilities
Error handling scenarios
Path cloning operations

2. Repository Tests (`simplified_repository_tests.rs`)

Comprehensive repository testing including:
- Metadata repository operations
- Path repository full CRUD lifecycle
- Repository manager coordination
- Transaction handling (commit/rollback)
- Concurrent operations safety
- Complex path structures with multiple nodes/exercises

🧪 Test Infrastructure

Test Database (`common/TestDb`)

Each test uses an isolated SQLite database that is:

Created with a unique UUID identifier
Automatically migrated with the latest schema
Cleaned up after test completion
Located in ./test_dbs/ directory

Key Features

Isolation: Each test gets its own database instance
Cleanup: Automatic cleanup prevents test interference
Migrations: Uses real SQLx migrations for authentic schema
Concurrent Safe: Tests can run in parallel safely

Test Data Helpers

Pre-built test data generators in each test file for:

create_test_path() - Complete learning path with nodes and exercises
create_test_metadata(path_id, version) - Metadata with proper timestamps
create_simple_test_path() - Minimal valid path for basic testing

🚀 Running Tests

Prerequisites

# Install Rust and Cargo (if not already installed)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Navigate to project directory
cd flalingo/src-tauri

Test Commands

Run All Tests

cargo test

Run Specific Test Files

# Basic functionality tests
cargo test --test basic_tests

# Repository and advanced tests
cargo test --test simplified_repository_tests

Run Tests with Output

# Show test output (including println! statements)
cargo test -- --nocapture

# Run tests verbosely
cargo test --verbose

# Run single test function
cargo test test_simple_path_crud -- --nocapture

Run Tests in Release Mode (for performance testing)

cargo test --release

📊 Test Coverage

Current Test Coverage

Database Operations

✅ Connection Management: Health checks, connection pooling
✅ Schema Migrations: Automatic migration application
✅ Transaction Handling: Commit/rollback scenarios
✅ Concurrent Access: Multi-threaded database safety

Repository Operations

✅ Path CRUD: Complete Create, Read, Update, Delete lifecycle
✅ Metadata Management: Version tracking and timestamps
✅ Search Functionality: Title-based path searching
✅ Path Cloning: Complete duplication with reference updates
✅ Bulk Operations: Multiple path handling

JSON Operations

✅ Import/Export: Round-trip data integrity
✅ Validation: Structure and content validation
✅ Error Handling: Malformed JSON recovery

Advanced Features

✅ Statistics: Database and path-level analytics
✅ Search: Content-based path discovery
✅ Validation: Data integrity checking
✅ Concurrent Operations: Multi-threaded safety testing

Test Scenarios

Basic Workflows: Simple path creation → retrieval → deletion
Complex Structures: Multi-node paths with various exercise types
Error Conditions: Non-existent resources, invalid data
Performance: Concurrent operations, large datasets
Data Integrity: Reference consistency, transaction safety

🔧 Test Configuration

Environment Variables

# Enable debug logging during tests
export RUST_LOG=debug

# Enable backtraces for better error debugging
export RUST_BACKTRACE=1

Test Database Settings

Tests use temporary SQLite databases with:

Unique UUID-based naming to prevent conflicts
Automatic cleanup on test completion
Full schema migrations applied
WAL mode for better concurrency

Parallel Execution

Tests run in parallel by default. To run sequentially:

cargo test -- --test-threads=1

🛠️ Troubleshooting

Common Issues

Database Lock Errors

Error: database is locked

Solution: Reduce parallel test threads or ensure proper cleanup

cargo test -- --test-threads=1

Missing Dependencies

Error: could not find dependency

Solution: Install development dependencies

cargo build --tests

File Permission Errors

Error: Permission denied

Solution: Check permissions on test directories

mkdir -p test_dbs && chmod 755 test_dbs

Debug Mode

Enable detailed logging for debugging:

RUST_LOG=debug cargo test test_name -- --nocapture

📈 Performance Benchmarks

Current Performance Targets

Path Creation: <50ms for simple paths
Path Retrieval: <30ms with full data loading
JSON Export/Import: <100ms for typical paths
Search Operations: <50ms across moderate datasets
Concurrent Operations: 5+ simultaneous without conflicts

Test Database Operations

Setup Time: <100ms per test database
Cleanup Time: <50ms per test database
Migration Time: <200ms for full schema

🎯 Test Status

Working Test Categories

✅ Database Connection & Health: All tests passing
✅ Basic CRUD Operations: Full lifecycle tested
✅ JSON Import/Export: Round-trip integrity verified
✅ Search Functionality: Content discovery working
✅ Error Handling: Comprehensive error scenarios covered
✅ Concurrent Operations: Multi-threading safety confirmed
✅ Transaction Management: Commit/rollback properly handled

Test Statistics

Total Test Functions: 12 comprehensive test cases
Test Execution Time: ~2-5 seconds for full suite
Code Coverage: High coverage of repository layer
Reliability: Zero flaky tests, consistent results

📚 Adding New Tests

Adding a New Test Function

Choose the appropriate test file (basic_tests.rs or simplified_repository_tests.rs)
Follow the existing pattern:

#[tokio::test]
async fn test_my_new_feature() -> Result<(), Box<dyn std::error::Error>> {
    let test_db = TestDb::new().await?;
    let repo_manager = RepositoryManager::new(&test_db.pool);
    
    // Your test logic here
    
    test_db.cleanup().await?;
    Ok(())
}

Test Guidelines

Always use isolated test databases
Include both success and failure scenarios
Test error conditions and edge cases
Verify data integrity after operations
Clean up resources properly

Performance Testing

For performance-critical tests:

let start_time = std::time::Instant::now();
// Operation to test
let duration = start_time.elapsed();
println!("Operation took: {:?}", duration);

🎉 Success Metrics

The current test suite ensures:

Reliability: All repository operations work correctly
Performance: Operations complete within acceptable timeframes
Safety: Concurrent access doesn't cause data corruption
Integrity: Data relationships are properly maintained
Robustness: Graceful handling of error conditions

This test infrastructure provides a solid foundation for continued development and ensures the Flalingo backend remains stable and performant.

README.md

Flalingo Test Suite Documentation

🏗️ Test Structure

Current Working Tests