# Flalingo Test Suite Documentation

This directory contains comprehensive tests for the Flalingo language learning application's Rust backend.

## 🏗️ Test Structure

### Current Working Tests
```
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
```bash
# 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
```bash
cargo test
```

#### Run Specific Test Files
```bash
# Basic functionality tests
cargo test --test basic_tests

# Repository and advanced tests
cargo test --test simplified_repository_tests
```

#### Run Tests with Output
```bash
# 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)
```bash
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
```bash
# 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:
```bash
cargo test -- --test-threads=1
```

## 🛠️ Troubleshooting

### Common Issues

#### Database Lock Errors
```
Error: database is locked
```
**Solution**: Reduce parallel test threads or ensure proper cleanup
```bash
cargo test -- --test-threads=1
```

#### Missing Dependencies
```
Error: could not find dependency
```
**Solution**: Install development dependencies
```bash
cargo build --tests
```

#### File Permission Errors
```
Error: Permission denied
```
**Solution**: Check permissions on test directories
```bash
mkdir -p test_dbs && chmod 755 test_dbs
```

### Debug Mode
Enable detailed logging for debugging:
```bash
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
1. Choose the appropriate test file (`basic_tests.rs` or `simplified_repository_tests.rs`)
2. Follow the existing pattern:
```rust
#[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:
```rust
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.