Struct StatusCode 

pub struct StatusCode(/* private fields */);

HTTP status code.

Implementations

impl StatusCode

pub const CONTINUE: StatusCode

100 Continue

pub const SWITCHING_PROTOCOLS: StatusCode

101 Switching Protocols

pub const OK: StatusCode

200 OK

pub const CREATED: StatusCode

201 Created

pub const ACCEPTED: StatusCode

202 Accepted

pub const NO_CONTENT: StatusCode

204 No Content

pub const PARTIAL_CONTENT: StatusCode

206 Partial Content

pub const MOVED_PERMANENTLY: StatusCode

301 Moved Permanently

pub const FOUND: StatusCode

302 Found

pub const SEE_OTHER: StatusCode

303 See Other

pub const NOT_MODIFIED: StatusCode

304 Not Modified

pub const TEMPORARY_REDIRECT: StatusCode

307 Temporary Redirect

pub const PERMANENT_REDIRECT: StatusCode

308 Permanent Redirect

pub const BAD_REQUEST: StatusCode

400 Bad Request

pub const UNAUTHORIZED: StatusCode

401 Unauthorized

pub const FORBIDDEN: StatusCode

403 Forbidden

pub const NOT_FOUND: StatusCode

404 Not Found

pub const METHOD_NOT_ALLOWED: StatusCode

405 Method Not Allowed

pub const NOT_ACCEPTABLE: StatusCode

406 Not Acceptable

pub const PRECONDITION_FAILED: StatusCode

412 Precondition Failed

pub const PAYLOAD_TOO_LARGE: StatusCode

413 Payload Too Large

pub const UNSUPPORTED_MEDIA_TYPE: StatusCode

415 Unsupported Media Type

pub const RANGE_NOT_SATISFIABLE: StatusCode

416 Range Not Satisfiable

pub const UNPROCESSABLE_ENTITY: StatusCode

422 Unprocessable Entity

pub const TOO_MANY_REQUESTS: StatusCode

429 Too Many Requests

pub const CLIENT_CLOSED_REQUEST: StatusCode

499 Client Closed Request

pub const INTERNAL_SERVER_ERROR: StatusCode

500 Internal Server Error

pub const SERVICE_UNAVAILABLE: StatusCode

503 Service Unavailable

pub const GATEWAY_TIMEOUT: StatusCode

504 Gateway Timeout

pub const fn from_u16(code: u16) -> StatusCode

Create a status code from a u16.

pub const fn as_u16(self) -> u16

Get the numeric value.

Examples found in repository

examples/hello_world.rs (line 89)

