test(general): Added basic snapshot tests for normalize and event par…

…sing (#154)

common/src/upstream.rs

@@ -78,7 +78,7 @@ impl<'a> UpstreamDescriptor<'a> {
 
     /// Returns a URL relative to the upstream.
     pub fn get_url(&self, path: &str) -> Url {
-        format!("{}{}", self, path.trim_left_matches(&['/'][..]))
+        format!("{}{}", self, path.trim_start_matches(&['/'][..]))
             .parse()
             .unwrap()
     }

general/Cargo.toml

@@ -25,9 +25,11 @@ serde_urlencoded = "0.5.4"
 smallvec = { version = "0.6.7", features = ["serde"] }
 url = "1.7.2"
 uuid = { version = "0.7.1", features = ["v4", "serde"] }
+insta = "0.4.1"
 
 [dev-dependencies]
 difference = "2.0.0"
 
 [features]
 bench = []
+

general/benches/benchmarks.rs

@@ -4,15 +4,16 @@
 macro_rules! benchmark {
     ($sdk:ident) => {
         mod $sdk {
+            extern crate test;
             use std::collections::BTreeSet;
 
             use semaphore_general::processor::process_value;
             use semaphore_general::protocol::Event;
-            use semaphore_general::store::{StoreConfig, StoreNormalizeProcessor};
+            use semaphore_general::store::{StoreConfig, StoreProcessor};
             use semaphore_general::types::Annotated;
 
             fn load_json() -> String {
-                let path = concat!("fixtures/payloads/", stringify!($sdk), ".json");
+                let path = concat!("tests/fixtures/payloads/", stringify!($sdk), ".json");
                 std::fs::read_to_string(path).expect("failed to load json")
             }
 
@@ -50,15 +51,17 @@ macro_rules! benchmark {
                     valid_platforms: platforms,
                     max_secs_in_future: Some(3600),
                     max_secs_in_past: Some(2_592_000),
+                    enable_trimming: Some(true),
+                    max_stacktrace_frames: Some(50),
                 };
 
                 let json = load_json();
-                let mut processor = StoreNormalizeProcessor::new(config, None);
+                let mut processor = StoreProcessor::new(config, None);
                 let event = Annotated::<Event>::from_json(&json).expect("failed to deserialize");
 
                 b.iter(|| {
                     let mut event = test::black_box(event.clone());
-                    process_value(&mut event, &mut processor, Default::default());
+                    process_value(&mut event, &mut processor, &Default::default());
                     event
                 });
             }

general/src/types/annotated.rs

@@ -109,6 +109,9 @@ impl From<bool> for ValueAction {
 #[derive(Clone, PartialEq)]
 pub struct Annotated<T>(pub Option<T>, pub Meta);
 
+/// An utility to serialize annotated objects with payload.
+pub struct SerializableAnnotated<'a, T>(pub &'a Annotated<T>);
+
 impl<T: fmt::Debug> fmt::Debug for Annotated<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
@@ -418,21 +421,12 @@ impl<T> Default for Annotated<T> {
     }
 }
 
-impl<T: Serialize> Serialize for Annotated<T> {
+impl<'a, T: ToValue> Serialize for SerializableAnnotated<'a, T> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        Serialize::serialize(&self.value(), serializer)
-    }
-}
-
-impl<'de, T: Deserialize<'de>> Deserialize<'de> for Annotated<T> {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        Ok(Annotated(
-            Deserialize::deserialize(deserializer)?,
-            Default::default(),
-        ))
+        self.0.serialize_with_meta(serializer)
     }
 }
 

general/src/types/mod.rs

@@ -10,7 +10,7 @@ mod meta;
 mod traits;
 mod value;
 
-pub use self::annotated::{Annotated, MetaMap, MetaTree, ValueAction};
+pub use self::annotated::{Annotated, MetaMap, MetaTree, SerializableAnnotated, ValueAction};
 pub use self::impls::SerializePayload;
 pub use self::meta::{Error, ErrorKind, Meta, Range, Remark, RemarkType};
 pub use self::traits::{Empty, FromValue, SkipSerialization, ToValue};