test: add integration tests

Author: barreeeiroo

Cargo.lock

@@ -12,7 +12,6 @@ tracing-subscriber = { version = "~0.3", features = ["env-filter"] }
 
 # HTTP and body handling
 bytes = "~1.11"
-http = "~1.3"
 http-body = "~1.0"
 http-body-util = "~0.1"
 tower-http = { version = "~0.6", features = ["trace"] }

Cargo.toml

@@ -0,0 +1,18 @@
+// Library exports for integration tests
+pub mod app_state;
+pub mod auth;
+pub mod config;
+pub mod handlers;
+pub mod server;
+pub mod storage;
+pub mod types;
+
+// Re-export commonly used types
+pub use app_state::AppState;
+pub use auth::CredentialsStore;
+pub use config::{BackendConfig, Config};
+pub use storage::{InMemoryStorage, MultiBackend, S3Backend, StorageBackend};
+pub use types::Credentials;
+
+// Re-export server creation function
+pub use server::create_app;

src/lib.rs

@@ -5,27 +5,19 @@ mod handlers;
 mod storage;
 mod types;
 
+mod server;
+
 use app_state::AppState;
-use auth::{CredentialsStore, auth_middleware};
+use auth::CredentialsStore;
 use config::{BackendConfig, Config};
-use handlers::{
-    delete_object, get_object, head_bucket, head_object, list_objects, not_found, put_object,
-};
 use storage::{
     InMemoryStorage, MultiBackend, S3Backend, StorageBackend, determine_primary_by_latency,
 };
 use types::Credentials;
 
-use axum::{
-    Router,
-    extract::Request,
-    middleware::{self, Next},
-    routing::get,
-};
 use clap::Parser;
 use std::collections::HashMap;
 use std::sync::Arc;
-use tower_http::trace::TraceLayer;
 
 // Server configuration
 const HOST: &str = "0.0.0.0";
