testing-rust

name	testing-rust
description	Rust 테스트 패턴 — 단위 테스트, 통합 테스트,

Rust 테스트 패턴

소스: https://doc.rust-lang.org/book/ch11-00-testing.html | https://docs.rs/tokio/latest/tokio/attr.test.html | https://docs.rs/axum/0.8/axum/ | https://docs.rs/tower/latest/tower/trait.ServiceExt.html 검증일: 2026-06-20

주의: Rust 1.75+ / tokio 1.x / axum 0.8.x 기준으로 작성되었습니다.

---

단위 테스트 (#[cfg(test)] 모듈)

같은 파일 내에 #[cfg(test)] 모듈을 만들어 비공개 함수까지 테스트할 수 있다. cargo test에서만 컴파일된다.

// src/domain/entity.rs

pub struct UserId(pub i64);

impl UserId {
    pub fn is_valid(&self) -> bool {
        self.0 > 0
    }
}

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

    #[test]
    fn valid_user_id() {
        assert!(UserId(1).is_valid());
    }

    #[test]
    fn invalid_user_id() {
        assert!(!UserId(0).is_valid());
        assert!(!UserId(-1).is_valid());
    }
}

핵심 규칙:

• #[cfg(test)]는 cargo test 시에만 해당 모듈을 컴파일한다
• use super::*;로 부모 모듈의 비공개 항목에 접근 가능
• 테스트 함수에 #[test] 어트리뷰트 필수

---

표준 assert 매크로

#[cfg(test)]
mod tests {
    #[test]
    fn assert_examples() {
        // 불리언 검사
        assert!(true);
        assert!(1 + 1 == 2);

        // 동등성 검사 (Debug trait 필요)
        assert_eq!(4, 2 + 2);
        assert_ne!(3, 2 + 2);

        // 커스텀 메시지
        let result = 42;
        assert_eq!(result, 42, "expected 42 but got {result}");

        // 패턴 매칭 (stable Rust에서 사용 가능)
        let value: Result<i32, String> = Ok(42);
        assert!(matches!(value, Ok(42)));

        let err: Result<i32, String> = Err("fail".to_string());
        assert!(matches!(err, Err(ref msg) if msg.contains()));
    }
}

