Integration tests for /api/v2/text/detection/chat

Cargo.toml

@@ -18,6 +18,7 @@ anyhow = "1.0.95"
 async-trait = "0.1.85"
 axum = { version = "0.8.1", features = ["json"] }
 axum-extra = "0.10.0"
+bytes = "1.10.0"
 clap = { version = "4.5.26", features = ["derive", "env"] }
 eventsource-stream = "0.2.3"
 futures = "0.3.31"
@@ -28,27 +29,53 @@ http-body = "1.0"
 http-body-util = "0.1.2"
 http-serde = "2.1.1"
 hyper = { version = "1.5.2", features = ["http1", "http2", "server"] }
-hyper-rustls = { version = "0.27.5", features = ["ring"]}
+hyper-rustls = { version = "0.27.5", features = ["ring"] }
 hyper-timeout = "0.5.2"
-hyper-util = { version = "0.1.10", features = ["server-auto", "server-graceful", "tokio"] }
+hyper-util = { version = "0.1.10", features = [
+    "server-auto",
+    "server-graceful",
+    "tokio",
+] }
 opentelemetry = { version = "0.27.1", features = ["metrics", "trace"] }
 opentelemetry-http = { version = "0.27.0", features = ["reqwest"] }
-opentelemetry-otlp = { version = "0.27.0", features = ["grpc-tonic", "http-proto"] }
+opentelemetry-otlp = { version = "0.27.0", features = [
+    "grpc-tonic",
+    "http-proto",
+] }
 opentelemetry_sdk = { version = "0.27.1", features = ["rt-tokio", "metrics"] }
 pin-project-lite = "0.2.16"
 prost = "0.13.4"
-reqwest = { version = "0.12.12", features = ["blocking", "rustls-tls", "json"] }
-rustls = {version = "0.23.21", default-features = false, features = ["ring", "std"]}
+reqwest = { version = "0.12.12", features = [
+    "blocking",
+    "rustls-tls",
+    "json",
+    "stream",
+] }
+rustls = { version = "0.23.21", default-features = false, features = [
+    "ring",
+    "std",
+] }
 rustls-pemfile = "2.2.0"
 rustls-webpki = "0.102.8"
 serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0.135"
 serde_yml = "0.0.12"
 thiserror = "2.0.11"
-tokio = { version = "1.43.0", features = ["rt", "rt-multi-thread", "parking_lot", "signal", "sync", "fs"] }
-tokio-rustls = { version = "0.26.1", features = ["ring"]}
+tokio = { version = "1.43.0", features = [
+    "rt",
+    "rt-multi-thread",
+    "parking_lot",
+    "signal",
+    "sync",
+    "fs",
+] }
+tokio-rustls = { version = "0.26.1", features = ["ring"] }
 tokio-stream = { version = "0.1.17", features = ["sync"] }
-tonic = { version = "0.12.3", features = ["tls", "tls-roots", "tls-webpki-roots"] }
+tonic = { version = "0.12.3", features = [
+    "tls",
+    "tls-roots",
+    "tls-webpki-roots",
+] }
 tower = { version = "0.5.2", features = ["timeout"] }
 tower-http = { version = "0.6.2", features = ["trace"] }
 tracing = "0.1.41"
@@ -63,7 +90,8 @@ tonic-build = "0.12.3"
 [dev-dependencies]
 axum-test = "17.1.0"
 faux = "0.1.12"
-tracing-test = "0.2.5"
+mocktail = { git = "https://github.com/IBM/mocktail", version = "0.1.2-alpha" }
+test-log = "0.2.17"
 
 [profile.release]
 debug = false

src/server.rs

@@ -166,59 +166,7 @@ pub async fn run(
     }
 
     // (2b) Add main guardrails server routes
-    let mut router = Router::new()
-        .route(
-            &format!("{}/classification-with-text-generation", API_PREFIX),
-            post(classification_with_gen),
-        )
-        .route(
-            &format!("{}/detection/stream-content", TEXT_API_PREFIX),
-            post(stream_content_detection),
-        )
-        .route(
-            &format!(
-                "{}/server-streaming-classification-with-text-generation",
-                API_PREFIX
-            ),
-            post(stream_classification_with_gen),
-        )
-        .route(
-            &format!("{}/generation-detection", TEXT_API_PREFIX),
-            post(generation_with_detection),
-        )
-        .route(
-            &format!("{}/detection/content", TEXT_API_PREFIX),
-            post(detection_content),
-        )
-        .route(
-            &format!("{}/detection/chat", TEXT_API_PREFIX),
-            post(detect_chat),
-        )
-        .route(
-            &format!("{}/detection/context", TEXT_API_PREFIX),
-            post(detect_context_documents),
-        )
-        .route(
-            &format!("{}/detection/generated", TEXT_API_PREFIX),
-            post(detect_generated),
-        );
-
-    // If chat generation is configured, enable the chat completions detection endpoint.
-    if shared_state.orchestrator.config().chat_generation.is_some() {
-        info!("Enabling chat completions detection endpoint");
-        router = router.route(
-            "/api/v2/chat/completions-detection",
-            post(chat_completions_detection),
-        );
-    }
-
-    let app = router.with_state(shared_state).layer(
-        TraceLayer::new_for_http()
-            .make_span_with(utils::trace::incoming_request_span)
-            .on_request(utils::trace::on_incoming_request)
-            .on_response(utils::trace::on_outgoing_response)
-            .on_eos(utils::trace::on_outgoing_eos),
-    );
+    let app = get_app(shared_state);
 
     // (2c) Generate main guardrails server handle based on whether TLS is needed
     let listener: TcpListener = TcpListener::bind(&http_addr)
