[+test] primitives - targeting - impl Output::try_get()

Author: elpiel

primitives/src/targeting.rs

@@ -6,6 +6,7 @@ use chrono::Utc;
 use std::collections::HashMap;
 
 pub use eval::*;
+use serde_json::Number;
 
 mod eval;
 
@@ -213,6 +214,23 @@ pub struct Output {
     pub price: HashMap<String, BigNum>,
 }
 
+impl Output {
+    fn try_get(&self, key: &str) -> Result<Value, Error> {
+        match key {
+            "show" => Ok(Value::Bool(self.show)),
+            "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)?;
+                Ok(Value::BigNum(price.clone()))
+            },
+            _ => Err(Error::UnknownVariable)
+        }
+    }
+}
+
 impl From<&Channel> for Output {
     fn from(channel: &Channel) -> Self {
         let price = match &channel.spec.pricing_bounds {
@@ -325,6 +343,21 @@ mod test {
         assert!(input.try_get("adSlot.alexaRank").is_ok());
     }
 
+    #[test]
+    fn test_try_get_of_output() {
+        let output = Output {
+            show: false,
+            boost: 5.5,
+            price: vec![("one".to_string(), 100.into())].into_iter().collect(),
+        };
+
+        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::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"));
+    }
+
     #[test]
     fn test_output_from_channel() {
         use crate::channel::{Pricing, PricingBounds};

primitives/src/targeting/eval.rs

@@ -944,7 +944,11 @@ fn eval(input: &Input, output: &mut Output, rule: &Rule) -> Result<Option<Value>
 
             return Ok(None);
         }
-        Function::Get(key) => Some(input.try_get(key)?),
+        Function::Get(key) => match input.try_get(key) {
+            Ok(value) => Some(value),
+            Err(Error::UnknownVariable) => Some(output.try_get(key)?),
+            Err(e) => return Err(e),
+        },
         Function::Bn(value) => {
             let big_num = value.clone().try_bignum()?;
 

primitives/src/targeting/eval_test.rs

@@ -1063,9 +1063,12 @@ mod control_flow_and_logic {
             boost: 1.0,
             price: Default::default(),
         };
-        Rule::Function(Function::new_only_show_if(Value::Bool(true))).eval(&input, &mut output);
+        let result = Function::new_only_show_if(Value::Bool(true)).eval(&input, &mut output);
+        assert_eq!(Ok(None), result);
         assert!(output.show);
-        Rule::Function(Function::new_only_show_if(Value::Bool(false))).eval(&input, &mut output);
+
+        let result = Function::new_only_show_if(Value::Bool(false)).eval(&input, &mut output);
+        assert_eq!(Ok(None), result);
         assert!(!output.show);
     }
     #[test]