Add comprehensive Rust test coverage for MCP core flows

- Add 44 new integration tests for feature grants, routing, and MCP flows

- Add mock repository infrastructure (mocks.rs) for in-memory testing

- Add database tests for feature sets, inbound clients, installed servers, outbound OAuth

- Add gateway tests for ServerManager (22 tests)

- Add OAuth tests for DCR, flows, and token management (53 tests)

- Fix existing tests to account for auto-created builtin feature sets

- Total: 217 Rust tests now passing

Author: Mohammod Al Amin Ashik

Cargo.lock

@@ -32,6 +32,23 @@ chrono = { version = "0.4", features = ["serde"] }
 # Hex encoding for crypto tests
 hex = "0.4"
 
+# Dashmap for concurrent collections
+dashmap = "6.1"
+
+# Tracing for test output
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+# HTTP mocking for OAuth tests
+wiremock = "0.6"
+reqwest = { version = "0.12", features = ["json"] }
+
+# URL parsing for OAuth tests
+url = "2.5"
+
+# Sync primitives for tests
+parking_lot = "0.12"
+
 [lib]
 path = "src/lib.rs"
 
@@ -43,11 +60,14 @@ path = "tests/database/mod.rs"
 name = "security"
 path = "tests/security/mod.rs"
 
-# Gateway and OAuth tests will be added later when infrastructure is ready
-# [[test]]
-# name = "gateway"
-# path = "tests/gateway/mod.rs"
-#
-# [[test]]
-# name = "oauth"
-# path = "tests/oauth/mod.rs"
+[[test]]
+name = "gateway"
+path = "tests/gateway/mod.rs"
+
+[[test]]
+name = "oauth"
+path = "tests/oauth/mod.rs"
+
+[[test]]
+name = "integration"
+path = "tests/integration/mod.rs"

tests/rust/Cargo.toml

@@ -1,6 +1,125 @@
 //! Shared test utilities and fixtures for McpMux integration tests.
 
-pub use mcpmux_core::domain::{InstalledServer, Space, FeatureSet, FeatureSetType};
+pub use mcpmux_core::domain::{InstalledServer, Space, FeatureSet, FeatureSetType, Client, Credential};
+pub use mcpmux_core::{DomainEvent, ConnectionStatus, DiscoveredCapabilities, ServerFeature, FeatureType};
+
+/// Mock repository implementations
+pub mod mocks;
+pub use mocks::MockRepositories;
+
+/// Service test helpers
+pub mod services;
+pub use services::ServerManagerTestHarness;
+
+/// Event testing utilities
+pub mod events {
+    use mcpmux_core::DomainEvent;
+    use tokio::sync::broadcast;
+    use std::time::Duration;
+
+    /// Create a test event channel with sufficient capacity
+    pub fn test_event_channel() -> (broadcast::Sender<DomainEvent>, broadcast::Receiver<DomainEvent>) {
+        broadcast::channel(100)
+    }
+
+    /// Collect events from a receiver with a timeout
+    pub async fn collect_events(
+        mut rx: broadcast::Receiver<DomainEvent>,
+        timeout: Duration,
+    ) -> Vec<DomainEvent> {
+        let mut events = Vec::new();
+        let deadline = tokio::time::Instant::now() + timeout;
+        
+        loop {
+            let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
+            if remaining.is_zero() {
+                break;
+            }
+            
+            match tokio::time::timeout(remaining, rx.recv()).await {
+                Ok(Ok(event)) => events.push(event),
+                Ok(Err(_)) => break, // Channel closed or lagged
+                Err(_) => break, // Timeout
+            }
+        }
+        
+        events
+    }
+
+    /// Wait for a specific event type
+    pub async fn wait_for_event<F>(
+        mut rx: broadcast::Receiver<DomainEvent>,
+        timeout: Duration,
+        predicate: F,
+    ) -> Option<DomainEvent>
+    where
+        F: Fn(&DomainEvent) -> bool,
+    {
+        let deadline = tokio::time::Instant::now() + timeout;
+        
+        loop {
+            let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
+            if remaining.is_zero() {
+                return None;
+            }
+            
+            match tokio::time::timeout(remaining, rx.recv()).await {
+                Ok(Ok(event)) if predicate(&event) => return Some(event),
+                Ok(Ok(_)) => continue, // Not the event we want
+                Ok(Err(_)) => return None, // Channel closed
+                Err(_) => return None, // Timeout
+            }
+        }
+    }
+
+    /// Assert that a ServerStatusChanged event was emitted with expected status
+    pub fn assert_status_changed(
+        events: &[DomainEvent],
+        expected_server_id: &str,
+        expected_status: mcpmux_core::ConnectionStatus,
+    ) -> bool {
+        events.iter().any(|e| {
+            if let DomainEvent::ServerStatusChanged { server_id, status, .. } = e {
+                server_id == expected_server_id && *status == expected_status
+            } else {
+                false
+            }
+        })
+    }
+}
+
+/// Server feature fixtures for testing
+pub mod features {
+    use mcpmux_core::ServerFeature;
+
+    /// Create a test tool feature
+    pub fn test_tool(space_id: &str, server_id: &str, name: &str) -> ServerFeature {
+        ServerFeature::tool(space_id, server_id, name)
+            .with_description(format!("Test tool: {}", name))
+    }
+
+    /// Create a test prompt feature
+    pub fn test_prompt(space_id: &str, server_id: &str, name: &str) -> ServerFeature {
+        ServerFeature::prompt(space_id, server_id, name)
+            .with_description(format!("Test prompt: {}", name))
+    }
+
+    /// Create a test resource feature
+    pub fn test_resource(space_id: &str, server_id: &str, uri: &str) -> ServerFeature {
+        ServerFeature::resource(space_id, server_id, uri)
+            .with_description(format!("Test resource: {}", uri))
+    }
+
+    /// Create a set of test features for a server
+    pub fn test_feature_set(space_id: &str, server_id: &str) -> Vec<ServerFeature> {
+        vec![
+            test_tool(space_id, server_id, "read_file"),
+            test_tool(space_id, server_id, "write_file"),
+            test_prompt(space_id, server_id, "summarize"),
+            test_resource(space_id, server_id, "file:///test"),
+        ]
+    }
+}
 
 /// Test fixture utilities
 pub mod fixtures {