Rust axum 실무 구성 — 에러를 응답으로, 입력 검증, 서버 없이 테스트

[package]
name = "notes-service"
version = "0.1.0"
edition = "2024"

[dependencies]
axum = "=0.8.9"
tokio = { version = "=1.54.1", features = ["rt-multi-thread", "macros", "net", "time"] }
serde = { version = "=1.0.229", features = ["derive"] }
serde_json = "=1.0.154"
thiserror = "=2.0.21"

[dev-dependencies]
tower = { version = "=0.5.3", features = ["util"] }
http-body-util = "=0.1.5"

#[derive(Debug, thiserror::Error)]
enum AppError {
    #[error("title must be 1 to {max} characters")]
    InvalidTitle { max: usize },
    #[error("note {0} not found")]
    NotFound(usize),
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let status = match self {
            AppError::InvalidTitle { .. } => StatusCode::BAD_REQUEST,
            AppError::NotFound(_) => StatusCode::NOT_FOUND,
        };
        let body = Json(serde_json::json!({ "error": self.to_string() }));
        (status, body).into_response()
    }
}

async fn create(State(state): State<AppState>, Json(input): Json<NewNote>) -> Result<(StatusCode, Json<Note>), AppError> {
    let title = input.title.trim();
    if title.is_empty() || title.chars().count() > TITLE_MAX {
        return Err(AppError::InvalidTitle { max: TITLE_MAX });
    }
    let mut notes = state.notes.lock().unwrap();
    let note = Note { id: notes.len() + 1, title: title.to_string() };
    notes.push(note.clone());
    Ok((StatusCode::CREATED, Json(note)))
}

async fn one(State(state): State<AppState>, Path(id): Path<usize>) -> Result<Json<Note>, AppError> {
    let notes = state.notes.lock().unwrap();
    notes.iter().find(|n| n.id == id).cloned().map(Json).ok_or(AppError::NotFound(id))
}

fn app(state: AppState) -> Router {
    let api = Router::new()
        .route("/notes", axum::routing::post(create))
        .route("/notes/{id}", get(one));
    Router::new()
        .route("/health", get(|| async { "ok" }))
        .nest("/api", api)
        .with_state(state)
}

#[cfg(test)]
mod tests {
    use super::*;
    use axum::body::Body;
    use axum::http::Request;
    use http_body_util::BodyExt;
    use tower::ServiceExt;

    async fn call(app: Router, method: &str, uri: &str, body: &str) -> (StatusCode, String) {
        let req = Request::builder()
            .method(method)
            .uri(uri)
            .header("content-type", "application/json")
            .body(Body::from(body.to_string()))
            .unwrap();
        let res = app.oneshot(req).await.unwrap();
        let status = res.status();
        let bytes = res.into_body().collect().await.unwrap().to_bytes();
        (status, String::from_utf8(bytes.to_vec()).unwrap())
    }

    #[tokio::test]
    async fn creates_note() {
        let (status, body) = call(app(AppState::default()), "POST", "/api/notes", r#"{"title":" learn axum "}"#).await;
        assert_eq!(status, StatusCode::CREATED);
        assert_eq!(body, r#"{"id":1,"title":"learn axum"}"#);
    }

    #[tokio::test]
    async fn rejects_empty_title() {
        let (status, body) = call(app(AppState::default()), "POST", "/api/notes", r#"{"title":"   "}"#).await;
        assert_eq!(status, StatusCode::BAD_REQUEST);
        assert_eq!(body, r#"{"error":"title must be 1 to 50 characters"}"#);
    }

    #[tokio::test]
    async fn missing_note_is_404_json() {
        let (status, body) = call(app(AppState::default()), "GET", "/api/notes/7", "").await;
        assert_eq!(status, StatusCode::NOT_FOUND);
        assert_eq!(body, r#"{"error":"note 7 not found"}"#);
    }

    #[tokio::test]
    async fn health_is_outside_api() {
        let (status, body) = call(app(AppState::default()), "GET", "/health", "").await;
        assert_eq!((status, body.as_str()), (StatusCode::OK, "ok"));
    }
}