feat(ads-client): handle different ad types (#7073)

* feat(ads-client): handle different ad types

* test(ads-client): test all three ad variants in client

* refactor(ads-client): deserialize ad using generic

* test(ads-client): setup context id component for tests

* doc(ads-client): rename UATile to Tile and update usage doc with new names

Author: Almaju

CHANGELOG.md

@@ -17,6 +17,9 @@
 
 ## ✨ What's New ✨
 
+### Ads Client
+- Add support for three ad types: Image, Spoc (Sponsored Content), and UA Tile
+
 ### Autofill
 - Adds a migration to migrate users to use subregion codes over fully qualified strings. ([bug 1993388](https://bugzilla.mozilla.org/show_bug.cgi?id=1993388))
 - Added credit card verification logic ([#7047](https://github.com/mozilla/application-services/pull/7047)).

components/ads-client/docs/usage.md

@@ -6,12 +6,14 @@
 use std::collections::HashMap;
 use std::time::Duration;
 
-use crate::client::ad_response::Ad;
+use crate::client::ad_response::{AdImage, AdResponse, AdSpoc, AdTile};
 use crate::client::config::AdsClientConfig;
 use crate::error::{RecordClickError, RecordImpressionError, ReportAdError, RequestAdsError};
 use crate::http_cache::{HttpCache, RequestCachePolicy};
-use crate::mars::{DefaultMARSClient, MARSClient};
+use crate::mars::MARSClient;
 use ad_request::{AdPlacementRequest, AdRequest};
+use context_id::{ContextIDComponent, DefaultContextIdCallback};
+use serde::de::DeserializeOwned;
 use url::Url;
 use uuid::Uuid;
 
@@ -25,7 +27,8 @@ const DEFAULT_TTL_SECONDS: u64 = 300;
 const DEFAULT_MAX_CACHE_SIZE_MIB: u64 = 10;
 
 pub struct AdsClient {
-    client: Box<dyn MARSClient>,
+    client: MARSClient,
+    context_id_component: ContextIDComponent,
 }
 
 impl AdsClient {
@@ -34,6 +37,13 @@ impl AdsClient {
 
         let client_config = client_config.unwrap_or_default();
 
+        let context_id_component = ContextIDComponent::new(
+            &context_id,
+            0,
+            cfg!(test),
+            Box::new(DefaultContextIdCallback),
+        );
+
         // Configure the cache if a path is provided.
         // Defaults for ttl and cache size are also set if unspecified.
         if let Some(cache_cfg) = client_config.cache_config {
@@ -51,32 +61,60 @@ impl AdsClient {
                 .build()
                 .ok(); // TODO: handle error with telemetry
 
-            let client = Box::new(DefaultMARSClient::new(
-                context_id,
-                client_config.environment,
-                http_cache,
-            ));
-            return Self { client };
+            let client = MARSClient::new(client_config.environment, http_cache);
+            return Self {
+                context_id_component,
+                client,
+            };
         }
 
-        let client = Box::new(DefaultMARSClient::new(
-            context_id,
-            client_config.environment,
-            None,
-        ));
-        Self { client }
+        let client = MARSClient::new(client_config.environment, None);
+        Self {
+            context_id_component,
+            client,
+        }
     }
 
-    pub fn request_ads(
+    fn request_ads<T>(
         &self,
         ad_placement_requests: Vec<AdPlacementRequest>,
         options: Option<RequestCachePolicy>,
-    ) -> Result<HashMap<String, Vec<Ad>>, RequestAdsError> {
-        let ad_request = AdRequest::build(self.client.get_context_id()?, ad_placement_requests)?;
+    ) -> Result<AdResponse<T>, RequestAdsError>
+    where
+        T: DeserializeOwned,
+    {
+        let context_id = self.get_context_id()?;
+        let ad_request = AdRequest::build(context_id, ad_placement_requests)?;
         let cache_policy = options.unwrap_or_default();
         let response = self.client.fetch_ads(&ad_request, &cache_policy)?;
-        let placements = response.build_placements(&ad_request)?;
-        Ok(placements)
+        Ok(response)
+    }
+
+    pub fn request_image_ads(
+        &self,
+        ad_placement_requests: Vec<AdPlacementRequest>,
+        options: Option<RequestCachePolicy>,
+    ) -> Result<HashMap<String, AdImage>, RequestAdsError> {
+        let response = self.request_ads::<AdImage>(ad_placement_requests, options)?;
+        Ok(response.take_first())
+    }
+
+    pub fn request_spoc_ads(
+        &self,
+        ad_placement_requests: Vec<AdPlacementRequest>,
+        options: Option<RequestCachePolicy>,
+    ) -> Result<HashMap<String, Vec<AdSpoc>>, RequestAdsError> {
+        let response = self.request_ads::<AdSpoc>(ad_placement_requests, options)?;
+        Ok(response.data)
+    }
+
+    pub fn request_tile_ads(
+        &self,
+        ad_placement_requests: Vec<AdPlacementRequest>,
+        options: Option<RequestCachePolicy>,
+    ) -> Result<HashMap<String, AdTile>, RequestAdsError> {
+        let response = self.request_ads::<AdTile>(ad_placement_requests, options)?;
+        Ok(response.take_first())
     }
 
     pub fn record_impression(&self, impression_url: Url) -> Result<(), RecordImpressionError> {
@@ -92,8 +130,14 @@ impl AdsClient {
         Ok(())
     }
 
+    pub fn get_context_id(&self) -> context_id::ApiResult<String> {
+        self.context_id_component.request(0)
+    }
+
     pub fn cycle_context_id(&mut self) -> context_id::ApiResult<String> {
-        self.client.cycle_context_id()
+        let old_context_id = self.get_context_id()?;
+        self.context_id_component.force_rotation()?;
+        Ok(old_context_id)
     }
 
     pub fn clear_cache(&self) -> Result<(), HttpCacheError> {
@@ -103,78 +147,123 @@ impl AdsClient {
 
 #[cfg(test)]
 mod tests {
-    use url::Url;
-
-    use crate::{
-        client::ad_request::{AdContentCategory, IABContentTaxonomy},
-        mars::MockMARSClient,
-        test_utils::{
-            get_example_happy_ad_response, get_example_happy_placements,
-            make_happy_placement_requests,
-        },
+    use crate::test_utils::{
+        get_example_happy_image_response, get_example_happy_spoc_response,
+        get_example_happy_uatile_response, make_happy_placement_requests,
     };
 
     use super::*;
 
     #[test]
-    fn test_request_ads_happy() {
-        let mut mock = MockMARSClient::new();
-        mock.expect_fetch_ads()
-            .returning(|_req, _| Ok(get_example_happy_ad_response()));
-        mock.expect_get_context_id()
-            .returning(|| Ok("mock-context-id".to_string()));
+    fn test_get_context_id() {
+        let client = AdsClient::new(None);
+        let context_id = client.get_context_id().unwrap();
+        assert!(!context_id.is_empty());
+    }
 
-        mock.expect_get_mars_endpoint()
-            .return_const(Url::parse("https://mock.endpoint/ads").unwrap());
+    #[test]
+    fn test_cycle_context_id() {
+        let mut client = AdsClient::new(None);
+        let old_id = client.get_context_id().unwrap();
+        let previous_id = client.cycle_context_id().unwrap();
+        assert_eq!(previous_id, old_id);
+        let new_id = client.get_context_id().unwrap();
+        assert_ne!(new_id, old_id);
+    }
 
+    #[test]
+    fn test_request_image_ads_happy() {
+        use crate::test_utils::create_test_client;
+        use context_id::{ContextIDComponent, DefaultContextIdCallback};
+        viaduct_dev::init_backend_dev();
+
+        let expected_response = get_example_happy_image_response();
+        let _m = mockito::mock("POST", "/ads")
+            .with_status(200)
+            .with_header("content-type", "application/json")
+            .with_body(serde_json::to_string(&expected_response).unwrap())
+            .create();
+
+        let mars_client = create_test_client(mockito::server_url());
+        let context_id_component = ContextIDComponent::new(
+            &uuid::Uuid::new_v4().to_string(),
+            0,
+            false,
+            Box::new(DefaultContextIdCallback),
+        );
         let component = AdsClient {
-            client: Box::new(mock),
+            context_id_component,
+            client: mars_client,
         };
 
         let ad_placement_requests = make_happy_placement_requests();
 
-        let result = component.request_ads(ad_placement_requests, None);
+        let result = component.request_image_ads(ad_placement_requests, None);
 
         assert!(result.is_ok());
     }
 
     #[test]
-    fn test_request_ads_multiset_happy() {
-        let mut mock = MockMARSClient::new();
-        mock.expect_fetch_ads()
-            .returning(|_req, _| Ok(get_example_happy_ad_response()));
-        mock.expect_get_context_id()
-            .returning(|| Ok("mock-context-id".to_string()));
+    fn test_request_spocs_happy() {
+        use crate::test_utils::create_test_client;
+        use context_id::{ContextIDComponent, DefaultContextIdCallback};
+        viaduct_dev::init_backend_dev();
+
+        let expected_response = get_example_happy_spoc_response();
+        let _m = mockito::mock("POST", "/ads")
+            .with_status(200)
+            .with_header("content-type", "application/json")
+            .with_body(serde_json::to_string(&expected_response).unwrap())
+            .create();
+
+        let mars_client = create_test_client(mockito::server_url());
+        let context_id_component = ContextIDComponent::new(
+            &uuid::Uuid::new_v4().to_string(),
+            0,
+            false,
+            Box::new(DefaultContextIdCallback),
+        );
+        let component = AdsClient {
+            context_id_component,
+            client: mars_client,
+        };
 
-        mock.expect_get_mars_endpoint()
-            .return_const(Url::parse("https://mock.endpoint/ads").unwrap());
+        let ad_placement_requests = make_happy_placement_requests();
+
+        let result = component.request_spoc_ads(ad_placement_requests, None);
+
+        assert!(result.is_ok());
+    }
 
+    #[test]
+    fn test_request_tiles_happy() {
+        use crate::test_utils::create_test_client;
+        use context_id::{ContextIDComponent, DefaultContextIdCallback};
+        viaduct_dev::init_backend_dev();
+
+        let expected_response = get_example_happy_uatile_response();
+        let _m = mockito::mock("POST", "/ads")
+            .with_status(200)
+            .with_header("content-type", "application/json")
+            .with_body(serde_json::to_string(&expected_response).unwrap())
+            .create();
+
+        let mars_client = create_test_client(mockito::server_url());
+        let context_id_component = ContextIDComponent::new(
+            &uuid::Uuid::new_v4().to_string(),
+            0,
+            false,
+            Box::new(DefaultContextIdCallback),
+        );
         let component = AdsClient {
-            client: Box::new(mock),
+            context_id_component,
+            client: mars_client,
         };
 
-        let ad_placement_requests: Vec<AdPlacementRequest> = vec![
-            AdPlacementRequest {
-                placement: "example_placement_1".to_string(),
-                count: 1,
-                content: Some(AdContentCategory {
-                    taxonomy: IABContentTaxonomy::IAB2_1,
-                    categories: vec!["entertainment".to_string()],
-                }),
-            },
-            AdPlacementRequest {
-                placement: "example_placement_2".to_string(),
-                count: 2,
-                content: Some(AdContentCategory {
-                    taxonomy: IABContentTaxonomy::IAB3_0,
-                    categories: vec![],
-                }),
-            },
-        ];
-
-        let result = component.request_ads(ad_placement_requests, None);
+        let ad_placement_requests = make_happy_placement_requests();
+
+        let result = component.request_tile_ads(ad_placement_requests, None);
 
         assert!(result.is_ok());
-        assert_eq!(result.unwrap(), get_example_happy_placements());
     }
 }

components/ads-client/src/client.rs

@@ -89,10 +89,7 @@ pub enum IABContentTaxonomy {
 
 #[cfg(test)]
 mod tests {
-    use crate::test_utils::{
-        get_example_happy_ad_response, get_example_happy_placements, make_happy_placement_requests,
-        TEST_CONTEXT_ID,
-    };
+    use crate::test_utils::TEST_CONTEXT_ID;
 
     use super::*;
     use serde_json::{json, to_value};
@@ -224,53 +221,4 @@ mod tests {
         let request = AdRequest::build(TEST_CONTEXT_ID.to_string(), vec![]);
         assert!(request.is_err());
     }
-
-    #[test]
-    fn test_build_placements_with_empty_placement_in_response() {
-        let mut ad_placement_requests = make_happy_placement_requests();
-        // Adding an extra placement request
-        ad_placement_requests.push(AdPlacementRequest {
-            placement: "example_placement_3".to_string(),
-            count: 1,
-            content: Some(AdContentCategory {
-                taxonomy: IABContentTaxonomy::IAB2_1,
-                categories: vec![],
-            }),
-        });
-
-        let mut api_resp = get_example_happy_ad_response();
-        api_resp
-            .data
-            .insert("example_placement_3".to_string(), vec![]);
-
-        let ad_request =
-            AdRequest::build(TEST_CONTEXT_ID.to_string(), ad_placement_requests).unwrap();
-
-        let placements = api_resp.build_placements(&ad_request).unwrap();
-
-        assert_eq!(placements, get_example_happy_placements());
-    }
-
-    #[test]
-    fn test_request_ads_with_missing_callback_in_response() {
-        let mut ad_placement_requests = make_happy_placement_requests();
-        // Adding an extra placement request
-        ad_placement_requests.push(AdPlacementRequest {
-            placement: "example_placement_3".to_string(),
-            count: 1,
-            content: Some(AdContentCategory {
-                taxonomy: IABContentTaxonomy::IAB2_1,
-                categories: vec![],
-            }),
-        });
-
-        let ad_request =
-            AdRequest::build(TEST_CONTEXT_ID.to_string(), ad_placement_requests).unwrap();
-
-        let placements = get_example_happy_ad_response()
-            .build_placements(&ad_request)
-            .unwrap();
-
-        assert_eq!(placements, get_example_happy_placements());
-    }
 }