Fix asset route rebase fallout

Author: ChristianPavilonis

crates/trusted-server-adapter-fastly/src/route_tests.rs

@@ -7,8 +7,8 @@ use edgezero_core::http::response_builder as edge_response_builder;
 use edgezero_core::key_value_store::NoopKvStore;
 use error_stack::Report;
 use fastly::http::{header, Method, StatusCode};
-use fastly::Request;
-use trusted_server_core::auction::build_orchestrator;
+use fastly::{Request, Response};
+use trusted_server_core::auction::{build_orchestrator, AuctionOrchestrator};
 use trusted_server_core::ec::registry::PartnerRegistry;
 use trusted_server_core::integrations::IntegrationRegistry;
 use trusted_server_core::platform::{
@@ -330,14 +330,38 @@ fn test_runtime_services_with_secret_and_http_client(
         .build()
 }
 
+fn test_partner_registry(settings: &Settings) -> PartnerRegistry {
+    PartnerRegistry::from_config(&settings.ec.partners).expect("should build partner registry")
+}
+
+fn buffered_route_response(
+    settings: &Settings,
+    orchestrator: &AuctionOrchestrator,
+    integration_registry: &IntegrationRegistry,
+    services: &RuntimeServices,
+    req: Request,
+) -> Response {
+    let partner_registry = test_partner_registry(settings);
+    let outcome = futures::executor::block_on(route_request(
+        settings,
+        orchestrator,
+        integration_registry,
+        &partner_registry,
+        services,
+        req,
+    ))
+    .expect("should route test request");
+
+    outcome.response.expect("should buffer test response")
+}
+
 #[test]
 fn routes_use_request_local_consent() {
     let settings = create_test_settings();
     let orchestrator = build_orchestrator(&settings).expect("should build auction orchestrator");
     let integration_registry =
         IntegrationRegistry::new(&settings).expect("should create integration registry");
-    let partner_registry =
-        PartnerRegistry::from_config(&settings.ec.partners).expect("should build partner registry");
+    let partner_registry = test_partner_registry(&settings);
 
     let discovery_req = Request::get("https://test.com/.well-known/trusted-server.json");
     let discovery_services = test_runtime_services(&discovery_req);
@@ -396,14 +420,13 @@ fn asset_routes_bypass_publisher_consent_dependencies() {
 
     let asset_req = Request::get("https://test.com/.images/logo.png?auto=webp");
     let asset_services = test_runtime_services(&asset_req);
-    let asset_resp = futures::executor::block_on(route_request(
+    let asset_resp = buffered_route_response(
         &settings,
         &orchestrator,
         &integration_registry,
         &asset_services,
         asset_req,
-    ))
-    .expect("should return an error response for asset proxy requests");
+    );
     assert_eq!(
         asset_resp.get_status(),
         StatusCode::BAD_GATEWAY,
@@ -430,14 +453,13 @@ fn asset_origin_failure_does_not_fall_back_to_publisher_origin() {
         Arc::clone(&http_client) as Arc<dyn PlatformHttpClient>,
     );
 
-    let resp = futures::executor::block_on(route_request(
+    let resp = buffered_route_response(
         &settings,
         &orchestrator,
         &integration_registry,
         &services,
         req,
-    ))
-    .expect("should return an error response for failed asset origin");
+    );
 
     assert_eq!(
         resp.get_status(),
@@ -518,14 +540,13 @@ fn s3_asset_origin_error_stays_uncacheable_after_global_headers() {
         Arc::clone(&http_client) as Arc<dyn PlatformHttpClient>,
     );
 
-    let resp = futures::executor::block_on(route_request(
+    let resp = buffered_route_response(
         &settings,
         &orchestrator,
         &integration_registry,
         &services,
         req,
-    ))
-    .expect("should route S3 asset request");
+    );
 
     assert_eq!(
         resp.get_status(),
@@ -567,14 +588,13 @@ fn asset_routes_proxy_head_requests() {
         Arc::clone(&http_client) as Arc<dyn PlatformHttpClient>,
     );
 
-    let resp = futures::executor::block_on(route_request(
+    let resp = buffered_route_response(
         &settings,
         &orchestrator,
         &integration_registry,
         &services,
         req,
-    ))
-    .expect("should route HEAD asset request");
+    );
 
     assert_eq!(
         resp.get_status(),
@@ -617,14 +637,13 @@ fn asset_routes_ignore_query_string_for_matching() {
         Arc::clone(&http_client) as Arc<dyn PlatformHttpClient>,
     );
 
-    let resp = futures::executor::block_on(route_request(
+    let resp = buffered_route_response(
         &settings,
         &orchestrator,
         &integration_registry,
         &services,
         req,
-    ))
-    .expect("should route asset request with query string");
+    );
 
     assert_eq!(
         resp.get_status(),
@@ -667,14 +686,13 @@ fn asset_routes_pass_redirect_responses_through() {
         Arc::clone(&http_client) as Arc<dyn PlatformHttpClient>,
     );
 
-    let resp = futures::executor::block_on(route_request(
+    let resp = buffered_route_response(
         &settings,
         &orchestrator,
         &integration_registry,
         &services,
         req,
-    ))
-    .expect("should route redirecting asset request");
+    );
 
     assert_eq!(
         resp.get_status(),
@@ -691,6 +709,7 @@ fn asset_routes_pass_redirect_responses_through() {
 #[test]
 fn asset_routes_skip_non_get_head_requests() {
     let mut settings = create_test_settings();
+    settings.publisher.origin_url = "https://".to_string();
     settings.proxy.asset_routes = vec![ProxyAssetRoute::new(
         "/.images/",
         "https://assets.example.com",
@@ -707,18 +726,17 @@ fn asset_routes_skip_non_get_head_requests() {
         Arc::clone(&http_client) as Arc<dyn PlatformHttpClient>,
     );
 
-    let resp = futures::executor::block_on(route_request(
+    let resp = buffered_route_response(
         &settings,
         &orchestrator,
         &integration_registry,
         &services,
         req,
-    ))
-    .expect("should route non-asset POST request");
+    );
 
     assert_eq!(
         resp.get_status(),
-        StatusCode::SERVICE_UNAVAILABLE,
+        StatusCode::BAD_GATEWAY,
         "should fall through to publisher fallback for POST requests"
     );
     assert!(
@@ -744,14 +762,13 @@ fn built_in_routes_take_precedence_over_asset_routes() {
 
     let req = Request::get("https://test.com/.well-known/trusted-server.json");
     let services = test_runtime_services(&req);
-    let resp = futures::executor::block_on(route_request(
+    let resp = buffered_route_response(
         &settings,
         &orchestrator,
         &integration_registry,
         &services,
         req,
-    ))
-    .expect("should route discovery request");
+    );
     assert_eq!(
         resp.get_status(),
         StatusCode::OK,
@@ -772,14 +789,13 @@ fn integration_routes_take_precedence_over_asset_routes() {
 
     let req = Request::get("https://test.com/prebid.js");
     let services = test_runtime_services(&req);
-    let mut resp = futures::executor::block_on(route_request(
+    let mut resp = buffered_route_response(
         &settings,
         &orchestrator,
         &integration_registry,
         &services,
         req,
-    ))
-    .expect("should route integration request");
+    );
     assert_eq!(
         resp.get_status(),
         StatusCode::OK,

crates/trusted-server-core/src/integrations/datadome.rs

@@ -71,6 +71,7 @@ use crate::integrations::{
     AttributeRewriteAction, IntegrationAttributeContext, IntegrationAttributeRewriter,
     IntegrationEndpoint, IntegrationProxy, IntegrationRegistration,
 };
+use crate::platform::RuntimeServices;
 use crate::settings::{IntegrationConfig, Settings};
 
 const DATADOME_INTEGRATION_ID: &str = "datadome";
@@ -404,6 +405,7 @@ impl IntegrationProxy for DataDomeIntegration {
     async fn handle(
         &self,
         _settings: &Settings,
+        _services: &RuntimeServices,
         req: Request,
     ) -> Result<Response, Report<TrustedServerError>> {
         let path = req.get_path();

crates/trusted-server-core/src/integrations/didomi.rs

@@ -11,6 +11,7 @@ use validator::Validate;
 use crate::backend::BackendConfig;
 use crate::error::TrustedServerError;
 use crate::integrations::{IntegrationEndpoint, IntegrationProxy, IntegrationRegistration};
+use crate::platform::RuntimeServices;
 use crate::settings::{IntegrationConfig, Settings};
 
 const DIDOMI_INTEGRATION_ID: &str = "didomi";
@@ -198,6 +199,7 @@ impl IntegrationProxy for DidomiIntegration {
     async fn handle(
         &self,
         _settings: &Settings,
+        _services: &RuntimeServices,
         req: Request,
     ) -> Result<Response, Report<TrustedServerError>> {
         let path = req.get_path();

crates/trusted-server-core/src/integrations/google_tag_manager.rs

@@ -28,6 +28,7 @@ use crate::integrations::{
     IntegrationEndpoint, IntegrationProxy, IntegrationRegistration, IntegrationScriptContext,
     IntegrationScriptRewriter, ScriptRewriteAction,
 };
+use crate::platform::RuntimeServices;
 use crate::proxy::{proxy_request, ProxyRequestConfig};
 use crate::settings::{IntegrationConfig, Settings};
 
@@ -427,6 +428,7 @@ impl IntegrationProxy for GoogleTagManagerIntegration {
     async fn handle(
         &self,
         settings: &Settings,
+        services: &RuntimeServices,
         mut req: Request,
     ) -> Result<Response, Report<TrustedServerError>> {
         let path = req.get_path().to_string();
@@ -482,7 +484,7 @@ impl IntegrationProxy for GoogleTagManagerIntegration {
             }
         };
 
-        let mut response = proxy_request(settings, req, proxy_config)
+        let mut response = proxy_request(settings, req, proxy_config, services)
             .await
             .change_context(Self::error("Failed to proxy GTM request"))?;
 
@@ -611,6 +613,7 @@ mod tests {
         IntegrationDocumentState, IntegrationRegistry, IntegrationScriptContext,
         IntegrationScriptRewriter, ScriptRewriteAction,
     };
+    use crate::platform::test_support::noop_services;
     use crate::settings::Settings;
     use crate::streaming_processor::{Compression, PipelineConfig, StreamingPipeline};
 
@@ -1213,7 +1216,7 @@ j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
 
         let settings = make_settings();
         let response = integration
-            .handle(&settings, req)
+            .handle(&settings, &noop_services(), req)
             .await
             .expect("handle should not return error");
 
@@ -1248,7 +1251,7 @@ j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
 
         let settings = make_settings();
         let response = integration
-            .handle(&settings, req)
+            .handle(&settings, &noop_services(), req)
             .await
             .expect("handle should not return error");
 

crates/trusted-server-core/src/integrations/gpt.rs

@@ -49,6 +49,7 @@ use crate::integrations::{
     IntegrationEndpoint, IntegrationHeadInjector, IntegrationHtmlContext, IntegrationProxy,
     IntegrationRegistration,
 };
+use crate::platform::RuntimeServices;
 use crate::proxy::{proxy_request, ProxyRequestConfig};
 use crate::settings::{IntegrationConfig, Settings};
 
@@ -238,12 +239,13 @@ impl GptIntegration {
     async fn proxy_gpt_asset(
         &self,
         settings: &Settings,
+        services: &RuntimeServices,
         req: Request,
         target_url: &str,
         context: &str,
     ) -> Result<Response, Report<TrustedServerError>> {
         let config = Self::build_proxy_config(target_url, &req);
-        let response = proxy_request(settings, req, config)
+        let response = proxy_request(settings, req, config, services)
             .await
             .change_context(Self::error(context))?;
 
@@ -287,12 +289,14 @@ impl GptIntegration {
     async fn handle_script_serving(
         &self,
         settings: &Settings,
+        services: &RuntimeServices,
         req: Request,
     ) -> Result<Response, Report<TrustedServerError>> {
         let script_url = &self.config.script_url;
         log::info!("Fetching GPT script from: {}", script_url);
         self.proxy_gpt_asset(
             settings,
+            services,
             req,
             script_url,
             &format!("Failed to fetch GPT script from {script_url}"),
@@ -309,6 +313,7 @@ impl GptIntegration {
     async fn handle_pagead_proxy(
         &self,
         settings: &Settings,
+        services: &RuntimeServices,
         req: Request,
     ) -> Result<Response, Report<TrustedServerError>> {
         let original_path = req.get_path();
@@ -320,6 +325,7 @@ impl GptIntegration {
         log::info!("GPT proxy: forwarding to {}", target_url);
         self.proxy_gpt_asset(
             settings,
+            services,
             req,
             &target_url,
             &format!("Failed to fetch GPT resource from {target_url}"),
@@ -376,16 +382,17 @@ impl IntegrationProxy for GptIntegration {
     async fn handle(
         &self,
         settings: &Settings,
+        services: &RuntimeServices,
         req: Request,
     ) -> Result<Response, Report<TrustedServerError>> {
         let path = req.get_path();
 
         if path == "/integrations/gpt/script" {
-            self.handle_script_serving(settings, req).await
+            self.handle_script_serving(settings, services, req).await
         } else if path.starts_with("/integrations/gpt/pagead/")
             || path.starts_with("/integrations/gpt/tag/")
         {
-            self.handle_pagead_proxy(settings, req).await
+            self.handle_pagead_proxy(settings, services, req).await
         } else {
             Err(Report::new(Self::error(format!(
                 "Unknown GPT route: {}",

crates/trusted-server-core/src/integrations/lockr.rs

@@ -23,6 +23,7 @@ use crate::integrations::{
     AttributeRewriteAction, IntegrationAttributeContext, IntegrationAttributeRewriter,
     IntegrationEndpoint, IntegrationProxy, IntegrationRegistration,
 };
+use crate::platform::RuntimeServices;
 use crate::settings::{IntegrationConfig, Settings};
 
 const LOCKR_INTEGRATION_ID: &str = "lockr";
@@ -303,6 +304,7 @@ impl IntegrationProxy for LockrIntegration {
     async fn handle(
         &self,
         settings: &Settings,
+        _services: &RuntimeServices,
         req: Request,
     ) -> Result<Response, Report<TrustedServerError>> {
         let path = req.get_path();