gh-emillindfors-claude-marketplace-plugins-rust-testing/commands/rust-test-add-unit.md

---
description: Add comprehensive unit tests for a function or module
---

You are helping add unit tests to Rust code following best practices.

## Your Task

Generate comprehensive unit tests for the specified function or module, covering success cases, error cases, and edge cases.

## Steps

1. **Identify Target**

   Ask the user (if not specified):
   - What function/struct/module to test?
   - Where is it located?

   Or scan the current file for testable functions.

2. **Analyze Function**

   Read the function to understand:
   - What it does
   - What inputs it takes
   - What it returns (including error types)
   - What edge cases exist

3. **Create Test Module**

   Add or update the `#[cfg(test)]` module at the bottom of the file:

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

       // Tests go here
   }
   ```

4. **Generate Test Cases**

   For each function, create tests for:

   **Success Cases**:
   ```rust
   #[test]
   fn test_[function]_with_valid_input() {
       // Arrange
       let input = create_valid_input();

       // Act
       let result = function(input);

       // Assert
       assert!(result.is_ok());
       assert_eq!(result.unwrap(), expected_value);
   }
   ```

   **Error Cases**:
   ```rust
   #[test]
   fn test_[function]_returns_error_on_invalid_input() {
       let result = function(invalid_input);

       assert!(result.is_err());
       assert!(matches!(result.unwrap_err(), ErrorType::Specific));
   }
   ```

   **Edge Cases**:
   ```rust
   #[test]
   fn test_[function]_with_empty_input() {
       let result = function("");
       assert!(result.is_err());
   }

   #[test]
   fn test_[function]_with_max_length_input() {
       let long_input = "x".repeat(MAX_LENGTH);
       let result = function(&long_input);
       assert!(result.is_ok());
   }
   ```

5. **Add Test Fixtures**

   Create helper functions for common test data:

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

       fn create_test_user() -> User {
           User {
               id: "test-id".to_string(),
               email: "test@example.com".to_string(),
           }
       }

       fn create_test_user_with_id(id: &str) -> User {
           User {
               id: id.to_string(),
               email: "test@example.com".to_string(),
           }
       }

       #[test]
       fn test_with_fixture() {
           let user = create_test_user();
           let result = validate_user(&user);
           assert!(result.is_ok());
       }
   }
   ```

6. **Add Async Tests if Needed**

   For async functions:

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

       #[tokio::test]
       async fn test_async_function() {
           let result = async_function().await;
           assert!(result.is_ok());
       }

       #[tokio::test]
       async fn test_async_error_case() {
           let result = async_function_with_error().await;
           assert!(result.is_err());
       }
   }
   ```

7. **Add Mock Implementations**

   For functions using traits:

   ```rust
   #[cfg(test)]
   mod tests {
       use super::*;
       use std::collections::HashMap;

       struct MockRepository {
           data: HashMap<String, User>,
       }

       impl MockRepository {
           fn new() -> Self {
               Self { data: HashMap::new() }
           }

           fn with_user(mut self, user: User) -> Self {
               self.data.insert(user.id.clone(), user);
               self
           }
       }

       #[async_trait]
       impl UserRepository for MockRepository {
           async fn find_by_id(&self, id: &str) -> Result<User, Error> {
               self.data.get(id)
                   .cloned()
                   .ok_or(Error::NotFound(id.to_string()))
           }
       }

       #[tokio::test]
       async fn test_service_with_mock() {
           let mock = MockRepository::new()
               .with_user(create_test_user());

           let service = UserService::new(mock);
           let user = service.get_user("test-id").await.unwrap();

           assert_eq!(user.email, "test@example.com");
       }
   }
   ```

8. **Add Table-Driven Tests**

   For multiple similar test cases:

   ```rust
   #[test]
   fn test_validation_cases() {
       let test_cases = vec![
           ("", false, "Empty input"),
           ("a", true, "Single char"),
           ("abc", true, "Valid input"),
           ("x".repeat(1000).as_str(), false, "Too long"),
       ];

       for (input, should_pass, description) in test_cases {
           let result = validate(input);
           assert_eq!(
               result.is_ok(),
               should_pass,
               "Failed for case: {}",
               description
           );
       }
   }
   ```

9. **Provide Test Summary**

   After generating tests:

   ```
   ✅ Unit tests added successfully!

   ## Tests Created:

   ### Success Cases (3):
   - test_create_user_with_valid_email
   - test_update_user_success
   - test_delete_user_success

   ### Error Cases (4):
   - test_create_user_with_empty_email
   - test_create_user_with_invalid_email
   - test_update_nonexistent_user
   - test_delete_nonexistent_user

   ### Edge Cases (2):
   - test_email_max_length
   - test_special_characters_in_email

   ## Test Fixtures:
   - create_test_user()
   - create_test_user_with_email(email)

   ## Mock Implementations:
   - MockUserRepository

   ## Run Tests:
   ```bash
   cargo test
   cargo test --package [package_name]
   cargo test test_create_user -- --nocapture
   ```

   ## Next Steps:
   1. Review generated tests
   2. Add more edge cases if needed
   3. Run tests and verify they pass
   4. Check coverage with cargo tarpaulin
   ```

## Test Naming Conventions

Use descriptive names following this pattern:
- `test_[function]_[scenario]_[expected_result]`

Examples:
- `test_create_user_with_valid_email_succeeds`
- `test_create_user_with_empty_email_returns_validation_error`
- `test_parse_config_with_invalid_json_returns_parse_error`

## Important Patterns

### Testing Result Types
```rust
#[test]
fn test_returns_ok() {
    let result = function();
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), expected);
}

#[test]
fn test_returns_specific_error() {
    let result = function();
    assert!(result.is_err());

    match result {
        Err(MyError::Specific) => (),  // Expected
        _ => panic!("Wrong error type"),
    }
}
```

### Testing Option Types
```rust
#[test]
fn test_returns_some() {
    let result = function();
    assert!(result.is_some());
    assert_eq!(result.unwrap(), expected);
}

#[test]
fn test_returns_none() {
    let result = function();
    assert!(result.is_none());
}
```

### Testing Panics
```rust
#[test]
#[should_panic(expected = "expected panic message")]
fn test_panics_on_invalid_input() {
    function_that_panics();
}
```

### Testing with assert_matches
```rust
use assert_matches::assert_matches;

#[test]
fn test_error_variant() {
    let result = function();
    assert_matches!(result, Err(Error::Specific { .. }));
}
```

## After Completion

Ask the user:
1. Do tests pass? (run `cargo test`)
2. Are there more scenarios to test?
3. Should we add integration tests?
4. Do you want to check test coverage?