@@ -323,6 +271,58 @@ pub fn get_health_app(state: Arc<ServerState>) -> Router {
         .with_state(state)
 }
 
+pub fn get_app(state: Arc<ServerState>) -> Router {
+    let mut router = Router::new()
+        .route(
+            &format!("{}/classification-with-text-generation", API_PREFIX),
+            post(classification_with_gen),
+        )
+        .route(
+            &format!(
+                "{}/server-streaming-classification-with-text-generation",
+                API_PREFIX
+            ),
+            post(stream_classification_with_gen),
+        )
+        .route(
+            &format!("{}/generation-detection", TEXT_API_PREFIX),
+            post(generation_with_detection),
+        )
+        .route(
+            &format!("{}/detection/content", TEXT_API_PREFIX),
+            post(detection_content),
+        )
+        .route(
+            &format!("{}/detection/chat", TEXT_API_PREFIX),
+            post(detect_chat),
+        )
+        .route(
+            &format!("{}/detection/context", TEXT_API_PREFIX),
+            post(detect_context_documents),
+        )
+        .route(
+            &format!("{}/detection/generated", TEXT_API_PREFIX),
+            post(detect_generated),
+        );
+
+    // If chat generation is configured, enable the chat completions detection endpoint.
+    if state.orchestrator.config().chat_generation.is_some() {
+        info!("Enabling chat completions detection endpoint");
+        router = router.route(
+            "/api/v2/chat/completions-detection",
+            post(chat_completions_detection),
+        );
+    }
+
+    router.with_state(state).layer(
+        TraceLayer::new_for_http()
+            .make_span_with(utils::trace::incoming_request_span)
+            .on_request(utils::trace::on_incoming_request)
+            .on_response(utils::trace::on_outgoing_response)
+            .on_eos(utils::trace::on_outgoing_eos),
+    )
+}
+
 async fn health() -> Result<impl IntoResponse, ()> {
     // NOTE: we are only adding the package information in the `health` endpoint to have this endpoint
     // provide a non empty 200 response. If we need to add more information regarding dependencies version

tests/canary_test.rs

@@ -1,41 +1,59 @@
+/*
+ Copyright FMS Guardrails Orchestrator Authors
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+*/
+
+// This is needed because integration test files are compiled as separate crates.
+// If any of the code in this file is not used by any of the test files, a warning about unused code is generated.
+// For more: https://github.com/rust-lang/rust/issues/46379
+
 use std::sync::Arc;
+use test_log::test;
 
 use axum_test::TestServer;
+use common::orchestrator::ensure_global_rustls_state;
 use fms_guardrails_orchestr8::{
     config::OrchestratorConfig,
     orchestrator::Orchestrator,
     server::{get_health_app, ServerState},
 };
 use hyper::StatusCode;
-use rustls::crypto::ring;
 use serde_json::Value;
 use tokio::sync::OnceCell;
 use tracing::debug;
-use tracing_test::traced_test;
+
+pub mod common;
 
 /// Async lazy initialization of shared state using tokio::sync::OnceCell
 static ONCE: OnceCell<Arc<ServerState>> = OnceCell::const_new();
 
 /// The actual async function that initializes the shared state if not already initialized
 async fn shared_state() -> Arc<ServerState> {
-    let config = OrchestratorConfig::load("tests/test.config.yaml")
+    let config = OrchestratorConfig::load("tests/test_config.yaml")
         .await
         .unwrap();
     let orchestrator = Orchestrator::new(config, false).await.unwrap();
     Arc::new(ServerState::new(orchestrator))
 }
 
-fn ensure_global_rustls_state() {
-    let _ = ring::default_provider().install_default();
-}
-
 /// Checks if the health endpoint is working
 /// NOTE: We do not currently mock client services yet, so this test is
 /// superficially testing the client health endpoints on the orchestrator is accessible
 /// and when the orchestrator is running (healthy) all the health endpoints return 200 OK.
 /// This will happen even if the client services or their health endpoints are not found.
-#[traced_test]
-#[tokio::test]
+#[test(tokio::test)]
 async fn test_health() {
     ensure_global_rustls_state();
     let shared_state = ONCE.get_or_init(shared_state).await.clone();