Contributing Guide

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_user_creation() {
        let user = UserData::new("test_user".to_string());
        assert_eq!(user.user_id, "test_user");
        assert!(user.created_at <= Utc::now());
    }

    #[tokio::test]
    async fn test_authentication_success() {
        let mock_data = create_mock_biometric_data();
        let context = create_test_context();

        let result = authenticate_user(&mock_data, &context).await;

        assert!(result.is_ok());
        assert!(result.unwrap().success);
    }
}

// tests/integration_test.rs
use boop_network::prelude::*;

#[tokio::test]
async fn test_full_authentication_flow() {
    // Start test services
    let test_env = TestEnvironment::new().await;

    // Register a user
    let user_id = test_env.register_user("test_user").await?;

    // Simulate authentication
    let auth_request = AuthRequest {
        user_id,
        context_type: ContextType::Payment { amount: 1000 },
        attributes: vec!["email".to_string()],
    };

    let result = test_env.authenticate(auth_request).await?;

    assert!(result.success);
    assert_eq!(result.attributes.len(), 1);

    test_env.cleanup().await;
}

# Run tests with coverage
cargo tarpaulin --out Html --output-dir coverage

# Requirements:
# - Unit tests: > 80% coverage
# - Integration tests for all public APIs
# - Error case testing
# - Performance regression tests

# Make requested changes
git add .
git commit -m "fix: address review feedback"
git push origin feature/your-branch

# If you need to squash commits before merge:
git rebase -i HEAD~3  # Interactive rebase for last 3 commits
git push --force-with-lease origin feature/your-branch

use serde::{Deserialize, Serialize};
use validator::{Validate, ValidationError};

#[derive(Debug, Deserialize, Validate)]
pub struct CreateUserRequest {
    #[validate(length(min = 1, max = 255))]
    pub user_id: String,

    #[validate(email)]
    pub email: Option<String>,

    #[validate(custom = "validate_biometric_data")]
    pub biometric_data: Vec<u8>,
}

fn validate_biometric_data(data: &[u8]) -> Result<(), ValidationError> {
    if data.is_empty() || data.len() > 10_000 {
        return Err(ValidationError::new("invalid_biometric_data"));
    }
    Ok(())
}

// Use prepared statements and connection pooling
pub struct DatabasePool {
    pool: sqlx::PgPool,
}

impl DatabasePool {
    pub async fn get_user(&self, user_id: &str) -> Result<User, DatabaseError> {
        let user = sqlx::query_as!(
            User,
            "SELECT * FROM users WHERE user_id = $1",
            user_id
        )
        .fetch_optional(&self.pool)
        .await?;

        user.ok_or(DatabaseError::UserNotFound)
    }
}

// Index frequently queried columns
// CREATE INDEX idx_users_user_id ON users(user_id);
// CREATE INDEX idx_auth_requests_created_at ON auth_requests(created_at);

use tokio::time::{timeout, Duration};

// Use timeouts for external calls
pub async fn call_external_service() -> Result<Response, ServiceError> {
    let future = external_service_call();

    match timeout(Duration::from_secs(30), future).await {
        Ok(result) => result,
        Err(_) => Err(ServiceError::Timeout),
    }
}

// Batch database operations when possible
pub async fn batch_insert_users(&self, users: Vec<User>) -> Result<(), DatabaseError> {
    let mut tx = self.pool.begin().await?;

    for user in users {
        sqlx::query!("INSERT INTO users (user_id, email) VALUES ($1, $2)")
            .bind(&user.user_id)
            .bind(&user.email)
            .execute(&mut *tx)
            .await?;
    }

    tx.commit().await?;
    Ok(())
}