@@ -201,34 +193,8 @@ async fn main() {
     // Create shared app state
     let app_state = AppState::new(storage, credentials_store, bucket_name.clone());
 
-    // Build router with S3 API endpoints using the bucket name as a constant path
-    let bucket_path = format!("/{}", bucket_name);
-    let bucket_path_with_slash = format!("/{}/", bucket_name);
-    let object_path = format!("/{}/{{*key}}", bucket_name);
-
-    let app = Router::new()
-        // Object operations: /{bucket_name}/{key}
-        .route(
-            &object_path,
-            get(get_object)
-                .put(put_object)
-                .delete(delete_object)
-                .head(head_object),
-        )
-        // Bucket operations: /{bucket_name} and /{bucket_name}/
-        .route(&bucket_path, get(list_objects).head(head_bucket))
-        .route(&bucket_path_with_slash, get(list_objects).head(head_bucket))
-        // Fallback for 404 Not Found
-        .fallback(not_found)
-        // Add shared state
-        .with_state(app_state.clone())
-        // Add authentication middleware (captures app_state)
-        .layer(middleware::from_fn(move |request: Request, next: Next| {
-            let state = app_state.clone();
-            async move { auth_middleware(state, request, next).await }
-        }))
-        // Add tracing
-        .layer(TraceLayer::new_for_http());
+    // Create the application router using the shared create_app function
+    let app = server::create_app(app_state, bucket_name.clone());
 
     // Start server
     let addr = format!("{}:{}", cli.host, cli.port);

src/main.rs

@@ -0,0 +1,46 @@
+use crate::{app_state::AppState, auth, handlers};
+use axum::{
+    Router,
+    extract::Request,
+    middleware::{self, Next},
+    routing::get,
+};
+use tower_http::trace::TraceLayer;
+
+/// Create the application router with all routes and middleware
+///
+/// This function is used by both main.rs and integration tests to ensure
+/// the same server configuration is used in both production and tests.
+pub fn create_app(app_state: AppState, bucket_name: String) -> Router {
+    use handlers::{
+        delete_object, get_object, head_bucket, head_object, list_objects, not_found, put_object,
+    };
+
+    let bucket_path = format!("/{}", bucket_name);
+    let bucket_path_with_slash = format!("/{}/", bucket_name);
+    let object_path = format!("/{}/{{*key}}", bucket_name);
+
+    Router::new()
+        // Object operations: /{bucket_name}/{key}
+        .route(
+            &object_path,
+            get(get_object)
+                .put(put_object)
+                .delete(delete_object)
+                .head(head_object),
+        )
+        // Bucket operations: /{bucket_name} and /{bucket_name}/
+        .route(&bucket_path, get(list_objects).head(head_bucket))
+        .route(&bucket_path_with_slash, get(list_objects).head(head_bucket))
+        // Fallback for 404 Not Found
+        .fallback(not_found)
+        // Add shared state
+        .with_state(app_state.clone())
+        // Add authentication middleware (captures app_state)
+        .layer(middleware::from_fn(move |request: Request, next: Next| {
+            let state = app_state.clone();
+            async move { auth::auth_middleware(state, request, next).await }
+        }))
+        // Add tracing
+        .layer(TraceLayer::new_for_http())
+}

src/server.rs

@@ -18,6 +18,12 @@ struct StoredObject {
     metadata: ObjectMetadata,
 }
 
+impl Default for InMemoryStorage {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl InMemoryStorage {
     pub fn new() -> Self {
         Self {

src/storage/in_memory.rs

@@ -0,0 +1,8 @@
+pub mod test_server;
+
+pub use test_server::TestServer;
+
+// Test constants
+pub const TEST_ACCESS_KEY_ID: &str = "AKIAIOSFODNN7EXAMPLE";
+pub const TEST_SECRET_ACCESS_KEY: &str = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY";
+pub const TEST_BUCKET: &str = "test-bucket";

tests/helpers/mod.rs

@@ -0,0 +1,100 @@
+use aws_sdk_s3::Client as S3Client;
+use aws_sdk_s3::config::Credentials as AwsCredentials;
+use replicat4::{
+    AppState, Credentials, CredentialsStore, InMemoryStorage, StorageBackend, create_app,
+};
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::task::JoinHandle;
+
+/// Test server handle that automatically shuts down on drop
+///
+/// This starts a real HTTP server on a random port for integration testing.
+/// The server uses the actual production code via create_app().
+/// It also provides an AWS S3 client configured to communicate with the test server.
+pub struct TestServer {
+    shutdown_tx: Option<tokio::sync::oneshot::Sender<()>>,
+    #[allow(dead_code)] // Keep handle alive to prevent task abort
+    handle: JoinHandle<()>,
+    pub client: S3Client,
+    pub bucket_name: String,
+}
+
+impl TestServer {
+    /// Start a test server with in-memory storage and return an S3 client
+    pub async fn start(
+        bucket_name: String,
+        access_key_id: String,
+        secret_access_key: String,
+    ) -> Self {
+        // Create in-memory storage backend
+        let storage: Arc<dyn StorageBackend> = Arc::new(InMemoryStorage::new());
+
+        // Create credentials store with test credentials
+        let mut credentials_map = HashMap::new();
+        credentials_map.insert(
+            access_key_id.clone(),
+            Credentials {
+                _access_key_id: access_key_id.clone(),
+                secret_access_key: secret_access_key.clone(),
+            },
+        );
+        let credentials_store = CredentialsStore::new(credentials_map);
+
+        // Create app state
+        let app_state = AppState::new(storage, credentials_store, bucket_name.clone());
+
+        // Use the ACTUAL production create_app function
+        let app = create_app(app_state, bucket_name.clone());
+
+        // Bind to a random available port
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+
+        // Create shutdown channel
+        let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel::<()>();
+
+        // Spawn server task
+        let handle = tokio::spawn(async move {
+            axum::serve(listener, app)
+                .with_graceful_shutdown(async {
+                    shutdown_rx.await.ok();
+                })
+                .await
+                .unwrap();
+        });
+
+        // Give the server a moment to start
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+
+        // Create AWS S3 client configured to point to our test server
+        let endpoint_url = format!("http://{}", addr);
+        let creds = AwsCredentials::new(access_key_id, secret_access_key, None, None, "test");
+
+        let config = aws_sdk_s3::config::Builder::new()
+            .behavior_version_latest()
+            .credentials_provider(creds)
+            .region(aws_sdk_s3::config::Region::new("us-east-1"))
+            .endpoint_url(&endpoint_url)
+            .force_path_style(true)
+            .build();
+
+        let client = S3Client::from_conf(config);
+
+        TestServer {
+            shutdown_tx: Some(shutdown_tx),
+            handle,
+            client,
+            bucket_name,
+        }
+    }
+}
+
+impl Drop for TestServer {
+    fn drop(&mut self) {
+        // Signal shutdown (ignore errors if already shut down)
+        if let Some(tx) = self.shutdown_tx.take() {
+            let _ = tx.send(());
+        }
+    }
+}