test(facet-msgpack): drafted test cases (that don't pass) from JSON crate, snapshot setup

Author: lmmx

Cargo.lock

@@ -25,5 +25,6 @@ facet-serialize = { version = "0.20.0", path = "../facet-serialize" }
 eyre = "0.6.12"
 facet = { path = "../facet" }
 facet-testhelpers = { path = "../facet-testhelpers" }
+insta = "1.43.1"
 rmp-serde = "1.1"
 serde = { version = "1.0", features = ["derive"] }

facet-msgpack/Cargo.toml

@@ -0,0 +1,45 @@
+use eyre::Result;
+use facet::Facet;
+use facet_msgpack::from_slice;
+
+#[derive(Facet, Debug)]
+struct FooBar {
+    foo: u64,
+    bar: String,
+}
+
+#[test]
+fn bad_hex_1() -> Result<()> {
+    facet_testhelpers::setup();
+
+    let data = [
+        0x82, // Fixmap with 2 elements
+        0xa3, // Fixstr with length 3
+        0x66, 0x6f, 0x6f, // "foo"
+        0xce, // uint32 (correct prefix according to MessagePack spec)
+        0x00, 0x00, 0x00, 0x2a, // 42
+    ];
+    let err = from_slice::<FooBar>(&data).unwrap_err();
+    insta::assert_snapshot!(err);
+    Ok(())
+}
+
+#[test]
+fn bad_hex_2() -> Result<()> {
+    facet_testhelpers::setup();
+
+    let data = [
+        0x82, // Fixmap with 2 elements
+        0xa3, // Fixstr with length 3
+        0x66, 0x6f, 0x6f, // "foo"
+        0xce, // uint32 (correct prefix according to MessagePack spec)
+        0x00, 0x00, 0x00, 0x2a, // 42
+        0xa3, // Fixstr with length 3
+        0x62, 0x61, 0x72, // "bar"
+        0xce, // uint32 (correct prefix according to MessagePack spec)
+        0x00, 0x00, 0x00, 0x2a, // 42
+    ];
+    let err = from_slice::<FooBar>(&data).unwrap_err();
+    insta::assert_snapshot!(err);
+    Ok(())
+}

facet-msgpack/tests/integration/err.rs

@@ -0,0 +1,3 @@
+mod err;
+mod read;
+mod write;

facet-msgpack/tests/integration/mod.rs

@@ -0,0 +1 @@
+mod structs;

facet-msgpack/tests/integration/read.rs

@@ -0,0 +1,35 @@
+use eyre::Result;
+use facet::Facet;
+use facet_msgpack::from_slice;
+
+#[test]
+fn msgpack_read_bool() -> Result<()> {
+    facet_testhelpers::setup();
+
+    #[derive(Facet, Debug, PartialEq)]
+    struct BoolStruct {
+        yes: bool,
+        no: bool,
+    }
+
+    let data = [
+        0x82, // Map with 2 elements
+        0xa3, // Fixstr with length 3
+        0x79, 0x65, 0x73, // "yes"
+        0xc3, // true
+        0xa2, // Fixstr with length 2
+        0x6e, 0x6f, // "no"
+        0xc2, // false
+    ];
+
+    let s: BoolStruct = from_slice(&data)?;
+    assert_eq!(
+        s,
+        BoolStruct {
+            yes: true,
+            no: false
+        }
+    );
+
+    Ok(())
+}

facet-msgpack/tests/integration/read/drafts/bool.rs

@@ -0,0 +1,61 @@
+use eyre::Result;
+use facet::Facet;
+use facet_msgpack::from_slice;
+
+#[test]
+fn msgpack_deserialize_field_level_default_no_function() -> Result<()> {
+    facet_testhelpers::setup();
+
+    #[derive(Facet, Debug, PartialEq)]
+    struct FieldDefault {
+        foo: i32,
+        #[facet(default)]
+        bar: String,
+    }
+
+    // Only set foo, leave bar missing - should use Default for String
+    // {"foo": 789}
+    let data = [
+        0x81, // Map with 1 element
+        0xa3, 0x66, 0x6f, 0x6f, // "foo"
+        0xcd, 0x03, 0x15, // 789 (uint16)
+    ];
+
+    let s: FieldDefault = from_slice(&data)?;
+    assert_eq!(s.foo, 789, "Expected foo to be 789, got {}", s.foo);
+    assert_eq!(
+        s.bar, "",
+        "Expected bar to be empty string, got {:?}",
+        s.bar
+    );
+    Ok(())
+}
+
+#[test]
+fn msgpack_deserialize_field_level_default_function() -> Result<()> {
+    facet_testhelpers::setup();
+
+    fn default_number() -> i32 {
+        12345
+    }
+
+    #[derive(Facet, Debug, PartialEq)]
+    struct FieldDefaultFn {
+        #[facet(default = default_number())]
+        foo: i32,
+        bar: String,
+    }
+
+    // Only set bar, leave foo missing - should use default_number()
+    // {"bar": "hello"}
+    let data = [
+        0x81, // Map with 1 element
+        0xa3, 0x62, 0x61, 0x72, // "bar"
+        0xa5, 0x68, 0x65, 0x6c, 0x6c, 0x6f, // "hello"
+    ];
+
+    let s: FieldDefaultFn = from_slice(&data)?;
+    assert_eq!(s.foo, 12345, "Expected foo to be 12345, got {}", s.foo);
+    assert_eq!(s.bar, "hello", "Expected bar to be 'hello', got {}", s.bar);
+    Ok(())
+}

facet-msgpack/tests/integration/read/drafts/deny_unknown_and_default.rs

@@ -0,0 +1,108 @@
+use eyre::Result;
+use facet::Facet;
+use facet_msgpack::from_slice;
+
+#[test]
+fn msgpack_deserialize_unit_enum_variant() -> Result<()> {
+    facet_testhelpers::setup();
+
+    #[derive(Facet, Debug, PartialEq)]
+    #[repr(u8)]
+    enum FontStyle {
+        Italic,
+        Oblique,
+    }
+
+    // "Italic"
+    let data_italic = [
+        0xa6, 0x49, 0x74, 0x61, 0x6c, 0x69, 0x63, // "Italic"
+    ];
+
+    // "Oblique"
+    let data_oblique = [
+        0xa7, 0x4f, 0x62, 0x6c, 0x69, 0x71, 0x75, 0x65, // "Oblique"
+    ];
+
+    let s_italic: FontStyle = from_slice(&data_italic)?;
+    assert_eq!(s_italic, FontStyle::Italic);
+
+    let s_oblique: FontStyle = from_slice(&data_oblique)?;
+    assert_eq!(s_oblique, FontStyle::Oblique);
+
+    Ok(())
+}
+
+#[test]
+fn msgpack_deserialize_tuple_variant() -> Result<()> {
+    facet_testhelpers::setup();
+
+    #[derive(Facet, Debug, PartialEq)]
+    #[repr(u8)]
+    enum Point {
+        X(u64),
+        Y(String, bool),
+    }
+
+    // { "X": 123 }
+    let data_x = [
+        0x81, // Map with 1 element
+        0xa1, 0x58, // "X"
+        0x7b, // 123 (positive fixint)
+    ];
+
+    // { "Y": ["hello", true] }
+    let data_y = [
+        0x81, // Map with 1 element
+        0xa1, 0x59, // "Y"
+        0x92, // Array with 2 elements
+        0xa5, 0x68, 0x65, 0x6c, 0x6c, 0x6f, // "hello"
+        0xc3, // true
+    ];
+
+    let p_x: Point = from_slice(&data_x)?;
+    assert_eq!(p_x, Point::X(123));
+
+    let p_y: Point = from_slice(&data_y)?;
+    assert_eq!(p_y, Point::Y("hello".to_string(), true));
+
+    Ok(())
+}
+
+#[test]
+fn msgpack_deserialize_struct_variant() -> Result<()> {
+    facet_testhelpers::setup();
+
+    #[derive(Facet, Debug, PartialEq)]
+    #[repr(u8)]
+    #[allow(dead_code)]
+    enum Point {
+        Thing,
+        Well { made: String, i: bool, guess: i32 },
+        Other(i32),
+    }
+
+    // { "Well": { "made": "in germany", "i": false, "guess": 3 } }
+    let data = [
+        0x81, // Map with 1 element
+        0xa4, 0x57, 0x65, 0x6c, 0x6c, // "Well"
+        0x83, // Map with 3 elements
+        0xa4, 0x6d, 0x61, 0x64, 0x65, // "made"
+        0xaa, 0x69, 0x6e, 0x20, 0x67, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x79, // "in germany"
+        0xa1, 0x69, // "i"
+        0xc2, // false
+        0xa5, 0x67, 0x75, 0x65, 0x73, 0x73, // "guess"
+        0x03, // 3 (positive fixint)
+    ];
+
+    let point: Point = from_slice(&data)?;
+    assert_eq!(
+        point,
+        Point::Well {
+            made: "in germany".to_string(),
+            i: false,
+            guess: 3
+        }
+    );
+
+    Ok(())
+}

facet-msgpack/tests/integration/read/drafts/enums.rs

@@ -0,0 +1,29 @@
+use eyre::Result;
+use facet_msgpack::from_slice;
+use std::collections::HashMap;
+
+#[test]
+fn msgpack_deserialize_hashmap() -> Result<()> {
+    facet_testhelpers::setup();
+
+    // { "key1": "value1", "key2": "value2", "key3": "value3" }
+    let data = [
+        0x83, // Map with 3 elements
+        // key1: value1
+        0xa4, 0x6b, 0x65, 0x79, 0x31, // "key1"
+        0xa6, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x31, // "value1"
+        // key2: value2
+        0xa4, 0x6b, 0x65, 0x79, 0x32, // "key2"
+        0xa6, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x32, // "value2"
+        // key3: value3
+        0xa4, 0x6b, 0x65, 0x79, 0x33, // "key3"
+        0xa6, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x33, // "value3"
+    ];
+
+    let m: HashMap<String, String> = from_slice(&data)?;
+    assert_eq!(m.get("key1").unwrap(), "value1");
+    assert_eq!(m.get("key2").unwrap(), "value2");
+    assert_eq!(m.get("key3").unwrap(), "value3");
+
+    Ok(())
+}

facet-msgpack/tests/integration/read/drafts/hashmap.rs

@@ -0,0 +1,74 @@
+use eyre::Result;
+use facet::Facet;
+use facet_msgpack::from_slice;
+
+#[test]
+fn msgpack_deserialize_more_types() -> Result<()> {
+    facet_testhelpers::setup();
+
+    #[derive(Facet)]
+    struct TestStructWithMoreTypes {
+        u8_val: u8,
+        u16_val: u16,
+        i8_val: i8,
+        i16_val: i16,
+        u32_val: u32,
+        i32_val: i32,
+        u64_val: u64,
+        i64_val: i64,
+        f32_val: f32,
+        f64_val: f64,
+    }
+
+    // MessagePack encoded data representing the struct with all the numeric values
+    let data = [
+        0x8a, // Map with 10 elements
+        // u8_val: 255
+        0xa6, 0x75, 0x38, 0x5f, 0x76, 0x61, 0x6c, // "u8_val"
+        0xcc, 0xff, // unsigned 8-bit int (255)
+        // u16_val: 65535
+        0xa8, 0x75, 0x31, 0x36, 0x5f, 0x76, 0x61, 0x6c, // "u16_val"
+        0xcd, 0xff, 0xff, // unsigned 16-bit int (65535)
+        // i8_val: -128
+        0xa7, 0x69, 0x38, 0x5f, 0x76, 0x61, 0x6c, // "i8_val"
+        0xd0, 0x80, // signed 8-bit int (-128)
+        // i16_val: -32768
+        0xa8, 0x69, 0x31, 0x36, 0x5f, 0x76, 0x61, 0x6c, // "i16_val"
+        0xd1, 0x80, 0x00, // signed 16-bit int (-32768)
+        // u32_val: 4294967295
+        0xa8, 0x75, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, // "u32_val"
+        0xce, 0xff, 0xff, 0xff, 0xff, // unsigned 32-bit int (4294967295)
+        // i32_val: -2147483648
+        0xa8, 0x69, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, // "i32_val"
+        0xd2, 0x80, 0x00, 0x00, 0x00, // signed 32-bit int (-2147483648)
+        // u64_val: 18446744073709551615
+        0xa8, 0x75, 0x36, 0x34, 0x5f, 0x76, 0x61, 0x6c, // "u64_val"
+        0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+        0xff, // unsigned 64-bit int (18446744073709551615)
+        // i64_val: -9223372036854775808
+        0xa8, 0x69, 0x36, 0x34, 0x5f, 0x76, 0x61, 0x6c, // "i64_val"
+        0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, // signed 64-bit int (-9223372036854775808)
+        // f32_val: 3.14...
+        0xa8, 0x66, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, // "f32_val"
+        0xca, 0x40, 0x49, 0x0f, 0xdb, // float 32 (approx. PI)
+        // f64_val: 3.14...
+        0xa8, 0x66, 0x36, 0x34, 0x5f, 0x76, 0x61, 0x6c, // "f64_val"
+        0xcb, 0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18, // float 64 (more precise PI)
+    ];
+
+    let test_struct: TestStructWithMoreTypes = from_slice(&data)?;
+
+    assert_eq!(test_struct.u8_val, 255);
+    assert_eq!(test_struct.u16_val, 65535);
+    assert_eq!(test_struct.i8_val, -128);
+    assert_eq!(test_struct.i16_val, -32768);
+    assert_eq!(test_struct.u32_val, 4294967295);
+    assert_eq!(test_struct.i32_val, -2147483648);
+    assert_eq!(test_struct.u64_val, 18446744073709551615);
+    assert_eq!(test_struct.i64_val, -9223372036854775808);
+    assert!((test_struct.f32_val - std::f32::consts::PI).abs() < f32::EPSILON);
+    assert!((test_struct.f64_val - std::f64::consts::PI).abs() < f64::EPSILON);
+
+    Ok(())
+}