Skip to main content

sendmock_core/template/
template_expression_evaluation.rs

1use minijinja::value::Serde;
2use serde_json::Value;
3
4use super::template_environment::build_template_environment;
5use super::template_functions::TemplateFunctions;
6use super::template_problems::find_template_problems;
7use super::template_renderer::describe_render_error;
8use super::{TemplateEscape, TemplateProblem, TemplateProblemSeverity, TemplateRenderMode};
9
10/// Evaluates one expression, such as `data.to[0].address | lower` or `random_int(1, 9)`, and
11/// keeps its type: a number stays a number and a list stays a list. A missing value is null.
12pub fn evaluate_template_expression(
13    expression_text: &str,
14    template_context: &Value,
15    template_functions: &dyn TemplateFunctions,
16    render_mode: TemplateRenderMode,
17) -> Result<Value, TemplateProblem> {
18    let wrapped_text = format!("{{{{ {expression_text} }}}}");
19    let function_names = template_functions.function_names();
20    let static_problem =
21        find_template_problems(&wrapped_text, template_context, &function_names, false)
22            .into_iter()
23            .find(|problem| problem.severity == TemplateProblemSeverity::Error);
24    if let Some(static_problem) = static_problem {
25        return Err(static_problem);
26    }
27    let environment = build_template_environment(
28        template_functions.to_shared(),
29        TemplateEscape::None,
30        render_mode,
31    );
32    let evaluated_value = environment
33        .compile_expression(expression_text)
34        .and_then(|expression| expression.eval(minijinja::Value::from(Serde(template_context))))
35        .map_err(|evaluation_error| describe_render_error(expression_text, &evaluation_error))?;
36    if evaluated_value.is_undefined() {
37        return Ok(Value::Null);
38    }
39    Ok(serde_json::to_value(&evaluated_value).unwrap_or_default())
40}
41
42#[cfg(test)]
43mod tests {
44    use std::sync::Arc;
45
46    use serde_json::json;
47
48    use super::*;
49    use crate::{FixedClock, SeededRandomSource, StandardTemplateFunctions};
50
51    fn evaluate(
52        expression_text: &str,
53        render_mode: TemplateRenderMode,
54    ) -> Result<Value, TemplateProblem> {
55        let template_functions = StandardTemplateFunctions::new(
56            Arc::new(FixedClock::new(0)),
57            Arc::new(SeededRandomSource::new(1)),
58        );
59        let template_context = json!({ "data": { "to": [{ "address": "Ann@Example.com" }] } });
60        evaluate_template_expression(
61            expression_text,
62            &template_context,
63            &template_functions,
64            render_mode,
65        )
66    }
67
68    #[test]
69    fn expressions_keep_their_type() {
70        assert_eq!(
71            evaluate("data.to[0].address | lower", TemplateRenderMode::Strict),
72            Ok(json!("ann@example.com"))
73        );
74        assert_eq!(
75            evaluate("random_int(7, 7)", TemplateRenderMode::Strict),
76            Ok(json!(7))
77        );
78        assert_eq!(
79            evaluate("data.to | length > 0", TemplateRenderMode::Strict),
80            Ok(json!(true))
81        );
82        assert_eq!(
83            evaluate("data.missing", TemplateRenderMode::Lenient),
84            Ok(Value::Null)
85        );
86    }
87
88    #[test]
89    fn bad_expressions_are_reported() {
90        let unknown_function = evaluate("shout()", TemplateRenderMode::Lenient);
91        let syntax_error = evaluate("data.to[", TemplateRenderMode::Lenient);
92
93        assert_eq!(
94            unknown_function.map_err(|problem| problem.message),
95            Err("Unknown function: shout".to_owned())
96        );
97        assert!(syntax_error.is_err_and(|problem| problem.message.starts_with("Syntax error")));
98    }
99}