Move test_data to main crate

Signed-off-by: Dejan Bosanac <[email protected]>

Author: dejanb

src/binding/actix/server_request.rs

@@ -156,23 +156,18 @@ mod tests {
     use super::*;
     use actix_web::test;
 
+    use crate::test::fixtures;
     use crate::{EventBuilder, EventBuilderV10};
     use serde_json::json;
-
     #[actix_rt::test]
     async fn test_request() {
-        let expected = EventBuilderV10::new()
-            .id("0001")
-            .ty("example.test")
-            .source("http://localhost/")
-            .extension("someint", "10")
-            .build()
-            .unwrap();
+        let mut expected = fixtures::v10::minimal();
+        expected.set_extension("someint", "10");
 
         let (req, payload) = test::TestRequest::post()
             .header("ce-specversion", "1.0")
             .header("ce-id", "0001")
-            .header("ce-type", "example.test")
+            .header("ce-type", "test_event.test_application")
             .header("ce-source", "http://localhost/")
             .header("ce-someint", "10")
             .to_http_parts();

src/event/builder.rs

@@ -58,3 +58,223 @@ pub enum Error {
     ))]
     InvalidUriRefError { attribute_name: &'static str },
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::test::fixtures;
+    use crate::Event;
+    use crate::EventBuilder;
+    use crate::EventBuilderV03;
+    use crate::EventBuilderV10;
+    use claim::*;
+    use rstest::rstest;
+    use serde_json::{json, Value};
+    use serde_yaml;
+
+    /// Test conversions
+
+    #[test]
+    fn v10_to_v03() {
+        let in_event = fixtures::v10::full_json_data();
+        let out_event = EventBuilderV03::from(in_event).build().unwrap();
+        assert_eq!(fixtures::v03::full_json_data(), out_event)
+    }
+
+    #[test]
+    fn v03_to_v10() {
+        let in_event = fixtures::v03::full_json_data();
+        let out_event = EventBuilderV10::from(in_event).build().unwrap();
+        assert_eq!(fixtures::v10::full_json_data(), out_event)
+    }
+
+    /// Test YAML
+    /// This test checks if the usage of serde_json::Value makes the Deserialize implementation incompatible with
+    /// other Deserializers
+    #[test]
+    fn deserialize_yaml_should_succeed() {
+        let input = r#"
+    id: aaa
+    type: bbb
+    source: http://localhost
+    datacontenttype: application/json
+    data: true
+    specversion: "1.0"
+    "#;
+
+        let expected = EventBuilderV10::new()
+            .id("aaa")
+            .ty("bbb")
+            .source("http://localhost")
+            .data("application/json", serde_json::Value::Bool(true))
+            .build()
+            .unwrap();
+
+        let deserialize_result: Result<Event, serde_yaml::Error> = serde_yaml::from_str(input);
+        assert_ok!(&deserialize_result);
+        let deserialized = deserialize_result.unwrap();
+        assert_eq!(deserialized, expected)
+    }
+
+    /// Test Json
+    /// This test is a parametrized test that uses data from tests/test_data
+    #[rstest(
+        in_event,
+        out_json,
+        case::minimal_v03(fixtures::v03::minimal(), fixtures::v03::minimal_json()),
+        case::full_v03_no_data(fixtures::v03::full_no_data(), fixtures::v03::full_no_data_json()),
+        case::full_v03_with_json_data(
+            fixtures::v03::full_json_data(),
+            fixtures::v03::full_json_data_json()
+        ),
+        case::full_v03_with_xml_string_data(
+            fixtures::v03::full_xml_string_data(),
+            fixtures::v03::full_xml_string_data_json()
+        ),
+        case::full_v03_with_xml_base64_data(
+            fixtures::v03::full_xml_binary_data(),
+            fixtures::v03::full_xml_base64_data_json()
+        ),
+        case::minimal_v10(fixtures::v10::minimal(), fixtures::v10::minimal_json()),
+        case::full_v10_no_data(fixtures::v10::full_no_data(), fixtures::v10::full_no_data_json()),
+        case::full_v10_with_json_data(
+            fixtures::v10::full_json_data(),
+            fixtures::v10::full_json_data_json()
+        ),
+        case::full_v10_with_xml_string_data(
+            fixtures::v10::full_xml_string_data(),
+            fixtures::v10::full_xml_string_data_json()
+        ),
+        case::full_v10_with_xml_base64_data(
+            fixtures::v10::full_xml_binary_data(),
+            fixtures::v10::full_xml_base64_data_json()
+        )
+    )]
+    fn serialize_should_succeed(in_event: Event, out_json: Value) {
+        // Event -> serde_json::Value
+        let serialize_result = serde_json::to_value(in_event.clone());
+        assert_ok!(&serialize_result);
+        let actual_json = serialize_result.unwrap();
+        assert_eq!(&actual_json, &out_json);
+
+        // serde_json::Value -> String
+        let actual_json_serialized = actual_json.to_string();
+        assert_eq!(actual_json_serialized, out_json.to_string());
+
+        // String -> Event
+        let deserialize_result: Result<Event, serde_json::Error> =
+            serde_json::from_str(&actual_json_serialized);
+        assert_ok!(&deserialize_result);
+        let deserialize_json = deserialize_result.unwrap();
+        assert_eq!(deserialize_json, in_event)
+    }
+
+    /// This test is a parametrized test that uses data from tests/test_data
+    #[rstest(
+        in_json,
+        out_event,
+        case::minimal_v03(fixtures::v03::minimal_json(), fixtures::v03::minimal()),
+        case::full_v03_no_data(fixtures::v03::full_no_data_json(), fixtures::v03::full_no_data()),
+        case::full_v03_with_json_data(
+            fixtures::v03::full_json_data_json(),
+            fixtures::v03::full_json_data()
+        ),
+        case::full_v03_with_json_base64_data(
+            fixtures::v03::full_json_base64_data_json(),
+            fixtures::v03::full_json_data()
+        ),
+        case::full_v03_with_xml_string_data(
+            fixtures::v03::full_xml_string_data_json(),
+            fixtures::v03::full_xml_string_data()
+        ),
+        case::full_v03_with_xml_base64_data(
+            fixtures::v03::full_xml_base64_data_json(),
+            fixtures::v03::full_xml_binary_data()
+        ),
+        case::minimal_v10(fixtures::v10::minimal_json(), fixtures::v10::minimal()),
+        case::full_v10_no_data(fixtures::v10::full_no_data_json(), fixtures::v10::full_no_data()),
+        case::full_v10_with_json_data(
+            fixtures::v10::full_json_data_json(),
+            fixtures::v10::full_json_data()
+        ),
+        case::full_v10_with_json_base64_data(
+            fixtures::v10::full_json_base64_data_json(),
+            fixtures::v10::full_json_data()
+        ),
+        case::full_v10_with_xml_string_data(
+            fixtures::v10::full_xml_string_data_json(),
+            fixtures::v10::full_xml_string_data()
+        ),
+        case::full_v10_with_xml_base64_data(
+            fixtures::v10::full_xml_base64_data_json(),
+            fixtures::v10::full_xml_binary_data()
+        )
+    )]
+    fn deserialize_json_should_succeed(in_json: Value, out_event: Event) {
+        let deserialize_result: Result<Event, serde_json::Error> = serde_json::from_value(in_json);
+        assert_ok!(&deserialize_result);
+        let deserialize_json = deserialize_result.unwrap();
+        assert_eq!(deserialize_json, out_event)
+    }
+
+    #[test]
+    fn deserialize_with_null_attribute() {
+        let in_json = json!({
+            "specversion" : "1.0",
+            "type" : "com.example.someevent",
+            "source" : "/mycontext",
+            "id" : "A234-1234-1234",
+            "time" : null,
+            "comexampleextension1" : "value",
+            "comexampleothervalue" : 5,
+            "datacontenttype" : "text/xml",
+            "data" : "<much wow=\"xml\"/>"
+        });
+
+        let out_event = EventBuilderV10::new()
+            .ty("com.example.someevent")
+            .source("/mycontext")
+            .id("A234-1234-1234")
+            .data("text/xml", "<much wow=\"xml\"/>")
+            .extension("comexampleextension1", "value")
+            .extension("comexampleothervalue", 5)
+            .build()
+            .unwrap();
+
+        let deserialize_result: Result<Event, serde_json::Error> = serde_json::from_value(in_json);
+        assert_ok!(&deserialize_result);
+        let deserialize_json = deserialize_result.unwrap();
+        assert_eq!(deserialize_json, out_event)
+    }
+
+    #[test]
+    fn deserialize_with_null_ext() {
+        let in_json = json!({
+            "specversion" : "1.0",
+            "type" : "com.example.someevent",
+            "source" : "/mycontext",
+            "id" : "A234-1234-1234",
+            "time" : "2018-04-05T17:31:00Z",
+            "comexampleextension1" : "value",
+            "comexampleothervalue" : 5,
+            "unsetextension": null,
+            "datacontenttype" : "text/xml",
+            "data" : "<much wow=\"xml\"/>"
+        });
+
+        let out_event = EventBuilderV10::new()
+            .ty("com.example.someevent")
+            .source("/mycontext")
+            .id("A234-1234-1234")
+            .time("2018-04-05T17:31:00Z")
+            .data("text/xml", "<much wow=\"xml\"/>")
+            .extension("comexampleextension1", "value")
+            .extension("comexampleothervalue", 5)
+            .build()
+            .unwrap();
+
+        let deserialize_result: Result<Event, serde_json::Error> = serde_json::from_value(in_json);
+        assert_ok!(&deserialize_result);
+        let deserialize_json = deserialize_result.unwrap();
+        assert_eq!(deserialize_json, out_event)
+    }
+}