주의: std::assert_matches::assert_matches!는 nightly 전용(#![feature(assert_matches)])입니다. stable Rust에서는 matches! 매크로와 assert!를 조합하세요.

---

#[should_panic] 테스트

함수가 panic하는지 검증한다.

#[cfg(test)]
mod tests {
    #[test]
    #[should_panic]
    fn panics_on_invalid_input() {
        divide(10, 0);
    }

    #[test]
    #[should_panic(expected = "division by zero")]
    fn panics_with_message() {
        divide(10, 0);
    }
}

---

Result 반환 테스트

? 연산자를 사용하려면 Result를 반환한다.

#[cfg(test)]
mod tests {
    #[test]
    fn result_test() -> Result<(), String> {
        let value: i32 = "42".parse().map_err(|e| format!("{e}"))?;
        assert_eq!(value, 42);
        Ok(())
    }
}

---

비동기 테스트 (#[tokio::test])

#[tokio::test]는 비동기 테스트 함수를 위한 tokio 매크로다. 내부적으로 tokio 런타임을 생성한다.

#[cfg(test)]
mod tests {
    #[tokio::test]
    async fn async_test() {
        let result = some_async_fn().await;
        assert_eq!(result, 42);
    }
}

런타임 flavor 설정:

// current_thread (기본값) — 단일 스레드, 대부분의 단위 테스트에 적합
#[tokio::test]
async fn default_single_thread() { /* ... */ }

// multi_thread — 멀티스레드 런타임이 필요한 경우
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn multi_thread_test() { /* ... */ }

주의: #[tokio::test]의 기본 flavor는 current_thread입니다. #[tokio::main]의 기본값인 multi_thread와 다릅니다.

필요 feature: macros와 rt (또는 "full")

[dev-dependencies]
tokio = { version = "1", features = ["macros", "rt"] }

---

In-Memory Mock (repository-pattern 연동)

Service 계층의 비즈니스 로직을 DB 없이 테스트한다. Repository trait의 In-Memory 구현을 주입한다.

관련 스킬: repository-pattern 스킬의 InMemoryUserRepository 참조

// tests/mock_repo.rs 또는 src 내부 테스트 모듈

use std::collections::HashMap;
use std::sync::atomic::{AtomicI64, Ordering};
use tokio::sync::RwLock;

pub struct InMemoryUserRepository {
    store: RwLock<HashMap<i64, User>>,
    next_id: AtomicI64,
}

impl InMemoryUserRepository {
    pub fn new() -> Self {
        Self {
            store: RwLock::new(HashMap::new()),
            next_id: AtomicI64::new(1),
        }
    }

    /// 테스트 셋업용: 초기 데이터를 미리 넣는 헬퍼
    pub async fn with_seed(users: Vec<User>) -> Self {
        let repo = Self::new();
        let mut store = repo.store.write().await;
        for user in users {
            let id = repo.next_id.fetch_add(1, Ordering::SeqCst);
            store.insert(id, user);
        }
        repo
    }
}

impl UserRepository   {
      (&, id: &UserId)  <<User>, DomainError> {
          = .store.().;
        (store.(&id.).())
    }

      (&, input: &CreateUser)  <User, DomainError> {
         .(&input.email).?.() {
             (DomainError::(, , &input.email));
        }
          = .next_id.(, Ordering::SeqCst);
          = User {
            id: (id),
            email: input.email.(),
            name: input.name.(),
            created_at: chrono::Utc::(),
        };
          = .store.().;
        store.(id, user.());
        (user)
    }

    
}

Service 단위 테스트

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

    fn setup() -> UserService<InMemoryUserRepository> {
        UserService::new(InMemoryUserRepository::new())
    }

    #[tokio::test]
    async fn create_and_get_user() {
        let service = setup();

        let input = CreateUser {
            email: "[e-mail]".to_string(),
            name: "Test User".to_string(),
        };

        let created = service.create_user(input).await.unwrap();
        assert_eq!(created.email, "[e-mail]");

        let found = service.get_user(created.id.clone()).await.unwrap();
        assert_eq!(found.id, created.id);
    }

    #[tokio::test]
    async fn duplicate_email_returns_conflict() {
        let service = setup();

        service.create_user(CreateUser {
            email: "[e-mail]".(),
            name: .(),
        })..();

          = service.(CreateUser {
            email: .(),
            name: .(),
        }).;

        (matches!(result, (DomainError::Conflict { .. })));
    }

    
      () {
          = ();
          = service.(()).;
        (matches!(result, (DomainError::NotFound { .. })));
    }
}

---

Axum 핸들러 테스트 (tower::ServiceExt)

axum의 Router는 tower::Service를 구현한다. tower::ServiceExt::oneshot으로 HTTP 요청을 직접 보내 테스트할 수 있다.

주의: axum은 자체 TestClient를 제공하지 않습니다. 공식 테스트 패턴은 tower::ServiceExt::oneshot입니다.

의존성

[dev-dependencies]
tokio = { version = "1", features = ["macros", "rt"] }
tower = { version = "0.5", features = ["util"] }
http-body-util = "0.1"          # body 읽기 유틸
hyper = "1"

기본 패턴

#[cfg(test)]
mod tests {
    use axum::{
        body::Body,
        http::{Request, StatusCode},
        Router,
    };
    use http_body_util::BodyExt;  // .collect() 메서드
    use tower::ServiceExt;        // .oneshot() 메서드

    // 테스트용 Router 생성 (AppState에 InMemory 주입)
    fn test_app() -> Router {
        let repo = InMemoryUserRepository::new();
        let service = UserService::new(repo);
        let state = AppState {
            user_service: Arc::new(service),
        };

        create_router_with_state(state)
    }

    #[tokio::test]
    async fn test_get_user_not_found() {
        let app = test_app();

        let response = app
            .oneshot(
                Request::builder()
                    .uri("/users/999")
                    .body(Body::empty())
                    .unwrap(),
            )
            .await
            .unwrap();

        assert_eq!(response.status(), StatusCode::NOT_FOUND);
    }

    
      () {
          = ();

          = app
            .(
                Request::()
                    .()
                    .()
                    .(, )
                    .(Body::(
                        serde_json::(&serde_json::json!({
                            : ,
                            : 
                        })).(),
                    ))
                    .(),
            )
            .
            .();

        (response.(), StatusCode::CREATED);

        
          = response.().()..().();
         : serde_json::Value = serde_json::(&body).();
        (user[], );
    }
}

oneshot의 제약: 여러 요청 보내기

oneshot은 Service를 소비(consume)한다. 여러 요청을 보내려면 매번 Router를 생성하거나 .into_service()를 사용한다.

#[tokio::test]
async fn test_multiple_requests() {
    let app = test_app();

    // Router를 Service로 변환하면 clone 가능
    let mut app = app.into_service();

    // 첫 번째 요청
    let req1 = Request::builder()
        .method("POST")
        .uri("/users")
        .header("content-type", "application/json")
        .body(Body::from(r#"{"email":"[e-mail]","name":"A"}"#))
        .unwrap();
    let res1 = ServiceExt::<Request<Body>>::ready(&mut app)
        .await
        .unwrap()
        .call(req1)
        .await
        .unwrap();
    assert_eq!(res1.status(), StatusCode::CREATED);

    // 두 번째 요청 (같은 서비스 인스턴스)
    let req2 = Request::builder()
        .uri("/users/1")
        .body(Body::empty())
        .();
      = ServiceExt::<Request<Body>>::(& app)
        .
        .()
        .(req2)
        .
        .();
    (res2.(), StatusCode::OK);
}

---

---

상세 레퍼런스 (예제·고급 패턴·흔한 실수) → references/REFERENCE.md