fn main() {
    println!("fastapi_rust Hello World Example");
    println!("================================\n");

    // Build the application
    //
    // App::builder() creates a new application builder that lets you:
    // - Add routes for different HTTP methods
    // - Configure middleware
    // - Set application state
    // - Define exception handlers
    let app = App::builder()
        // Register a GET handler for the root path "/"
        //
        // This is equivalent to:
        //   @app.get("/")
        //   def hello():
        //       return "Hello, World!"
        // in Python FastAPI
        .get("/", hello_handler)
        // Build the final immutable App
        .build();

    println!("App created with {} route(s)\n", app.route_count());

    // Create a test client to make requests to our app
    //
    // TestClient wraps any Handler (including App) and provides
    // a convenient API for making HTTP requests in tests.
    let client = TestClient::new(app);

    // Make a GET request to "/"
    println!("Making request: GET /");
    let response = client.get("/").send();

    // Check the response
    println!(
        "GET / -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    println!("Response: {}\n", response.text());

    // Verify success
    assert_eq!(response.status().as_u16(), 200);
    assert_eq!(response.text(), "Hello, World!");

    // Try a path that doesn't exist - should get 404
    println!("Making request: GET /not-found");
    let response = client.get("/not-found").send();
    println!(
        "GET /not-found -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(response.status().as_u16(), 404);

    println!("\nAll assertions passed!");
}

examples/getting_started.rs (line 40)

fn main() {
    println!("Getting Started Guide - Code Validation\n");

    // === Basic App Example ===
    println!("1. Basic app with two routes:");
    let app = App::builder()
        .get("/", hello)
        .get("/health", health)
        .build();

    println!("   Routes: {}", app.route_count());
    let client = TestClient::new(app);

    let response = client.get("/").send();
    println!(
        "   GET / -> {} ({})",
        response.status().as_u16(),
        response.text()
    );
    assert_eq!(response.status().as_u16(), 200);
    assert_eq!(response.text(), "Hello, World!");

    let response = client.get("/health").send();
    println!(
        "   GET /health -> {} ({})",
        response.status().as_u16(),
        response.text()
    );
    assert_eq!(response.status().as_u16(), 200);

    // === App with Middleware ===
    println!("\n2. App with middleware:");
    let app = App::builder()
        .middleware(RequestIdMiddleware::new())
        .middleware(SecurityHeaders::new())
        .get("/", hello)
        .build();

    let client = TestClient::new(app);
    let response = client.get("/").send();
    println!("   GET / -> {}", response.status().as_u16());
    assert_eq!(response.status().as_u16(), 200);

    // === App with Configuration ===
    println!("\n3. App with configuration:");
    let config = AppConfig::new()
        .name("My API")
        .version("1.0.0")
        .debug(true)
        .max_body_size(10 * 1024 * 1024)
        .request_timeout_ms(30_000);

    let app = App::builder().config(config).get("/", hello).build();

    println!("   App name: {}", app.config().name);
    println!("   Version: {}", app.config().version);
    assert_eq!(app.config().name, "My API");
    assert_eq!(app.config().version, "1.0.0");

    // === 404 for unknown routes ===
    println!("\n4. 404 for unknown routes:");
    let app = App::builder().get("/", hello).build();

    let client = TestClient::new(app);
    let response = client.get("/nonexistent").send();
    println!("   GET /nonexistent -> {}", response.status().as_u16());
    assert_eq!(response.status().as_u16(), 404);

    println!("\nAll getting started examples validated successfully!");
}

examples/crud_api.rs (line 282)

fn main() {
    // Initialize the global store
    *STORE.lock().unwrap() = Some(UserDb {
        users: HashMap::new(),
        next_id: 1,
    });

    println!("fastapi_rust CRUD API Example");
    println!("=============================\n");

    let app = App::builder()
        .post("/users", create_user)
        .get("/users", list_users)
        .get("/users/{id}", get_user)
        .put("/users/{id}", update_user)
        .delete("/users/{id}", delete_user)
        .build();

    println!("App created with {} route(s)\n", app.route_count());
    let client = TestClient::new(app);

    // 1. Create users
    println!("1. Create users");
    let resp = client
        .post("/users")
        .header("content-type", "application/json")
        .body(r#"{"name": "Alice", "email": "alice@example.com"}"#)
        .send();
    println!(
        "   POST /users -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 201);

    let resp = client
        .post("/users")
        .header("content-type", "application/json")
        .body(r#"{"name": "Bob", "email": "bob@example.com"}"#)
        .send();
    println!(
        "   POST /users -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 201);

    // 2. List users
    println!("\n2. List all users");
    let resp = client.get("/users").send();
    println!(
        "   GET /users -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 200);

    // 3. Get user by ID
    println!("\n3. Get user by ID");
    let resp = client.get("/users/1").send();
    println!(
        "   GET /users/1 -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 200);

    // 4. Get nonexistent user
    println!("\n4. Get nonexistent user");
    let resp = client.get("/users/999").send();
    println!(
        "   GET /users/999 -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 404);

    // 5. Update user
    println!("\n5. Update user");
    let resp = client
        .put("/users/1")
        .header("content-type", "application/json")
        .body(r#"{"name": "Alice Smith", "email": "alice.smith@example.com"}"#)
        .send();
    println!(
        "   PUT /users/1 -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 200);

    // 6. Validation: empty name
    println!("\n6. Validation error (empty name)");
    let resp = client
        .post("/users")
        .header("content-type", "application/json")
        .body(r#"{"name": "", "email": "bad@example.com"}"#)
        .send();
    println!(
        "   POST /users -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 400);

    // 7. Validation: invalid email
    println!("\n7. Validation error (invalid email)");
    let resp = client
        .post("/users")
        .header("content-type", "application/json")
        .body(r#"{"name": "Charlie", "email": "not-an-email"}"#)
        .send();
    println!(
        "   POST /users -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 400);

    // 8. Wrong Content-Type
    println!("\n8. Wrong Content-Type");
    let resp = client
        .post("/users")
        .header("content-type", "text/plain")
        .body(r#"{"name": "Dan", "email": "dan@example.com"}"#)
        .send();
    println!(
        "   POST /users -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 415);

    // 9. Delete user
    println!("\n9. Delete user");
    let resp = client.delete("/users/2").send();
    println!("   DELETE /users/2 -> {}", resp.status().as_u16());
    assert_eq!(resp.status().as_u16(), 204);

    // 10. Verify deletion
    println!("\n10. Verify deletion");
    let resp = client.get("/users/2").send();
    println!(
        "   GET /users/2 -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 404);

    let resp = client.get("/users").send();
    println!(
        "   GET /users -> {} {}",
        resp.status().as_u16(),
        resp.text()
    );
    assert_eq!(resp.status().as_u16(), 200);

    println!("\nAll CRUD operations passed!");
}

examples/auth_example.rs (line 274)

fn main() {
    println!("fastapi_rust Authentication Example");
    println!("====================================\n");

    // Build the application with public and protected routes
    let app = App::builder()
        // Public endpoints - accessible to everyone
        .get("/public", public_handler)
        // Login endpoint - returns a token
        .post("/login", login_handler)
        // Protected endpoint - requires valid bearer token
        .get("/protected", protected_handler)
        .build();

    println!("App created with {} route(s)\n", app.route_count());

    // Create a test client
    let client = TestClient::new(app);

    // =========================================================================
    // Test 1: Public endpoint - no auth required
    // =========================================================================
    println!("1. Public endpoint - no auth required");
    let response = client.get("/public").send();
    println!(
        "   GET /public -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(response.status().as_u16(), 200);
    assert!(response.text().contains("public endpoint"));

    // =========================================================================
    // Test 2: Protected endpoint - without token (should get 401)
    // =========================================================================
    println!("\n2. Protected endpoint - without token");
    let response = client.get("/protected").send();
    println!(
        "   GET /protected -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        401,
        "Protected endpoint should return 401 without token"
    );

    // Check for WWW-Authenticate header
    let has_www_auth = response
        .headers()
        .iter()
        .any(|(name, value)| name == "www-authenticate" && value == b"Bearer");
    assert!(
        has_www_auth,
        "401 response should include WWW-Authenticate: Bearer header"
    );

    // =========================================================================
    // Test 3: Login endpoint - get a token
    // =========================================================================
    println!("\n3. Login endpoint - get a token");
    let response = client
        .post("/login")
        .header("content-type", "application/json")
        .body(r#"{"username":"test","password":"test123"}"#)
        .send();
    println!(
        "   POST /login -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(response.status().as_u16(), 200);

    // Parse the response to get the token
    let body: serde_json::Value = serde_json::from_str(response.text()).unwrap();
    let token = body["access_token"].as_str().unwrap();
    println!("   Token: {token}");
    assert_eq!(token, SECRET_TOKEN);

    // =========================================================================
    // Test 4: Protected endpoint - with valid token (should get 200)
    // =========================================================================
    println!("\n4. Protected endpoint - with valid token");
    let response = client
        .get("/protected")
        .header("authorization", format!("Bearer {SECRET_TOKEN}"))
        .send();
    println!(
        "   GET /protected (Authorization: Bearer {}) -> {} {}",
        SECRET_TOKEN,
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        200,
        "Protected endpoint should return 200 with valid token"
    );
    assert!(response.text().contains("protected resource"));

    // =========================================================================
    // Test 5: Protected endpoint - with invalid token (should get 403)
    // =========================================================================
    println!("\n5. Protected endpoint - with invalid token");
    let response = client
        .get("/protected")
        .header("authorization", "Bearer wrong_token")
        .send();
    println!(
        "   GET /protected (Authorization: Bearer wrong_token) -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        403,
        "Protected endpoint should return 403 with invalid token"
    );

    // =========================================================================
    // Test 6: Protected endpoint - with wrong auth scheme (should get 401)
    // =========================================================================
    println!("\n6. Protected endpoint - with wrong auth scheme");
    let response = client
        .get("/protected")
        .header("authorization", "Basic dXNlcjpwYXNz")
        .send();
    println!(
        "   GET /protected (Authorization: Basic ...) -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        401,
        "Protected endpoint should return 401 with wrong auth scheme"
    );

    // =========================================================================
    // Test 7: Login with wrong Content-Type (should get 415)
    // =========================================================================
    println!("\n7. Login with wrong Content-Type");
    let response = client
        .post("/login")
        .header("content-type", "text/plain")
        .body("username=test&password=test123")
        .send();
    println!(
        "   POST /login (Content-Type: text/plain) -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        415,
        "Login should return 415 with wrong Content-Type"
    );

    // =========================================================================
    // Test 8: Token case sensitivity (lowercase 'bearer')
    // =========================================================================
    println!("\n8. Token case sensitivity (lowercase 'bearer')");
    let response = client
        .get("/protected")
        .header("authorization", format!("bearer {SECRET_TOKEN}"))
        .send();
    println!(
        "   GET /protected (Authorization: bearer {}) -> {} {}",
        SECRET_TOKEN,
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        200,
        "Bearer scheme should be case-insensitive (lowercase accepted)"
    );

    println!("\nAll authentication tests passed!");
}

pub const fn allows_body(self) -> bool

Check if status code allows a body.

pub const fn canonical_reason(self) -> &'static str

Get the canonical reason phrase.

Examples found in repository

examples/hello_world.rs (line 90)

fn main() {
    println!("fastapi_rust Hello World Example");
    println!("================================\n");

    // Build the application
    //
    // App::builder() creates a new application builder that lets you:
    // - Add routes for different HTTP methods
    // - Configure middleware
    // - Set application state
    // - Define exception handlers
    let app = App::builder()
        // Register a GET handler for the root path "/"
        //
        // This is equivalent to:
        //   @app.get("/")
        //   def hello():
        //       return "Hello, World!"
        // in Python FastAPI
        .get("/", hello_handler)
        // Build the final immutable App
        .build();

    println!("App created with {} route(s)\n", app.route_count());

    // Create a test client to make requests to our app
    //
    // TestClient wraps any Handler (including App) and provides
    // a convenient API for making HTTP requests in tests.
    let client = TestClient::new(app);

    // Make a GET request to "/"
    println!("Making request: GET /");
    let response = client.get("/").send();

    // Check the response
    println!(
        "GET / -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    println!("Response: {}\n", response.text());

    // Verify success
    assert_eq!(response.status().as_u16(), 200);
    assert_eq!(response.text(), "Hello, World!");

    // Try a path that doesn't exist - should get 404
    println!("Making request: GET /not-found");
    let response = client.get("/not-found").send();
    println!(
        "GET /not-found -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(response.status().as_u16(), 404);

    println!("\nAll assertions passed!");
}

examples/auth_example.rs (line 275)

fn main() {
    println!("fastapi_rust Authentication Example");
    println!("====================================\n");

    // Build the application with public and protected routes
    let app = App::builder()
        // Public endpoints - accessible to everyone
        .get("/public", public_handler)
        // Login endpoint - returns a token
        .post("/login", login_handler)
        // Protected endpoint - requires valid bearer token
        .get("/protected", protected_handler)
        .build();

    println!("App created with {} route(s)\n", app.route_count());

    // Create a test client
    let client = TestClient::new(app);

    // =========================================================================
    // Test 1: Public endpoint - no auth required
    // =========================================================================
    println!("1. Public endpoint - no auth required");
    let response = client.get("/public").send();
    println!(
        "   GET /public -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(response.status().as_u16(), 200);
    assert!(response.text().contains("public endpoint"));

    // =========================================================================
    // Test 2: Protected endpoint - without token (should get 401)
    // =========================================================================
    println!("\n2. Protected endpoint - without token");
    let response = client.get("/protected").send();
    println!(
        "   GET /protected -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        401,
        "Protected endpoint should return 401 without token"
    );

    // Check for WWW-Authenticate header
    let has_www_auth = response
        .headers()
        .iter()
        .any(|(name, value)| name == "www-authenticate" && value == b"Bearer");
    assert!(
        has_www_auth,
        "401 response should include WWW-Authenticate: Bearer header"
    );

    // =========================================================================
    // Test 3: Login endpoint - get a token
    // =========================================================================
    println!("\n3. Login endpoint - get a token");
    let response = client
        .post("/login")
        .header("content-type", "application/json")
        .body(r#"{"username":"test","password":"test123"}"#)
        .send();
    println!(
        "   POST /login -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(response.status().as_u16(), 200);

    // Parse the response to get the token
    let body: serde_json::Value = serde_json::from_str(response.text()).unwrap();
    let token = body["access_token"].as_str().unwrap();
    println!("   Token: {token}");
    assert_eq!(token, SECRET_TOKEN);

    // =========================================================================
    // Test 4: Protected endpoint - with valid token (should get 200)
    // =========================================================================
    println!("\n4. Protected endpoint - with valid token");
    let response = client
        .get("/protected")
        .header("authorization", format!("Bearer {SECRET_TOKEN}"))
        .send();
    println!(
        "   GET /protected (Authorization: Bearer {}) -> {} {}",
        SECRET_TOKEN,
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        200,
        "Protected endpoint should return 200 with valid token"
    );
    assert!(response.text().contains("protected resource"));

    // =========================================================================
    // Test 5: Protected endpoint - with invalid token (should get 403)
    // =========================================================================
    println!("\n5. Protected endpoint - with invalid token");
    let response = client
        .get("/protected")
        .header("authorization", "Bearer wrong_token")
        .send();
    println!(
        "   GET /protected (Authorization: Bearer wrong_token) -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        403,
        "Protected endpoint should return 403 with invalid token"
    );

    // =========================================================================
    // Test 6: Protected endpoint - with wrong auth scheme (should get 401)
    // =========================================================================
    println!("\n6. Protected endpoint - with wrong auth scheme");
    let response = client
        .get("/protected")
        .header("authorization", "Basic dXNlcjpwYXNz")
        .send();
    println!(
        "   GET /protected (Authorization: Basic ...) -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        401,
        "Protected endpoint should return 401 with wrong auth scheme"
    );

    // =========================================================================
    // Test 7: Login with wrong Content-Type (should get 415)
    // =========================================================================
    println!("\n7. Login with wrong Content-Type");
    let response = client
        .post("/login")
        .header("content-type", "text/plain")
        .body("username=test&password=test123")
        .send();
    println!(
        "   POST /login (Content-Type: text/plain) -> {} {}",
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        415,
        "Login should return 415 with wrong Content-Type"
    );

    // =========================================================================
    // Test 8: Token case sensitivity (lowercase 'bearer')
    // =========================================================================
    println!("\n8. Token case sensitivity (lowercase 'bearer')");
    let response = client
        .get("/protected")
        .header("authorization", format!("bearer {SECRET_TOKEN}"))
        .send();
    println!(
        "   GET /protected (Authorization: bearer {}) -> {} {}",
        SECRET_TOKEN,
        response.status().as_u16(),
        response.status().canonical_reason()
    );
    assert_eq!(
        response.status().as_u16(),
        200,
        "Bearer scheme should be case-insensitive (lowercase accepted)"
    );

    println!("\nAll authentication tests passed!");
}

Trait Implementations

impl Clone for StatusCode

fn clone(&self) -> StatusCode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StatusCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for StatusCode

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoStatusU16 for StatusCode

fn into_status_u16(self) -> u16

impl PartialEq for StatusCode

fn eq(&self, other: &StatusCode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for StatusCode

impl Eq for StatusCode

impl StructuralPartialEq for StatusCode