src/event/message.rs

@@ -118,6 +118,8 @@ impl BinarySerializer<Event> for EventBinarySerializer {
 mod tests {
     use super::*;
     use crate::message::Error;
+    use crate::test::fixtures;
+    use std::convert::TryInto;
 
     #[test]
     fn binary_deserializer_unrecognized_attribute_v03() {
@@ -168,4 +170,65 @@ mod tests {
                 .to_string()
         )
     }
+
+    #[test]
+    fn message_v03_roundtrip_structured() -> Result<()> {
+        assert_eq!(
+            fixtures::v03::full_json_data(),
+            StructuredDeserializer::into_event(fixtures::v03::full_json_data())?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn message_v03_roundtrip_binary() -> Result<()> {
+        //TODO this code smells because we're missing a proper way in the public APIs
+        // to destructure an event and rebuild it
+        let wanna_be_expected = fixtures::v03::full_json_data();
+        let data: serde_json::Value = wanna_be_expected.data().unwrap().clone().try_into()?;
+        let bytes = serde_json::to_vec(&data)?;
+        let expected = EventBuilderV03::from(wanna_be_expected.clone())
+            .data(wanna_be_expected.datacontenttype().unwrap(), bytes)
+            .build()
+            .unwrap();
+
+        assert_eq!(
+            expected,
+            BinaryDeserializer::into_event(fixtures::v03::full_json_data())?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn message_v10_roundtrip_structured() -> Result<()> {
+        assert_eq!(
+            fixtures::v10::full_json_data(),
+            StructuredDeserializer::into_event(fixtures::v10::full_json_data())?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn message_v10_roundtrip_binary() -> Result<()> {
+        //TODO this code smells because we're missing a proper way in the public APIs
+        // to destructure an event and rebuild it
+        let wanna_be_expected = fixtures::v10::full_json_data();
+        let data: serde_json::Value = wanna_be_expected
+            .data()
+            .cloned()
+            .unwrap()
+            .try_into()
+            .unwrap();
+        let bytes = serde_json::to_vec(&data)?;
+        let expected = EventBuilderV10::from(wanna_be_expected.clone())
+            .data(wanna_be_expected.datacontenttype().unwrap(), bytes)
+            .build()
+            .unwrap();
+
+        assert_eq!(
+            expected,
+            BinaryDeserializer::into_event(fixtures::v10::full_json_data())?
+        );
+        Ok(())
+    }
 }

src/event/v03/attributes.rs

@@ -220,8 +220,20 @@ impl crate::event::message::AttributesDeserializer for super::Attributes {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::test::fixtures;
     use chrono::NaiveDateTime;
 
+    #[test]
+    fn iter_v03_test() {
+        let in_event = fixtures::v03::full_json_data();
+        let mut iter_v03 = in_event.iter_attributes();
+
+        assert_eq!(
+            ("specversion", AttributeValue::SpecVersion(SpecVersion::V03)),
+            iter_v03.next().unwrap()
+        );
+    }
+
     #[test]
     fn iterator_test_v03() {
         let a = Attributes {