summaryrefslogtreecommitdiffstats
path: root/vendor/handlebars/tests
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/handlebars/tests')
-rw-r--r--vendor/handlebars/tests/block_context.rs106
-rw-r--r--vendor/handlebars/tests/data_helper.rs29
-rw-r--r--vendor/handlebars/tests/escape.rs43
-rw-r--r--vendor/handlebars/tests/helper_function_lifetime.rs36
-rw-r--r--vendor/handlebars/tests/helper_macro.rs76
-rw-r--r--vendor/handlebars/tests/helper_with_space.rs36
-rw-r--r--vendor/handlebars/tests/root_var.rs21
-rw-r--r--vendor/handlebars/tests/subexpression.rs169
-rw-r--r--vendor/handlebars/tests/template_names.rs35
9 files changed, 551 insertions, 0 deletions
diff --git a/vendor/handlebars/tests/block_context.rs b/vendor/handlebars/tests/block_context.rs
new file mode 100644
index 000000000..bbaa89a62
--- /dev/null
+++ b/vendor/handlebars/tests/block_context.rs
@@ -0,0 +1,106 @@
+use handlebars::Handlebars;
+use serde_json::json;
+
+#[test]
+fn test_partial_with_blocks() {
+ let hbs = Handlebars::new();
+
+ let data = json!({
+ "a": [
+ {"b": 1},
+ {"b": 2},
+ ],
+ });
+
+ let template = "{{#*inline \"test\"}}{{b}};{{/inline}}{{#each a as |z|}}{{> test z}}{{/each}}";
+ assert_eq!(hbs.render_template(template, &data).unwrap(), "1;2;");
+}
+
+#[test]
+fn test_root_with_blocks() {
+ let hbs = Handlebars::new();
+
+ let data = json!({
+ "a": [
+ {"b": 1},
+ {"b": 2},
+ ],
+ "b": 3,
+ });
+
+ let template =
+ "{{#*inline \"test\"}}{{b}}:{{@root.b}};{{/inline}}{{#each a}}{{> test}}{{/each}}";
+ assert_eq!(hbs.render_template(template, &data).unwrap(), "1:3;2:3;");
+}
+
+#[test]
+fn test_singular_and_pair_block_params() {
+ let hbs = Handlebars::new();
+
+ let data = json!([
+ {"value": 11},
+ {"value": 22},
+ ]);
+
+ let template =
+ "{{#each this as |b index|}}{{b.value}}{{#each this as |value key|}}:{{key}},{{/each}}{{/each}}";
+ assert_eq!(
+ hbs.render_template(template, &data).unwrap(),
+ "11:value,22:value,"
+ );
+}
+
+#[test]
+fn test_nested_each() {
+ let hbs = Handlebars::new();
+
+ let data = json!({
+ "classes": [
+ {
+ "methods": [
+ {"id": 1},
+ {"id": 2}
+ ]
+ },
+ {
+ "methods": [
+ {"id": 3},
+ {"id": 4}
+ ]
+ },
+ ],
+ });
+
+ let template = "{{#each classes as |class|}}{{#each class.methods as |method|}}{{method.id}};{{/each}}{{/each}}";
+ assert_eq!(hbs.render_template(template, &data).unwrap(), "1;2;3;4;");
+}
+
+#[test]
+fn test_referencing_block_param_from_upper_scope() {
+ let hbs = Handlebars::new();
+
+ let data = json!({
+ "classes": [
+ {
+ "methods": [
+ {"id": 1},
+ {"id": 2}
+ ],
+ "private": false
+ },
+ {
+ "methods": [
+ {"id": 3},
+ {"id": 4}
+ ],
+ "private": true
+ },
+ ],
+ });
+
+ let template = "{{#each classes as |class|}}{{#each class.methods as |method|}}{{class.private}}|{{method.id}};{{/each}}{{/each}}";
+ assert_eq!(
+ hbs.render_template(template, &data).unwrap(),
+ "false|1;false|2;true|3;true|4;"
+ );
+}
diff --git a/vendor/handlebars/tests/data_helper.rs b/vendor/handlebars/tests/data_helper.rs
new file mode 100644
index 000000000..7734b0d7a
--- /dev/null
+++ b/vendor/handlebars/tests/data_helper.rs
@@ -0,0 +1,29 @@
+use handlebars::*;
+use serde_json::json;
+
+struct HelperWithBorrowedData<'a>(&'a String);
+
+impl<'a> HelperDef for HelperWithBorrowedData<'a> {
+ fn call<'_reg: '_rc, '_rc>(
+ &self,
+ _: &Helper<'_reg, '_rc>,
+ _: &'_reg Handlebars,
+ _: &Context,
+ _: &mut RenderContext,
+ out: &mut dyn Output,
+ ) -> Result<(), RenderError> {
+ out.write(self.0).map_err(RenderError::from)
+ }
+}
+
+#[test]
+fn test_helper_with_ref_data() {
+ let s = "hello helper".to_owned();
+ let the_helper = HelperWithBorrowedData(&s);
+
+ let mut r = Handlebars::new();
+ r.register_helper("hello", Box::new(the_helper));
+
+ let s = r.render_template("Output: {{hello}}", &json!({})).unwrap();
+ assert_eq!(s, "Output: hello helper".to_owned());
+}
diff --git a/vendor/handlebars/tests/escape.rs b/vendor/handlebars/tests/escape.rs
new file mode 100644
index 000000000..563ab76b9
--- /dev/null
+++ b/vendor/handlebars/tests/escape.rs
@@ -0,0 +1,43 @@
+extern crate handlebars;
+
+#[macro_use]
+extern crate serde_json;
+
+use handlebars::{handlebars_helper, Handlebars};
+
+#[test]
+fn test_escape_216() {
+ let hbs = Handlebars::new();
+
+ let data = json!({
+ "FOO": "foo",
+ "BAR": "bar"
+ });
+
+ assert_eq!(
+ hbs.render_template(r"\\\\ {{FOO}} {{BAR}} {{FOO}}{{BAR}} {{FOO}}#{{BAR}} {{FOO}}//{{BAR}} {{FOO}}\\{{FOO}} {{FOO}}\\\\{{FOO}}\\\{{FOO}} \\\{{FOO}} \{{FOO}} \{{FOO}}", &data).unwrap(),
+ r"\\\\ foo bar foobar foo#bar foo//bar foo\foo foo\\\foo\\foo \\foo {{FOO}} {{FOO}}"
+ );
+}
+
+#[test]
+fn test_string_no_escape_422() {
+ let mut hbs = Handlebars::new();
+
+ handlebars_helper!(replace: |input: str, from: str, to: str| {
+ input.replace(from, to)
+ });
+ hbs.register_helper("replace", Box::new(replace));
+
+ assert_eq!(
+ r#"some\ path"#,
+ hbs.render_template(r#"{{replace "some/path" "/" "\\ " }}"#, &())
+ .unwrap()
+ );
+
+ assert_eq!(
+ r#"some\path"#,
+ hbs.render_template(r#"{{replace "some/path" "/" "\\" }}"#, &())
+ .unwrap()
+ );
+}
diff --git a/vendor/handlebars/tests/helper_function_lifetime.rs b/vendor/handlebars/tests/helper_function_lifetime.rs
new file mode 100644
index 000000000..fd21f3004
--- /dev/null
+++ b/vendor/handlebars/tests/helper_function_lifetime.rs
@@ -0,0 +1,36 @@
+use handlebars::*;
+
+fn ifcond<'reg, 'rc>(
+ h: &Helper<'reg, 'rc>,
+ handle: &'reg Handlebars,
+ ctx: &'rc Context,
+ render_ctx: &mut RenderContext<'reg, 'rc>,
+ out: &mut dyn Output,
+) -> Result<(), RenderError> {
+ let cond = h
+ .param(0)
+ .and_then(|ref v| v.value().as_bool())
+ .ok_or(RenderError::new("Ifcond takes a boolean !"))? as bool;
+ let temp = if cond { h.template() } else { h.inverse() };
+ match temp {
+ Some(t) => t.render(handle, ctx, render_ctx, out),
+ None => Ok(()),
+ }
+}
+
+#[test]
+fn test_helper() {
+ let mut handlebars = Handlebars::new();
+
+ // register some custom helpers
+ handlebars.register_helper("ifcond", Box::new(ifcond));
+
+ // make data and render it
+ let data = true;
+ assert_eq!(
+ "yes",
+ handlebars
+ .render_template("{{#ifcond this}}yes{{/ifcond}}", &data)
+ .unwrap()
+ );
+}
diff --git a/vendor/handlebars/tests/helper_macro.rs b/vendor/handlebars/tests/helper_macro.rs
new file mode 100644
index 000000000..9a8d2dc07
--- /dev/null
+++ b/vendor/handlebars/tests/helper_macro.rs
@@ -0,0 +1,76 @@
+#[macro_use]
+extern crate handlebars;
+#[macro_use]
+extern crate serde_json;
+
+use handlebars::Handlebars;
+
+handlebars_helper!(lower: |s: str| s.to_lowercase());
+handlebars_helper!(upper: |s: str| s.to_uppercase());
+handlebars_helper!(hex: |v: i64| format!("0x{:x}", v));
+handlebars_helper!(money: |v: i64, {cur: str="$"}| format!("{}{}.00", cur, v));
+handlebars_helper!(all_hash: |{cur: str="$"}| cur);
+handlebars_helper!(nargs: |*args| args.len());
+handlebars_helper!(has_a: |{a:i64 = 99}, **kwargs|
+ format!("{}, {}", a, kwargs.get("a").is_some()));
+handlebars_helper!(tag: |t: str| format!("<{}>", t));
+
+#[test]
+fn test_macro_helper() {
+ let mut hbs = Handlebars::new();
+
+ hbs.register_helper("lower", Box::new(lower));
+ hbs.register_helper("upper", Box::new(upper));
+ hbs.register_helper("hex", Box::new(hex));
+ hbs.register_helper("money", Box::new(money));
+ hbs.register_helper("nargs", Box::new(nargs));
+ hbs.register_helper("has_a", Box::new(has_a));
+ hbs.register_helper("tag", Box::new(tag));
+
+ let data = json!("Teixeira");
+
+ assert_eq!(
+ hbs.render_template("{{lower this}}", &data).unwrap(),
+ "teixeira"
+ );
+ assert_eq!(
+ hbs.render_template("{{upper this}}", &data).unwrap(),
+ "TEIXEIRA"
+ );
+ assert_eq!(hbs.render_template("{{hex 16}}", &()).unwrap(), "0x10");
+
+ assert_eq!(
+ hbs.render_template("{{money 5000}}", &()).unwrap(),
+ "$5000.00"
+ );
+ assert_eq!(
+ hbs.render_template("{{money 5000 cur=\"£\"}}", &())
+ .unwrap(),
+ "£5000.00"
+ );
+ assert_eq!(
+ hbs.render_template("{{nargs 1 1 1 1 1}}", &()).unwrap(),
+ "5"
+ );
+ assert_eq!(hbs.render_template("{{nargs}}", &()).unwrap(), "0");
+
+ assert_eq!(
+ hbs.render_template("{{has_a a=1 b=2}}", &()).unwrap(),
+ "1, true"
+ );
+
+ assert_eq!(
+ hbs.render_template("{{has_a x=1 b=2}}", &()).unwrap(),
+ "99, false"
+ );
+
+ assert_eq!(
+ hbs.render_template("{{tag \"html\"}}", &()).unwrap(),
+ "&lt;html&gt;"
+ );
+
+ assert_eq!(
+ hbs.render_template("{{{tag \"html\"}}}", &()).unwrap(),
+ "<html>"
+ );
+}
diff --git a/vendor/handlebars/tests/helper_with_space.rs b/vendor/handlebars/tests/helper_with_space.rs
new file mode 100644
index 000000000..5a55ab122
--- /dev/null
+++ b/vendor/handlebars/tests/helper_with_space.rs
@@ -0,0 +1,36 @@
+use handlebars::*;
+use serde_json::json;
+
+fn dump<'reg, 'rc>(
+ h: &Helper<'reg, 'rc>,
+ _: &'reg Handlebars,
+ _: &Context,
+ _: &mut RenderContext,
+ out: &mut dyn Output,
+) -> Result<(), RenderError> {
+ assert_eq!(2, h.params().len());
+
+ let result = h
+ .params()
+ .iter()
+ .map(|p| p.value().render())
+ .collect::<Vec<String>>()
+ .join(", ");
+ out.write(&result)?;
+
+ Ok(())
+}
+
+#[test]
+fn test_helper_with_space_param() {
+ let mut r = Handlebars::new();
+ r.register_helper("echo", Box::new(dump));
+
+ let s = r
+ .render_template(
+ "Output: {{echo \"Mozilla Firefox\" \"Google Chrome\"}}",
+ &json!({}),
+ )
+ .unwrap();
+ assert_eq!(s, "Output: Mozilla Firefox, Google Chrome".to_owned());
+}
diff --git a/vendor/handlebars/tests/root_var.rs b/vendor/handlebars/tests/root_var.rs
new file mode 100644
index 000000000..fb310f6c1
--- /dev/null
+++ b/vendor/handlebars/tests/root_var.rs
@@ -0,0 +1,21 @@
+extern crate handlebars;
+#[macro_use]
+extern crate serde_json;
+
+use handlebars::Handlebars;
+
+#[test]
+fn test_root_var() {
+ let hbs = Handlebars::new();
+
+ let data = json!({
+ "a": [1, 2, 3, 4],
+ "b": "top"
+ });
+
+ assert_eq!(
+ hbs.render_template("{{#each a}}{{@root/b}}: {{this}};{{/each}}", &data)
+ .unwrap(),
+ "top: 1;top: 2;top: 3;top: 4;"
+ );
+}
diff --git a/vendor/handlebars/tests/subexpression.rs b/vendor/handlebars/tests/subexpression.rs
new file mode 100644
index 000000000..a0ef4090f
--- /dev/null
+++ b/vendor/handlebars/tests/subexpression.rs
@@ -0,0 +1,169 @@
+extern crate handlebars;
+#[macro_use]
+extern crate serde_json;
+
+use std::sync::atomic::{AtomicU16, Ordering};
+use std::sync::Arc;
+
+use handlebars::{Context, Handlebars, Helper, HelperDef, RenderContext, RenderError, ScopedJson};
+
+#[test]
+fn test_subexpression() {
+ let hbs = Handlebars::new();
+
+ let data = json!({"a": 1, "b": 0, "c": 2});
+
+ assert_eq!(
+ hbs.render_template("{{#if (gt a b)}}Success{{else}}Failed{{/if}}", &data)
+ .unwrap(),
+ "Success"
+ );
+
+ assert_eq!(
+ hbs.render_template("{{#if (gt a c)}}Success{{else}}Failed{{/if}}", &data)
+ .unwrap(),
+ "Failed"
+ );
+
+ assert_eq!(
+ hbs.render_template("{{#if (not (gt a c))}}Success{{else}}Failed{{/if}}", &data)
+ .unwrap(),
+ "Success"
+ );
+
+ assert_eq!(
+ hbs.render_template("{{#if (not (gt a b))}}Success{{else}}Failed{{/if}}", &data)
+ .unwrap(),
+ "Failed"
+ );
+
+ // no argument provided for not
+ assert!(hbs
+ .render_template("{{#if (not)}}Success{{else}}Failed{{/if}}", &data)
+ .is_err());
+
+ // json literal
+ assert_eq!(
+ hbs.render_template("{{#if (not true)}}Success{{else}}Failed{{/if}}", &data)
+ .unwrap(),
+ "Failed"
+ );
+ assert_eq!(
+ hbs.render_template("{{#if (not false)}}Success{{else}}Failed{{/if}}", &data)
+ .unwrap(),
+ "Success"
+ );
+}
+
+#[test]
+fn test_strict_mode() {
+ let mut hbs = Handlebars::new();
+ hbs.set_strict_mode(true);
+
+ let data = json!({"a": 1});
+
+ assert!(hbs
+ .render_template("{{#if (eq a 1)}}Success{{else}}Failed{{/if}}", &data)
+ .is_ok());
+ assert!(hbs
+ .render_template("{{#if (eq z 1)}}Success{{else}}Failed{{/if}}", &data)
+ .is_err())
+}
+
+#[test]
+fn invalid_json_path() {
+ // The data here is not important
+ let data = &Vec::<()>::new();
+
+ let hbs = Handlebars::new();
+
+ let error = hbs.render_template("{{x[]@this}}", &data).unwrap_err();
+
+ let expected = "Error rendering \"Unnamed template\" line 1, col 1: Helper not defined: \"x\"";
+
+ assert_eq!(format!("{}", error), expected);
+}
+
+struct MyHelper;
+
+impl HelperDef for MyHelper {
+ fn call_inner<'reg: 'rc, 'rc>(
+ &self,
+ _: &Helper<'reg, 'rc>,
+ _: &'reg Handlebars,
+ _: &'rc Context,
+ _: &mut RenderContext<'reg, 'rc>,
+ ) -> Result<ScopedJson<'reg, 'rc>, RenderError> {
+ Ok(ScopedJson::Derived(json!({
+ "a": 1,
+ "b": 2,
+ })))
+ }
+}
+
+#[test]
+fn test_lookup_with_subexpression() {
+ let mut registry = Handlebars::new();
+ registry.register_helper("myhelper", Box::new(MyHelper {}));
+ registry
+ .register_template_string("t", "{{ lookup (myhelper) \"a\" }}")
+ .unwrap();
+
+ let result = registry.render("t", &json!({})).unwrap();
+
+ assert_eq!("1", result);
+}
+
+struct CallCounterHelper {
+ pub(crate) c: Arc<AtomicU16>,
+}
+
+impl HelperDef for CallCounterHelper {
+ fn call_inner<'reg: 'rc, 'rc>(
+ &self,
+ h: &Helper<'reg, 'rc>,
+ _: &'reg Handlebars,
+ _: &'rc Context,
+ _: &mut RenderContext<'reg, 'rc>,
+ ) -> Result<ScopedJson<'reg, 'rc>, RenderError> {
+ // inc counter
+ self.c.fetch_add(1, Ordering::SeqCst);
+
+ if let Some(_) = h.param(0) {
+ Ok(json!({
+ "a": 1,
+ })
+ .into())
+ } else {
+ Ok(json!(null).into())
+ }
+ }
+}
+
+#[test]
+fn test_helper_call_count() {
+ let mut registry = Handlebars::new();
+
+ let counter = Arc::new(AtomicU16::new(0));
+ let helper = Box::new(CallCounterHelper { c: counter.clone() });
+
+ registry.register_helper("myhelper", helper);
+
+ registry
+ .render_template(
+ "{{#if (myhelper a)}}something{{else}}nothing{{/if}}",
+ &json!(null),
+ ) // If returns true
+ .unwrap();
+
+ assert_eq!(1, counter.load(Ordering::SeqCst));
+
+ registry
+ .render_template(
+ "{{#if (myhelper)}}something{{else}}nothing{{/if}}",
+ &json!(null),
+ ) // If returns false
+ .unwrap();
+
+ assert_eq!(2, counter.load(Ordering::SeqCst));
+}
diff --git a/vendor/handlebars/tests/template_names.rs b/vendor/handlebars/tests/template_names.rs
new file mode 100644
index 000000000..eea9e033e
--- /dev/null
+++ b/vendor/handlebars/tests/template_names.rs
@@ -0,0 +1,35 @@
+extern crate handlebars;
+#[macro_use]
+extern crate serde_json;
+
+use handlebars::Handlebars;
+
+#[test]
+fn test_walk_dir_template_name() {
+ let mut hbs = Handlebars::new();
+
+ let data = json!({
+ "a": [1, 2, 3, 4],
+ "b": "top"
+ });
+
+ hbs.register_template_string("foo/bar", "{{@root/b}}")
+ .unwrap();
+ assert_eq!(hbs.render_template("{{> foo/bar }}", &data).unwrap(), "top");
+}
+
+#[test]
+fn test_walk_dir_template_name_with_args() {
+ let mut hbs = Handlebars::new();
+
+ let data = json!({
+ "a": [1, 2, 3, 4],
+ "b": "top"
+ });
+
+ hbs.register_template_string("foo/bar", "{{this}}").unwrap();
+ assert_eq!(
+ hbs.render_template("{{> foo/bar b }}", &data).unwrap(),
+ "top"
+ );
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-08 05:29:46 +0000