units-for-slot deposit assets:

- sentry - db - campaign - test max query limit with deposit assets
- primitives - sentry - add default for Query

Author: elpiel

primitives/src/sentry.rs

@@ -1157,9 +1157,10 @@ pub mod units_for_slot {
 
     use crate::Address;
 
-    #[derive(Debug, Clone, Serialize, Deserialize)]
+    #[derive(Debug, Clone, Serialize, Deserialize, Default)]
     #[serde(rename_all = "camelCase")]
     pub struct Query {
+        #[serde(default)]
         pub deposit_assets: HashSet<Address>,
     }
 

sentry/src/db/campaign.rs

@@ -216,6 +216,9 @@ pub async fn update_campaign(pool: &DbPool, campaign: &Campaign) -> Result<Campa
     Ok(Campaign::from(&updated_row))
 }
 
+/// Get Campaigns for GET `/v5/units-for-slot` route.
+///
+/// This method was tested with **5099** deposit assets and it does not reach the postgres query limit.
 pub async fn units_for_slot_get_campaigns(
     pool: &DbPool,
     deposit_assets: Option<&HashSet<Address>>,
@@ -905,4 +908,68 @@ mod test {
             vec![campaign_new_id.clone(), campaign.clone()]
         );
     }
+
+    #[tokio::test]
+    async fn test_units_for_slot_query_max_length_with_deposit_assets() {
+        use primitives::test_util::{CREATOR, PUBLISHER};
+        let database = DATABASE_POOL.get().await.expect("Should get a DB pool");
+
+        setup_test_migrations(database.pool.clone())
+            .await
+            .expect("Migrations should succeed");
+
+        let token_addr = *CREATOR;
+        // generate addresses
+        let generate = |for_byte: usize| {
+            (0..255_u8)
+                .map(|byte| {
+                    let mut bytes = token_addr.to_bytes();
+                    bytes[for_byte] = byte;
+
+                    Address::from_bytes(&bytes)
+                })
+                .collect::<Vec<_>>()
+        };
+        let mut generated = vec![];
+        generated.extend(generate(19));
+        generated.extend(generate(18));
+        generated.extend(generate(17));
+        generated.extend(generate(16));
+        generated.extend(generate(15));
+        generated.extend(generate(14));
+        generated.extend(generate(13));
+        generated.extend(generate(12));
+        generated.extend(generate(11));
+        generated.extend(generate(10));
+        generated.extend(generate(9));
+        generated.extend(generate(8));
+        generated.extend(generate(7));
+        generated.extend(generate(6));
+        generated.extend(generate(5));
+        generated.extend(generate(4));
+        generated.extend(generate(3));
+        generated.extend(generate(2));
+        generated.extend(generate(1));
+        generated.extend(generate(0));
+
+        // start from the largest to the smallest and if it successes with the largest value,
+        // then we just break the look.
+        // Otherwise continues to try out other amount of deposit assets before it succeeds.
+        for i in (0..generated.len()).rev() {
+            let deposit_assets = generated[0..i].iter().copied().collect::<HashSet<_>>();
+
+            
+            match units_for_slot_get_campaigns(
+                &database,
+                Some(&deposit_assets),
+                *PUBLISHER,
+                Utc::now(),
+            )
+            .await
+            {
+                Ok(_success) => break,
+                Err(_err) => panic!("Failed with {} deposit assets", i),
+            };
+        }
+    }
 }