Initial commit
This commit is contained in:
Zhongwei Li
436
commands/rust-test-add-integration.md
Normal file
436
commands/rust-test-add-integration.md
Normal file
@@ -0,0 +1,436 @@
|
||||
---
|
||||
description: Create integration tests in the tests/ directory
|
||||
---
|
||||
|
||||
You are helping create integration tests for a Rust project in the tests/ directory.
|
||||
|
||||
## Your Task
|
||||
|
||||
Set up integration test infrastructure and create comprehensive integration tests that test the public API.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Ask for Test Details**
|
||||
|
||||
Ask the user:
|
||||
- What feature/module to integration test?
|
||||
- Do you need database/HTTP mocking?
|
||||
- Should we use testcontainers for real databases?
|
||||
|
||||
2. **Create Integration Test File**
|
||||
|
||||
Create a new file in `tests/` directory:
|
||||
|
||||
```
|
||||
tests/
|
||||
├── [feature]_integration.rs
|
||||
└── common/
|
||||
└── mod.rs # Shared test utilities
|
||||
```
|
||||
|
||||
3. **Set Up Common Utilities**
|
||||
|
||||
Create `tests/common/mod.rs`:
|
||||
|
||||
```rust
|
||||
// tests/common/mod.rs
|
||||
#![allow(dead_code)]
|
||||
|
||||
use my_crate::*;
|
||||
|
||||
pub fn setup() {
|
||||
// Common setup logic
|
||||
}
|
||||
|
||||
pub fn teardown() {
|
||||
// Common cleanup logic
|
||||
}
|
||||
```
|
||||
|
||||
4. **Generate Integration Test**
|
||||
|
||||
Create the integration test file:
|
||||
|
||||
```rust
|
||||
// tests/[feature]_integration.rs
|
||||
use my_crate::*;
|
||||
|
||||
mod common;
|
||||
|
||||
#[test]
|
||||
fn test_[feature]_complete_workflow() {
|
||||
common::setup();
|
||||
|
||||
// Arrange
|
||||
let app = create_test_application();
|
||||
|
||||
// Act
|
||||
let result = app.execute_workflow();
|
||||
|
||||
// Assert
|
||||
assert!(result.is_ok());
|
||||
|
||||
common::teardown();
|
||||
}
|
||||
|
||||
fn create_test_application() -> Application {
|
||||
// Setup test instance with test configuration
|
||||
Application::new(test_config())
|
||||
}
|
||||
|
||||
fn test_config() -> Config {
|
||||
Config {
|
||||
database_url: "postgres://localhost/test_db".to_string(),
|
||||
// ... other test config
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
5. **Add Async Integration Tests**
|
||||
|
||||
For async applications:
|
||||
|
||||
```rust
|
||||
#[tokio::test]
|
||||
async fn test_async_integration() {
|
||||
let app = setup_test_app().await;
|
||||
|
||||
let result = app.process_request(test_request()).await;
|
||||
|
||||
assert!(result.is_ok());
|
||||
}
|
||||
|
||||
async fn setup_test_app() -> Application {
|
||||
Application::new(test_config()).await.unwrap()
|
||||
}
|
||||
```
|
||||
|
||||
6. **Add Database Integration Tests**
|
||||
|
||||
Using testcontainers:
|
||||
|
||||
```rust
|
||||
use testcontainers::{clients, images::postgres::Postgres};
|
||||
use sqlx::PgPool;
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_with_real_database() {
|
||||
let docker = clients::Cli::default();
|
||||
let postgres = docker.run(Postgres::default());
|
||||
|
||||
let connection_string = format!(
|
||||
"postgres://postgres@localhost:{}/postgres",
|
||||
postgres.get_host_port_ipv4(5432)
|
||||
);
|
||||
|
||||
let pool = PgPool::connect(&connection_string).await.unwrap();
|
||||
|
||||
// Run migrations
|
||||
sqlx::migrate!("./migrations")
|
||||
.run(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
// Now test with real database
|
||||
let repo = PostgresRepository::new(pool);
|
||||
let service = MyService::new(repo);
|
||||
|
||||
let result = service.create_item("test").await;
|
||||
|
||||
assert!(result.is_ok());
|
||||
}
|
||||
```
|
||||
|
||||
Or create a helper in common:
|
||||
|
||||
```rust
|
||||
// tests/common/mod.rs
|
||||
use sqlx::PgPool;
|
||||
use testcontainers::*;
|
||||
|
||||
pub async fn setup_test_database() -> PgPool {
|
||||
let docker = clients::Cli::default();
|
||||
let postgres = docker.run(images::postgres::Postgres::default());
|
||||
|
||||
let url = format!(
|
||||
"postgres://postgres@localhost:{}/postgres",
|
||||
postgres.get_host_port_ipv4(5432)
|
||||
);
|
||||
|
||||
let pool = PgPool::connect(&url).await.unwrap();
|
||||
sqlx::migrate!().run(&pool).await.unwrap();
|
||||
|
||||
pool
|
||||
}
|
||||
|
||||
// tests/database_integration.rs
|
||||
mod common;
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_repository() {
|
||||
let pool = common::setup_test_database().await;
|
||||
let repo = MyRepository::new(pool);
|
||||
|
||||
// Test repository operations
|
||||
}
|
||||
```
|
||||
|
||||
7. **Add HTTP API Integration Tests**
|
||||
|
||||
For testing HTTP APIs:
|
||||
|
||||
```rust
|
||||
use axum::body::Body;
|
||||
use axum::http::{Request, StatusCode};
|
||||
use tower::ServiceExt;
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_api_endpoint() {
|
||||
let app = create_test_app();
|
||||
|
||||
let response = app
|
||||
.oneshot(
|
||||
Request::builder()
|
||||
.uri("/api/users")
|
||||
.method("GET")
|
||||
.body(Body::empty())
|
||||
.unwrap(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
|
||||
let body = hyper::body::to_bytes(response.into_body())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let users: Vec<User> = serde_json::from_slice(&body).unwrap();
|
||||
assert!(!users.is_empty());
|
||||
}
|
||||
```
|
||||
|
||||
Or using reqwest for full HTTP testing:
|
||||
|
||||
```rust
|
||||
#[tokio::test]
|
||||
async fn test_api_full_request() {
|
||||
let server = spawn_test_server().await;
|
||||
|
||||
let client = reqwest::Client::new();
|
||||
let response = client
|
||||
.get(format!("{}/api/users", server.url()))
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(response.status(), 200);
|
||||
|
||||
let users: Vec<User> = response.json().await.unwrap();
|
||||
assert!(!users.is_empty());
|
||||
}
|
||||
|
||||
async fn spawn_test_server() -> TestServer {
|
||||
// Start server on random port for testing
|
||||
TestServer::spawn().await
|
||||
}
|
||||
```
|
||||
|
||||
8. **Add HTTP Mocking with wiremock**
|
||||
|
||||
For testing external API calls:
|
||||
|
||||
```rust
|
||||
use wiremock::{MockServer, Mock, ResponseTemplate};
|
||||
use wiremock::matchers::{method, path};
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_external_api_integration() {
|
||||
let mock_server = MockServer::start().await;
|
||||
|
||||
Mock::given(method("GET"))
|
||||
.and(path("/external/api"))
|
||||
.respond_with(ResponseTemplate::new(200).set_body_json(
|
||||
serde_json::json!({
|
||||
"status": "ok",
|
||||
"data": "test"
|
||||
})
|
||||
))
|
||||
.mount(&mock_server)
|
||||
.await;
|
||||
|
||||
let client = ExternalApiClient::new(&mock_server.uri());
|
||||
let result = client.fetch_data().await.unwrap();
|
||||
|
||||
assert_eq!(result.status, "ok");
|
||||
}
|
||||
```
|
||||
|
||||
9. **Add Multi-Step Workflow Tests**
|
||||
|
||||
Test complete user workflows:
|
||||
|
||||
```rust
|
||||
#[tokio::test]
|
||||
async fn test_complete_user_workflow() {
|
||||
let app = setup_test_app().await;
|
||||
|
||||
// Step 1: Create user
|
||||
let user_id = app
|
||||
.create_user("test@example.com")
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
// Step 2: Retrieve user
|
||||
let user = app
|
||||
.get_user(&user_id)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(user.email, "test@example.com");
|
||||
|
||||
// Step 3: Update user
|
||||
app.update_user(&user_id, "new@example.com")
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
// Step 4: Verify update
|
||||
let updated = app
|
||||
.get_user(&user_id)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(updated.email, "new@example.com");
|
||||
|
||||
// Step 5: Delete user
|
||||
app.delete_user(&user_id)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
// Step 6: Verify deletion
|
||||
let result = app.get_user(&user_id).await;
|
||||
assert!(result.is_err());
|
||||
}
|
||||
```
|
||||
|
||||
10. **Update Dev Dependencies**
|
||||
|
||||
Ensure required dependencies are in Cargo.toml:
|
||||
|
||||
```toml
|
||||
[dev-dependencies]
|
||||
tokio = { version = "1", features = ["full", "test-util"] }
|
||||
testcontainers = "0.15"
|
||||
wiremock = "0.6"
|
||||
reqwest = { version = "0.11", features = ["json"] }
|
||||
```
|
||||
|
||||
11. **Provide Summary**
|
||||
|
||||
```
|
||||
✅ Integration tests created successfully!
|
||||
|
||||
## Files Created:
|
||||
- `tests/[feature]_integration.rs` - Main integration test file
|
||||
- `tests/common/mod.rs` - Shared test utilities
|
||||
|
||||
## Tests Added:
|
||||
- test_[feature]_complete_workflow
|
||||
- test_database_operations
|
||||
- test_api_endpoints
|
||||
- test_external_api_integration
|
||||
|
||||
## Infrastructure:
|
||||
- Database test setup with testcontainers
|
||||
- HTTP mocking with wiremock
|
||||
- Test configuration helpers
|
||||
|
||||
## Dependencies Added:
|
||||
[List of dev dependencies]
|
||||
|
||||
## Running Integration Tests:
|
||||
|
||||
```bash
|
||||
# Run all integration tests
|
||||
cargo test --test [feature]_integration
|
||||
|
||||
# Run specific test
|
||||
cargo test test_complete_workflow
|
||||
|
||||
# Run with output
|
||||
cargo test --test [feature]_integration -- --nocapture
|
||||
|
||||
# Run all integration tests
|
||||
cargo test --tests
|
||||
```
|
||||
|
||||
## Next Steps:
|
||||
1. Review and customize test cases
|
||||
2. Add more workflow scenarios
|
||||
3. Run tests: `cargo test --tests`
|
||||
4. Check if you need more test infrastructure
|
||||
```
|
||||
|
||||
## Integration Test Patterns
|
||||
|
||||
### Setup/Teardown Pattern
|
||||
```rust
|
||||
struct TestContext {
|
||||
pool: PgPool,
|
||||
// Other resources
|
||||
}
|
||||
|
||||
impl TestContext {
|
||||
async fn new() -> Self {
|
||||
// Setup
|
||||
Self {
|
||||
pool: setup_database().await,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for TestContext {
|
||||
fn drop(&mut self) {
|
||||
// Cleanup
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_with_context() {
|
||||
let ctx = TestContext::new().await;
|
||||
// Use ctx.pool
|
||||
}
|
||||
```
|
||||
|
||||
### Parallel Test Isolation
|
||||
```rust
|
||||
#[tokio::test]
|
||||
async fn test_isolated_1() {
|
||||
let db = create_unique_test_db("test1").await;
|
||||
// Each test gets its own database
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_isolated_2() {
|
||||
let db = create_unique_test_db("test2").await;
|
||||
// Runs in parallel without interference
|
||||
}
|
||||
```
|
||||
|
||||
## Important Notes
|
||||
|
||||
- Integration tests are in separate crates from src/
|
||||
- Each file in tests/ is a separate binary
|
||||
- Common code goes in tests/common/ (not tests/common.rs)
|
||||
- Use real implementations when possible
|
||||
- Mock external services
|
||||
- Clean up resources after tests
|
||||
- Tests should be independent and runnable in any order
|
||||
|
||||
## After Completion
|
||||
|
||||
Ask the user:
|
||||
1. Did the integration tests pass?
|
||||
2. Do you need more test scenarios?
|
||||
3. Should we add performance/load tests?
|
||||
4. Do you want to set up CI/CD for these tests?
|
||||
Reference in New Issue
Block a user