diff options
Diffstat (limited to 'serde_v8/tests')
| -rw-r--r-- | serde_v8/tests/de.rs | 249 | ||||
| -rw-r--r-- | serde_v8/tests/magic.rs | 180 | ||||
| -rw-r--r-- | serde_v8/tests/ser.rs | 193 |
3 files changed, 622 insertions, 0 deletions
diff --git a/serde_v8/tests/de.rs b/serde_v8/tests/de.rs new file mode 100644 index 000000000..e036fd683 --- /dev/null +++ b/serde_v8/tests/de.rs @@ -0,0 +1,249 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +use rusty_v8 as v8; + +use serde::Deserialize; + +use serde_v8::utils::{js_exec, v8_do}; +use serde_v8::Error; + +#[derive(Debug, Deserialize, PartialEq)] +struct MathOp { + pub a: u64, + pub b: u64, + pub operator: Option<String>, +} + +#[derive(Debug, PartialEq, Deserialize)] +enum EnumUnit { + A, + B, + C, +} + +#[derive(Debug, PartialEq, Deserialize)] +enum EnumPayloads { + UInt(u64), + Int(i64), + Float(f64), + Point { x: i64, y: i64 }, + Tuple(bool, i64, ()), +} + +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() { + #[allow(clippy::bool_assert_comparison)] + dedo($src, |scope, v| { + let rt = serde_v8::from_v8(scope, v); + assert!(rt.is_ok(), "from_v8(\"{}\"): {:?}", $src, rt.err()); + let t: $t = rt.unwrap(); + assert_eq!(t, $rust); + }); + } + }; +} + +macro_rules! defail { + ($fn_name:ident, $t:ty, $src:expr, $failcase:expr) => { + #[test] + fn $fn_name() { + #[allow(clippy::bool_assert_comparison)] + dedo($src, |scope, v| { + let rt: serde_v8::Result<$t> = serde_v8::from_v8(scope, v); + let rtstr = format!("{:?}", rt); + let failed_as_expected = $failcase(rt); + assert!( + failed_as_expected, + "expected failure on deserialize(\"{}\"), got: {}", + $src, rtstr + ); + }); + } + }; +} + +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 + } +); + +// Unit enums +detest!(de_enum_unit_a, EnumUnit, "'A'", EnumUnit::A); +detest!(de_enum_unit_b, EnumUnit, "'B'", EnumUnit::B); +detest!(de_enum_unit_c, EnumUnit, "'C'", EnumUnit::C); + +// Enums with payloads (tuples & struct) +detest!( + de_enum_payload_int, + EnumPayloads, + "({ Int: -123 })", + EnumPayloads::Int(-123) +); +detest!( + de_enum_payload_uint, + EnumPayloads, + "({ UInt: 123 })", + EnumPayloads::UInt(123) +); +detest!( + de_enum_payload_float, + EnumPayloads, + "({ Float: 1.23 })", + EnumPayloads::Float(1.23) +); +detest!( + de_enum_payload_point, + EnumPayloads, + "({ Point: { x: 1, y: 2 } })", + EnumPayloads::Point { x: 1, y: 2 } +); +detest!( + de_enum_payload_tuple, + EnumPayloads, + "({ Tuple: [true, 123, null ] })", + EnumPayloads::Tuple(true, 123, ()) +); + +#[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(123)) +); +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(1)), + ), + ( + "b".to_string(), + serde_json::Value::String("hello".to_string()), + ), + ("c".to_string(), serde_json::Value::Bool(true),), + ] + .drain(..) + .collect() + ) +); +detest!(de_bigint_u64, u64, "BigInt(2**59)", 1 << 59); +detest!(de_bigint_i64, i64, "BigInt(-(2**59))", -(1 << 59)); + +defail!(defail_struct, MathOp, "123", |e| e + == Err(Error::ExpectedObject)); diff --git a/serde_v8/tests/magic.rs b/serde_v8/tests/magic.rs new file mode 100644 index 000000000..95ad3eb55 --- /dev/null +++ b/serde_v8/tests/magic.rs @@ -0,0 +1,180 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +use rusty_v8 as v8; + +use serde::{Deserialize, Serialize}; + +use serde_v8::utils::{js_exec, v8_do}; +use serde_v8::Result; +use std::convert::TryFrom; + +#[derive(Deserialize)] +struct MagicOp<'s> { + #[allow(unused)] + pub a: u64, + #[allow(unused)] + pub b: u64, + pub c: serde_v8::Value<'s>, + #[allow(unused)] + pub operator: Option<String>, +} + +#[derive(Serialize)] +struct MagicContainer<'s> { + pub magic: bool, + pub contains: serde_v8::Value<'s>, +} + +#[test] +fn magic_basic() { + 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); + + // 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"}}"# + ); + }) +} + +#[test] +fn magic_buffer() { + v8_do(|| { + // Init 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); + let global = context.global(scope); + + // Simple buffer + let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])"); + let zbuf: serde_v8::Buffer = serde_v8::from_v8(scope, v8_array).unwrap(); + assert_eq!(&*zbuf, &[1, 2, 3, 4, 5]); + + // Multi buffers + let v8_arrays = + js_exec(scope, "[new Uint8Array([1,2]), new Uint8Array([3,4,5])]"); + let (z1, z2): (serde_v8::Buffer, serde_v8::Buffer) = + serde_v8::from_v8(scope, v8_arrays).unwrap(); + assert_eq!(&*z1, &[1, 2]); + assert_eq!(&*z2, &[3, 4, 5]); + + // Wrapped in option, like our current op-ABI + let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])"); + let zbuf: Option<serde_v8::Buffer> = + serde_v8::from_v8(scope, v8_array).unwrap(); + assert_eq!(&*zbuf.unwrap(), &[1, 2, 3, 4, 5]); + + // Observe mutation in JS + let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])"); + let mut zbuf: serde_v8::Buffer = + serde_v8::from_v8(scope, v8_array).unwrap(); + let key = serde_v8::to_v8(scope, "t1").unwrap(); + global.set(scope, key, v8_array); + (&mut *zbuf)[2] = 42; + let eq = js_exec(scope, "t1[2] === 42"); + assert!(eq.is_true()); + + // Shared buffers + let v8_array = + js_exec(scope, "new Uint8Array(new SharedArrayBuffer([1,2,3,4,5]))"); + let zbuf: Result<serde_v8::Buffer> = serde_v8::from_v8(scope, v8_array); + assert!(zbuf.is_err()); + + // Serialization + let buf: Vec<u8> = vec![1, 2, 3, 99, 5]; + let zbuf: serde_v8::Buffer = buf.into(); + let v8_value = serde_v8::to_v8(scope, zbuf).unwrap(); + let key = serde_v8::to_v8(scope, "t2").unwrap(); + global.set(scope, key, v8_value); + let eq = js_exec(scope, "t2[3] === 99"); + assert!(eq.is_true()); + + // Composite Serialization + #[derive(serde::Serialize)] + struct Wrapper { + a: serde_v8::Buffer, + b: serde_v8::Buffer, + } + let buf1: Vec<u8> = vec![1, 2, 33, 4, 5]; + let buf2: Vec<u8> = vec![5, 4, 3, 2, 11]; + let wrapped = Wrapper { + a: buf1.into(), + b: buf2.into(), + }; + let v8_value = serde_v8::to_v8(scope, wrapped).unwrap(); + let key = serde_v8::to_v8(scope, "t3").unwrap(); + global.set(scope, key, v8_value); + let eq = js_exec(scope, "t3.a[2] === 33"); + assert!(eq.is_true()); + let eq = js_exec(scope, "t3.b[4] === 11"); + assert!(eq.is_true()); + }) +} + +#[test] +fn magic_byte_string() { + v8_do(|| { + // Init 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); + let global = context.global(scope); + + // JS string to ByteString + let v8_string = js_exec(scope, "'test \\0\\t\\n\\r\\x7F\\x80áþÆñ'"); + let rust_reflex: serde_v8::ByteString = + serde_v8::from_v8(scope, v8_string).unwrap(); + assert_eq!( + rust_reflex.as_ref(), + b"test \0\t\n\r\x7F\x80\xE1\xFE\xC6\xF1" + ); + + // Non-Latin-1 characters + let v8_string = js_exec(scope, "'日本語'"); + let rust_reflex: Result<serde_v8::ByteString> = + serde_v8::from_v8(scope, v8_string); + assert!(rust_reflex.is_err()); + + // Windows-1252 characters that aren't Latin-1 + let v8_string = js_exec(scope, "'œ'"); + let rust_reflex: Result<serde_v8::ByteString> = + serde_v8::from_v8(scope, v8_string); + assert!(rust_reflex.is_err()); + + // ByteString to JS string + let expected = "a\x00sf:~\x7Fá\u{009C}þ\u{008A}"; + let buf: Vec<u8> = b"a\x00sf:~\x7F\xE1\x9C\xFE\x8A".as_ref().into(); + let zbuf = serde_v8::ByteString(buf); + let v8_value = serde_v8::to_v8(scope, zbuf).unwrap(); + let key = serde_v8::to_v8(scope, "actual").unwrap(); + global.set(scope, key, v8_value); + let v8_value_expected = serde_v8::to_v8(scope, expected).unwrap(); + let key_expected = serde_v8::to_v8(scope, "expected").unwrap(); + global.set(scope, key_expected, v8_value_expected); + let eq = js_exec(scope, "actual === expected"); + assert!(eq.is_true()); + }) +} diff --git a/serde_v8/tests/ser.rs b/serde_v8/tests/ser.rs new file mode 100644 index 000000000..c3ada7a6e --- /dev/null +++ b/serde_v8/tests/ser.rs @@ -0,0 +1,193 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +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]); +} +"#; +const JS_POLLUTE: &str = r#" +Object.defineProperty(Array.prototype, "0", { + set: function (v) { + throw new Error("Polluted Array 0 set"); + }, +}); + +Object.defineProperty(Object.prototype, "a", { + set: (v) => { + throw new Error("Polluted Object 'a' set"); + } +}); +"#; + +fn sercheck<T: Serialize>(val: T, code: &str, pollute: bool) -> 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); + + // Load util functions + js_exec(scope, JS_UTILS); + if pollute { + js_exec(scope, JS_POLLUTE); + } + // TryCatch scope (to catch pollution exceptions) + let scope = &mut v8::TryCatch::new(scope); + + // 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); + + // Pollution check + if let Some(message) = scope.message() { + let msg = message.get(scope).to_rust_string_lossy(scope); + panic!("JS Exception: {}", msg); + } + + // 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, false), + "Expected: {} where x={:?}", + $src, + $rust, + ); + } + }; +} + +macro_rules! sertest_polluted { + ($fn_name:ident, $rust:expr, $src:expr) => { + #[test] + fn $fn_name() { + assert!( + sercheck($rust, $src, true), + "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'])" +); + +//// +// Pollution tests +//// + +sertest_polluted!( + ser_polluted_obj, + MathOp { + a: 1, + b: 2, + operator: None + }, + "objEqual(x, { a: 1, b: 2, operator: null })" +); + +sertest_polluted!( + ser_polluted_tuple, + (true, 123, false), + "arrEqual(x, [true, 123, false])" +); + +sertest_polluted!(ser_polluted_vec, vec![1, 2, 3], "arrEqual(x, [1, 2, 3])"); |