test: Add tests for newtypes

general/src/processor/traits.rs

@@ -83,6 +83,7 @@ pub trait Processor: Sized {
     process_method!(process_context, crate::protocol::Context);
     process_method!(process_breadcrumb, crate::protocol::Breadcrumb);
     process_method!(process_template_info, crate::protocol::TemplateInfo);
+    process_method!(process_header_name, crate::protocol::HeaderName);
 
     fn process_other(
         &mut self,

general/src/protocol/mod.rs

@@ -30,7 +30,7 @@ pub use self::exception::Exception;
 pub use self::fingerprint::Fingerprint;
 pub use self::logentry::LogEntry;
 pub use self::mechanism::{CError, MachException, Mechanism, MechanismMeta, PosixSignal};
-pub use self::request::{Cookies, Headers, Query, Request};
+pub use self::request::{Cookies, HeaderName, Headers, Query, Request};
 pub use self::stacktrace::{Frame, Stacktrace};
 pub use self::tags::{TagEntry, Tags};
 pub use self::templateinfo::TemplateInfo;

general/src/protocol/request.rs

@@ -84,7 +84,8 @@ impl FromValue for Cookies {
 
 /// A "into-string" type that normalizes header names.
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Empty, ToValue, ProcessValue)]
-pub struct HeaderName(String);
+#[metastructure(process_func = "process_header_name")]
+pub struct HeaderName(pub String);
 
 impl HeaderName {
     /// Creates a normalized header name.

general/tests/test_derive.rs

@@ -0,0 +1,62 @@
+use semaphore_general::processor::process_value;
+use semaphore_general::processor::ProcessingState;
+use semaphore_general::processor::Processor;
+use semaphore_general::protocol::HeaderName;
+use semaphore_general::types::Annotated;
+use semaphore_general::types::Meta;
+use semaphore_general::types::Value;
+use semaphore_general::types::ValueAction;
+
+struct RecordingProcessor(Vec<String>);
+
+impl Processor for RecordingProcessor {
+    fn process_value(
+        &mut self,
+        _value: &mut Value,
+        _meta: &mut Meta,
+        _state: &ProcessingState<'_>,
+    ) -> ValueAction {
+        self.0.push("process_value".to_string());
+        ValueAction::Keep
+    }
+
+    fn process_string(
+        &mut self,
+        _value: &mut String,
+        _meta: &mut Meta,
+        _state: &ProcessingState<'_>,
+    ) -> ValueAction {
+        self.0.push("process_string".to_string());
+        ValueAction::Keep
+    }
+
+    fn process_header_name(
+        &mut self,
+        _value: &mut HeaderName,
+        _meta: &mut Meta,
+        _state: &ProcessingState<'_>,
+    ) -> ValueAction {
+        self.0.push("process_header_name".to_string());
+        ValueAction::Keep
+    }
+}
+
+#[test]
+fn test_enums_processor_calls() {
+    let mut processor = RecordingProcessor(vec![]);
+
+    let mut value = Annotated::new(Value::String("hi".to_string()));
+    process_value(&mut value, &mut processor, &ProcessingState::root());
+
+    assert_eq!(processor.0, &["process_value", "process_string"]);
+}
+
+#[test]
+fn test_simple_newtype() {
+    let mut processor = RecordingProcessor(vec![]);
+
+    let mut value = Annotated::new(HeaderName("hi".to_string()));
+    process_value(&mut value, &mut processor, &ProcessingState::root());
+
+    assert_eq!(processor.0, &["process_header_name", "process_string"]);
+}