summaryrefslogtreecommitdiff
path: root/serde_v8/tests
diff options
context:
space:
mode:
Diffstat (limited to 'serde_v8/tests')
-rw-r--r--serde_v8/tests/de.rs169
-rw-r--r--serde_v8/tests/magic.rs57
-rw-r--r--serde_v8/tests/ser.rs129
3 files changed, 355 insertions, 0 deletions
diff --git a/serde_v8/tests/de.rs b/serde_v8/tests/de.rs
new file mode 100644
index 000000000..d0721c0f8
--- /dev/null
+++ b/serde_v8/tests/de.rs
@@ -0,0 +1,169 @@
+use rusty_v8 as v8;
+
+use serde::Deserialize;
+
+use serde_v8::utils::{js_exec, v8_do};
+
+#[derive(Debug, Deserialize, PartialEq)]
+struct MathOp {
+ pub a: u64,
+ pub b: u64,
+ pub operator: Option<String>,
+}
+
+fn dedo(
+ code: &str,
+ f: impl FnOnce(&mut v8::HandleScope, v8::Local<v8::Value>),
+) {
+ v8_do(|| {
+ let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
+ let handle_scope = &mut v8::HandleScope::new(isolate);
+ let context = v8::Context::new(handle_scope);
+ let scope = &mut v8::ContextScope::new(handle_scope, context);
+ let v = js_exec(scope, code);
+
+ f(scope, v);
+ })
+}
+
+macro_rules! detest {
+ ($fn_name:ident, $t:ty, $src:expr, $rust:expr) => {
+ #[test]
+ fn $fn_name() {
+ dedo($src, |scope, v| {
+ let rt = serde_v8::from_v8(scope, v);
+ assert!(rt.is_ok(), format!("from_v8(\"{}\"): {:?}", $src, rt.err()));
+ let t: $t = rt.unwrap();
+ assert_eq!(t, $rust);
+ });
+ }
+ };
+}
+
+detest!(de_option_some, Option<bool>, "true", Some(true));
+detest!(de_option_null, Option<bool>, "null", None);
+detest!(de_option_undefined, Option<bool>, "undefined", None);
+detest!(de_unit_null, (), "null", ());
+detest!(de_unit_undefined, (), "undefined", ());
+detest!(de_bool, bool, "true", true);
+detest!(de_u64, u64, "32", 32);
+detest!(de_string, String, "'Hello'", "Hello".to_owned());
+detest!(de_vec_u64, Vec<u64>, "[1,2,3,4,5]", vec![1, 2, 3, 4, 5]);
+detest!(
+ de_vec_str,
+ Vec<String>,
+ "['hello', 'world']",
+ vec!["hello".to_owned(), "world".to_owned()]
+);
+detest!(
+ de_tuple,
+ (u64, bool, ()),
+ "[123, true, null]",
+ (123, true, ())
+);
+detest!(
+ de_mathop,
+ MathOp,
+ "({a: 1, b: 3, c: 'ignored'})",
+ MathOp {
+ a: 1,
+ b: 3,
+ operator: None
+ }
+);
+
+#[test]
+fn de_f64() {
+ dedo("12345.0", |scope, v| {
+ let x: f64 = serde_v8::from_v8(scope, v).unwrap();
+ assert!((x - 12345.0).abs() < f64::EPSILON);
+ });
+}
+
+#[test]
+fn de_map() {
+ use std::collections::HashMap;
+
+ dedo("({a: 1, b: 2, c: 3})", |scope, v| {
+ let map: HashMap<String, u64> = serde_v8::from_v8(scope, v).unwrap();
+ assert_eq!(map.get("a").cloned(), Some(1));
+ assert_eq!(map.get("b").cloned(), Some(2));
+ assert_eq!(map.get("c").cloned(), Some(3));
+ assert_eq!(map.get("nada"), None);
+ })
+}
+
+////
+// JSON tests: serde_json::Value compatibility
+////
+
+detest!(
+ de_json_null,
+ serde_json::Value,
+ "null",
+ serde_json::Value::Null
+);
+detest!(
+ de_json_bool,
+ serde_json::Value,
+ "true",
+ serde_json::Value::Bool(true)
+);
+detest!(
+ de_json_int,
+ serde_json::Value,
+ "123",
+ serde_json::Value::Number(serde_json::Number::from_f64(123.0).unwrap())
+);
+detest!(
+ de_json_float,
+ serde_json::Value,
+ "123.45",
+ serde_json::Value::Number(serde_json::Number::from_f64(123.45).unwrap())
+);
+detest!(
+ de_json_string,
+ serde_json::Value,
+ "'Hello'",
+ serde_json::Value::String("Hello".to_string())
+);
+detest!(
+ de_json_vec_string,
+ serde_json::Value,
+ "['Hello', 'World']",
+ serde_json::Value::Array(vec![
+ serde_json::Value::String("Hello".to_string()),
+ serde_json::Value::String("World".to_string())
+ ])
+);
+detest!(
+ de_json_tuple,
+ serde_json::Value,
+ "[true, 'World', 123.45, null]",
+ serde_json::Value::Array(vec![
+ serde_json::Value::Bool(true),
+ serde_json::Value::String("World".to_string()),
+ serde_json::Value::Number(serde_json::Number::from_f64(123.45).unwrap()),
+ serde_json::Value::Null,
+ ])
+);
+detest!(
+ de_json_object,
+ serde_json::Value,
+ "({a: 1, b: 'hello', c: true})",
+ serde_json::Value::Object(
+ vec![
+ (
+ "a".to_string(),
+ serde_json::Value::Number(serde_json::Number::from_f64(1.0).unwrap()),
+ ),
+ (
+ "b".to_string(),
+ serde_json::Value::String("hello".to_string()),
+ ),
+ ("c".to_string(), serde_json::Value::Bool(true),),
+ ]
+ .drain(..)
+ .collect()
+ )
+);
diff --git a/serde_v8/tests/magic.rs b/serde_v8/tests/magic.rs
new file mode 100644
index 000000000..2825bcc9a
--- /dev/null
+++ b/serde_v8/tests/magic.rs
@@ -0,0 +1,57 @@
+use rusty_v8 as v8;
+
+use serde::{Deserialize, Serialize};
+
+use serde_v8::utils::{js_exec, v8_init, v8_shutdown};
+use std::convert::TryFrom;
+
+#[derive(Deserialize)]
+struct MagicOp<'s> {
+ pub a: u64,
+ pub b: u64,
+ pub c: serde_v8::Value<'s>,
+ pub operator: Option<String>,
+}
+
+#[derive(Serialize)]
+struct MagicContainer<'s> {
+ pub magic: bool,
+ pub contains: serde_v8::Value<'s>,
+}
+
+#[test]
+fn magic_basic() {
+ v8_init();
+
+ {
+ let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
+ let handle_scope = &mut v8::HandleScope::new(isolate);
+ let context = v8::Context::new(handle_scope);
+ let scope = &mut v8::ContextScope::new(handle_scope, context);
+
+ // Decode
+ let v = js_exec(scope, "({a: 1, b: 3, c: 'abracadabra'})");
+ let mop: MagicOp = serde_v8::from_v8(scope, v).unwrap();
+ // Check string
+ let v8_value: v8::Local<v8::Value> = mop.c.into();
+ let vs = v8::Local::<v8::String>::try_from(v8_value).unwrap();
+ let s = vs.to_rust_string_lossy(scope);
+ assert_eq!(s, "abracadabra");
+
+ // Encode
+ let container = MagicContainer {
+ magic: true,
+ contains: v.into(),
+ };
+ let vc = serde_v8::to_v8(scope, container).unwrap();
+ // JSON stringify & check
+ let json = v8::json::stringify(scope, vc).unwrap();
+ let s2 = json.to_rust_string_lossy(scope);
+ assert_eq!(
+ s2,
+ r#"{"magic":true,"contains":{"a":1,"b":3,"c":"abracadabra"}}"#
+ );
+ }
+
+ v8_shutdown();
+}
diff --git a/serde_v8/tests/ser.rs b/serde_v8/tests/ser.rs
new file mode 100644
index 000000000..1da8f6ff2
--- /dev/null
+++ b/serde_v8/tests/ser.rs
@@ -0,0 +1,129 @@
+use rusty_v8 as v8;
+
+use serde::Serialize;
+use serde_json::json;
+use serde_v8::utils::{js_exec, v8_do};
+
+#[derive(Debug, Serialize, PartialEq)]
+struct MathOp {
+ pub a: u64,
+ pub b: u64,
+ pub operator: Option<String>,
+}
+
+// Utility JS code (obj equality, etc...)
+const JS_UTILS: &str = r#"
+// Shallow obj equality (don't use deep objs for now)
+function objEqual(a, b) {
+ const ka = Object.keys(a);
+ const kb = Object.keys(b);
+ return ka.length === kb.length && ka.every(k => a[k] === b[k]);
+}
+
+function arrEqual(a, b) {
+ return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+"#;
+
+fn sercheck<T: Serialize>(val: T, code: &str) -> bool {
+ let mut equal = false;
+
+ v8_do(|| {
+ // Setup isolate
+ let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
+ let handle_scope = &mut v8::HandleScope::new(isolate);
+ let context = v8::Context::new(handle_scope);
+ let scope = &mut v8::ContextScope::new(handle_scope, context);
+
+ // Set value as "x" in global scope
+ let global = context.global(scope);
+ let v8_key = serde_v8::to_v8(scope, "x").unwrap();
+ let v8_val = serde_v8::to_v8(scope, val).unwrap();
+ global.set(scope, v8_key, v8_val);
+
+ // Load util functions
+ js_exec(scope, JS_UTILS);
+ // Execute equality check in JS (e.g: x == ...)
+ let v = js_exec(scope, code);
+ // Cast to bool
+ equal = serde_v8::from_v8(scope, v).unwrap();
+ });
+
+ equal
+}
+
+macro_rules! sertest {
+ ($fn_name:ident, $rust:expr, $src:expr) => {
+ #[test]
+ fn $fn_name() {
+ assert!(
+ sercheck($rust, $src),
+ format!("Expected: {} where x={:?}", $src, $rust),
+ );
+ }
+ };
+}
+
+sertest!(ser_option_some, Some(true), "x === true");
+sertest!(ser_option_null, None as Option<bool>, "x === null");
+sertest!(ser_unit_null, (), "x === null");
+sertest!(ser_bool, true, "x === true");
+sertest!(ser_u64, 32, "x === 32");
+sertest!(ser_f64, 12345.0, "x === 12345.0");
+sertest!(ser_string, "Hello".to_owned(), "x === 'Hello'");
+sertest!(ser_vec_u64, vec![1, 2, 3, 4, 5], "arrEqual(x, [1,2,3,4,5])");
+sertest!(
+ ser_vec_string,
+ vec!["hello".to_owned(), "world".to_owned(),],
+ "arrEqual(x, ['hello', 'world'])"
+);
+sertest!(ser_tuple, (123, true, ()), "arrEqual(x, [123, true, null])");
+sertest!(
+ ser_mathop,
+ MathOp {
+ a: 1,
+ b: 3,
+ operator: None
+ },
+ "objEqual(x, {a: 1, b: 3, operator: null})"
+);
+
+sertest!(
+ ser_map,
+ {
+ let map: std::collections::BTreeMap<&str, u32> =
+ vec![("a", 1), ("b", 2), ("c", 3)].drain(..).collect();
+ map
+ },
+ "objEqual(x, {a: 1, b: 2, c: 3})"
+);
+
+////
+// JSON tests: json!() compatibility
+////
+sertest!(ser_json_bool, json!(true), "x === true");
+sertest!(ser_json_null, json!(null), "x === null");
+sertest!(ser_json_int, json!(123), "x === 123");
+sertest!(ser_json_f64, json!(123.45), "x === 123.45");
+sertest!(ser_json_string, json!("Hello World"), "x === 'Hello World'");
+sertest!(ser_json_obj_empty, json!({}), "objEqual(x, {})");
+sertest!(
+ ser_json_obj,
+ json!({"a": 1, "b": 2, "c": true}),
+ "objEqual(x, {a: 1, b: 2, c: true})"
+);
+sertest!(
+ ser_json_vec_int,
+ json!([1, 2, 3, 4, 5]),
+ "arrEqual(x, [1,2,3,4,5])"
+);
+sertest!(
+ ser_json_vec_string,
+ json!(["Goodbye", "Dinosaurs 👋☄️"]),
+ "arrEqual(x, ['Goodbye', 'Dinosaurs 👋☄️'])"
+);
+sertest!(
+ ser_json_tuple,
+ json!([true, 42, "nabla"]),
+ "arrEqual(x, [true, 42, 'nabla'])"
+);
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-31 04:59:10 +0000