sendmock_core/template/
template_expression_evaluation.rs1use 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
10pub 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}