[test] primitives - eval - Function::Get

Author: elpiel

primitives/src/targeting.rs

@@ -25,6 +25,7 @@ impl Input {
         let spec = &self.global.channel.spec;
 
         match key {
+            // AdView scope, accessible only on the AdView
             "adView.secondsSinceCampaignImpression" => self
                 .ad_view
                 .as_ref()
@@ -35,9 +36,22 @@ impl Input {
                 .as_ref()
                 .map(|ad_view| Value::Bool(ad_view.has_custom_preferences))
                 .ok_or(Error::UnknownVariable),
+            "adView.navigatorLanguage" => self
+                .ad_view
+                .as_ref()
+                .map(|ad_view| Value::String(ad_view.navigator_language.clone()))
+                .ok_or(Error::UnknownVariable),
+            // Global scope, accessible everywhere
             "adSlotId" => Ok(Value::String(self.global.ad_slot_id.clone())),
             "adSlotType" => Ok(Value::String(self.global.ad_slot_type.clone())),
             "publisherId" => Ok(Value::String(self.global.publisher_id.to_checksum())),
+            "country" => self
+                .global
+                .country
+                .clone()
+                .ok_or(Error::UnknownVariable)
+                .map(Value::String),
+            "eventType" => Ok(Value::String(self.global.event_type.clone())),
             "secondsSinceEpoch" => Ok(Value::Number(self.global.seconds_since_epoch.into())),
             "userAgentOS" => self
                 .global
@@ -51,7 +65,7 @@ impl Input {
                 .clone()
                 .map(Value::String)
                 .ok_or(Error::UnknownVariable),
-
+            // Global scope, accessible everywhere, campaign-dependant
             "adUnitId" => {
                 let ipfs = self
                     .global
@@ -113,6 +127,7 @@ impl Input {
 
                 Ok(Value::BigNum(earned))
             }
+            // adSlot scope, accessible on Supermarket and AdView
             "adSlot.categories" => self
                 .ad_slot
                 .as_ref()
@@ -221,12 +236,15 @@ impl Output {
             "boost" => {
                 let boost = Number::from_f64(self.boost).ok_or(Error::TypeError)?;
                 Ok(Value::Number(boost))
-            },
+            }
             price_key if price_key.starts_with("price.") => {
-                let price = self.price.get(price_key.trim_start_matches("price.")).ok_or(Error::UnknownVariable)?;
+                let price = self
+                    .price
+                    .get(price_key.trim_start_matches("price."))
+                    .ok_or(Error::UnknownVariable)?;
                 Ok(Value::BigNum(price.clone()))
-            },
-            _ => Err(Error::UnknownVariable)
+            }
+            _ => Err(Error::UnknownVariable),
         }
     }
 }
@@ -352,7 +370,12 @@ mod test {
         };
 
         assert_eq!(Ok(Value::Bool(false)), output.try_get("show"));
-        assert_eq!(Ok(Value::Number(Number::from_f64(5.5).expect("Should make a number"))), output.try_get("boost"));
+        assert_eq!(
+            Ok(Value::Number(
+                Number::from_f64(5.5).expect("Should make a number")
+            )),
+            output.try_get("boost")
+        );
         assert_eq!(Ok(Value::BigNum(100.into())), output.try_get("price.one"));
         assert_eq!(Err(Error::UnknownVariable), output.try_get("price.unknown"));
         assert_eq!(Err(Error::UnknownVariable), output.try_get("unknown"));

primitives/src/targeting/eval.rs

@@ -895,7 +895,9 @@ fn eval(input: &Input, output: &mut Output, rule: &Rule) -> Result<Option<Value>
                 .try_bignum()?;
             let deposit_asset = &input.global.channel.deposit_asset;
 
-            let divisor = DEPOSIT_ASSETS_MAP.get(deposit_asset).ok_or(Error::TypeError)?;
+            let divisor = DEPOSIT_ASSETS_MAP
+                .get(deposit_asset)
+                .ok_or(Error::TypeError)?;
             let amount_in_usd = amount.div(divisor).to_f64().ok_or(Error::TypeError)?;
             let amount_as_number = Number::from_f64(amount_in_usd).ok_or(Error::TypeError)?;
             Some(Value::Number(amount_as_number))

primitives/src/targeting/eval_test.rs

@@ -253,6 +253,28 @@ mod dsl_test {
 
         assert_eq!(Some(&BigNum::from(20)), output.price.get("IMPRESSION"));
     }
+
+    #[test]
+    fn test_get_eval() {
+        let input = get_default_input();
+        let mut output = Output {
+            show: true,
+            boost: 42.0,
+            price: Default::default(),
+        };
+
+        let input_country = Function::Get("country".to_string())
+            .eval(&input, &mut output)
+            .expect("Should get input.global.country");
+        assert_eq!(Some(Value::String("bg".to_string())), input_country);
+
+        let output_boost = Function::Get("boost".to_string())
+            .eval(&input, &mut output)
+            .expect("Should get output.boost");
+        let expected_output_boost = Number::from_f64(42.0).expect("should create Number");
+
+        assert_eq!(Some(Value::Number(expected_output_boost)), output_boost);
+    }
 }
 
 mod math_functions {
@@ -1320,7 +1342,9 @@ mod string_and_array {
         for (key, value) in &*DEPOSIT_ASSETS_MAP {
             input.global.channel.deposit_asset = key.to_string();
             let amount_crypto = BigNum::from(100).mul(value);
-            let amount_usd = Some(Value::Number(Number::from_f64(100.0).expect("should create a float")));
+            let amount_usd = Some(Value::Number(
+                Number::from_f64(100.0).expect("should create a float"),
+            ));
             let rule = Rule::Function(Function::new_get_price_in_usd(Rule::Value(Value::BigNum(
                 amount_crypto,
             ))));