sentry - units-for-slot fix test and bug:

- db- campaign - fix bug in query
- units-for-slot - debug! logging and testing

Author: elpiel

sentry/src/db/campaign.rs

@@ -219,19 +219,19 @@ pub async fn update_campaign(pool: &DbPool, campaign: &Campaign) -> Result<Campa
 pub async fn units_for_slot_get_campaigns(
     pool: &DbPool,
     deposit_assets: Option<&HashSet<Address>>,
-    creator: Address,
+    not_creator: Address,
     active_to_ge: DateTime<Utc>,
 ) -> Result<Vec<Campaign>, PoolError> {
     let client = pool.get().await?;
 
     let mut where_clauses = vec![
         // Campaign.active.to
         "active_to >= $1".to_string(),
-        // Campaign.creator
-        "creator = $2".into(),
+        // Campaign.creator != not_creator
+        "creator != $2".into(),
     ];
     let mut params: Vec<Box<(dyn ToSql + Sync + Send)>> =
-        vec![Box::new(active_to_ge), Box::new(creator)];
+        vec![Box::new(active_to_ge), Box::new(not_creator)];
 
     // Deposit assets
     match deposit_assets.cloned() {

sentry/src/routes/units_for_slot.rs

@@ -118,10 +118,11 @@ where
         &app.config,
         &Some(query.deposit_assets),
         publisher_id,
+        &app.logger,
     )
     .await?;
 
-    debug!(&app.logger, "Fetched Cache campaigns limited by earner (publisher)"; "campaigns" => campaigns_limited_by_earner.len(), "publisher_id" => %publisher_id);
+    debug!(&app.logger, "Fetched campaigns limited by earner (publisher)"; "campaigns" => campaigns_limited_by_earner.len(), "publisher_id" => %publisher_id);
 
     // We return those in the result (which means AdView would have those) but we don't actually use them
     // we do that in order to have the same variables as the validator, so that the `price` is the same
@@ -177,6 +178,7 @@ async fn get_campaigns(
     config: &Config,
     deposit_assets: &Option<HashSet<Address>>,
     publisher_id: ValidatorId,
+    logger: &Logger,
 ) -> Result<Vec<Campaign>, CampaignsError> {
     // 1. Fetch active Campaigns: (postgres)
     //  Creator = publisher_id
@@ -200,6 +202,11 @@ async fn get_campaigns(
         .get_multiple_with_ids(active_campaign_ids)
         .await?;
 
+    debug!(
+        logger,
+        "Active Campaigns: {:?}\nRemaining: {:?}", &active_campaign_ids, &campaigns_remaining
+    );
+
     let campaigns_with_remaining = campaigns_remaining
         .into_iter()
         .filter_map(|(campaign_id, remaining)| {
@@ -208,9 +215,14 @@ async fn get_campaigns(
                 // and we have to find the `Campaign` instance
                 active_campaigns
                     .iter()
-                    .find(|campaign| campaign.id == campaign_id)
+                    .find(|campaign| {
+                        debug!(logger, "Take {:?} because it's active and not exhausted, i.e. {} (remaining budget) > 0", remaining, campaign_id);
+
+                        campaign.id == campaign_id
+                    })
                     .cloned()
             } else {
+                debug!(logger, "Skip {:?} because there's no remaining budget", campaign_id);
                 None
             }
         })
@@ -234,6 +246,11 @@ async fn get_campaigns(
     .flatten()
     .collect::<Vec<_>>();
 
+    debug!(
+        logger,
+        "Publishers Accounting for channels: {:?}", &publisher_accountings
+    );
+
     // 3. Filter `Campaign`s, that include the `publisher_id` in the Channel balances.
     let (mut campaigns_by_earner, rest_of_campaigns): (Vec<Campaign>, Vec<Campaign>) =
         campaigns_with_remaining.into_iter().partition(|campaign| {

sentry/src/routes/units_for_slot_test.rs

@@ -14,25 +14,25 @@ use primitives::{
             AdUnit as ResponseAdUnit, Campaign as ResponseCampaign, UnitsWithPrice,
         },
     },
-    targeting::{Function, Rules, Value},
+    targeting::Rules,
     test_util::{CAMPAIGNS, DUMMY_AD_UNITS, DUMMY_IPFS, IDS, PUBLISHER},
     unified_num::FromWhole,
+    util::logging::new_logger,
     AdSlot,
 };
 
+use wiremock::{
+    matchers::{method, path},
+    Mock, MockServer, ResponseTemplate,
+};
+
 use super::*;
 use crate::{
     routes::campaign::create_campaign,
     test_util::{setup_dummy_app, ApplicationGuard},
     Auth,
 };
 
-// use url::Url;
-use wiremock::{
-    matchers::{method, path},
-    Mock, MockServer, ResponseTemplate,
-};
-
 // User Agent OS: Linux (only in `woothee`)
 // User Agent Browser Family: Firefox
 const LINUX_FIREFOX_USER_AGENT: &str =
@@ -47,13 +47,18 @@ async fn setup_mocked_platform_dummy_app() -> (MockServer, ApplicationGuard) {
     let platform_url = mock_server.uri().parse().unwrap();
 
     let mut app_guard = setup_dummy_app().await;
+    app_guard.app.logger = new_logger("sentry-dummy-app");
+    debug!(
+        &app_guard.app.logger,
+        "With platform mocker server at {}", &platform_url
+    );
+
     app_guard.app.platform_api.platform_url = platform_url;
 
     (mock_server, app_guard)
 }
 
 #[tokio::test]
-#[ignore = "Fix test"]
 async fn test_targeting_input() {
     let (mock_server, app_guard) = setup_mocked_platform_dummy_app().await;
     let app = Arc::new(app_guard.app);
@@ -71,7 +76,7 @@ async fn test_targeting_input() {
             [
                 (
                     GANACHE_INFO_1.tokens["Mocked TOKEN 1"].address,
-                    UnifiedNum::from_whole(0.0007),
+                    UnifiedNum::from_whole(0.010),
                 ),
                 (
                     GANACHE_INFO_1337.tokens["Mocked TOKEN 1337"].address,
@@ -103,8 +108,7 @@ async fn test_targeting_input() {
                 deposit,
             );
 
-            CAMPAIGNS[0] /* .context */
-                .clone()
+            CAMPAIGNS[0].clone()
         };
 
         let campaign_1 = {
@@ -119,8 +123,7 @@ async fn test_targeting_input() {
                 deposit,
             );
 
-            CAMPAIGNS[1] /* .context */
-                .clone()
+            CAMPAIGNS[1].clone()
         };
 
         let matching_campaign_2 = {
@@ -135,14 +138,7 @@ async fn test_targeting_input() {
                 deposit,
             );
 
-            let min_impression_price =
-                Function::new_only_show_if(Function::new_get("eventMinPrice"));
-
-            let mut campaign_2 = CAMPAIGNS[2] /* .context */
-                .clone();
-            campaign_2.context.targeting_rules = Rules(vec![min_impression_price.into()]);
-
-            campaign_2
+            CAMPAIGNS[2].clone()
         };
 
         [campaign_0, campaign_1, matching_campaign_2]
@@ -253,8 +249,12 @@ async fn test_targeting_input() {
     .expect("Should return response")
     .0;
 
-    // pub targeting_input_base: Input,
-    // assert_eq!(response.targeting_input_base);
+    debug!(&app.logger, "{:?}", response.targeting_input_base);
+    assert_eq!(
+        response.targeting_input_base.global.publisher_id,
+        *PUBLISHER
+    );
+
     assert!(response.accepted_referrers.is_empty());
     let expected_fallback_until = ResponseAdUnit {
         ipfs: fallback_unit.ipfs,