Adding debugging for restwrapper test

Author: keelerm84

eventsource-client/src/client.rs

@@ -397,6 +397,7 @@ where
         loop {
             let this = self.as_mut().project();
             if let Some(event) = this.event_parser.get_event() {
+                trace!("We got an event {:?}", event);
                 return match event {
                     SSE::Event(ref evt) => {
                         *this.last_event_id = evt.id.clone();

eventsource-client/src/event_parser.rs

@@ -6,7 +6,7 @@ use pin_project::pin_project;
 
 use super::error::{Error, Result};
 
-#[derive(Default, PartialEq)]
+#[derive(Default, PartialEq, Debug)]
 struct EventData {
     pub event_type: String,
     pub data: String,
@@ -83,17 +83,19 @@ pub struct Event {
     pub retry: Option<u64>,
 }
 
-const LOGIFY_MAX_CHARS: usize = 100;
+// const LOGIFY_MAX_CHARS: usize = 100;
 fn logify(bytes: &[u8]) -> &str {
     let stringified = from_utf8(bytes).unwrap_or("<bad utf8>");
-    if stringified.len() <= LOGIFY_MAX_CHARS {
-        stringified
-    } else {
-        &stringified[..LOGIFY_MAX_CHARS - 1]
-    }
+    stringified
+    // if stringified.len() <= LOGIFY_MAX_CHARS {
+    //     stringified
+    // } else {
+    //     &stringified[..LOGIFY_MAX_CHARS - 1]
+    // }
 }
 
 fn parse_field(line: &[u8]) -> Result<Option<(&str, &str)>> {
+    trace!("Parse field {:?}", logify(line));
     if line.is_empty() {
         return Err(Error::InvalidLine(
             "should never try to parse an empty line (probably a bug)".into(),
@@ -125,10 +127,12 @@ fn parse_field(line: &[u8]) -> Result<Option<(&str, &str)>> {
 }
 
 fn parse_key(key: &[u8]) -> Result<&str> {
+    trace!("Parse key {:?}", logify(key));
     from_utf8(key).map_err(|e| Error::InvalidLine(format!("malformed key: {:?}", e)))
 }
 
 fn parse_value(value: &[u8]) -> Result<&str> {
+    trace!("Parse value {:?}", logify(value));
     from_utf8(value).map_err(|e| Error::InvalidLine(format!("malformed value: {:?}", e)))
 }
 
@@ -199,10 +203,18 @@ impl EventParser {
     //
     // Returns the event for dispatch if it is complete.
     fn parse_complete_lines_into_event(&mut self) -> Result<()> {
+        trace!(
+            "Preparing to parse_complete_lines_into_event {:?} {:?}",
+            self.event_data,
+            self.last_event_id
+        );
+
         loop {
+            trace!("loop");
             let mut seen_empty_line = false;
 
             while let Some(line) = self.complete_lines.pop_front() {
+                trace!("line {:?}", line);
                 if line.is_empty() && self.event_data.is_some() {
                     seen_empty_line = true;
                     break;
@@ -211,6 +223,8 @@ impl EventParser {
                 }
 
                 if let Some((key, value)) = parse_field(&line)? {
+                    trace!("key {:}, value {:?}", key, value);
+
                     let id = &self.last_event_id;
                     let event_data = self
                         .event_data
@@ -259,6 +273,7 @@ impl EventParser {
                 );
 
                 if let Some(event_data) = event_data {
+                    trace!("event_data {:?}", event_data);
                     match Option::<SSE>::try_from(event_data) {
                         Err(e) => return Err(e),
                         Ok(None) => (),
@@ -281,13 +296,15 @@ impl EventParser {
     // incomplete lines from previous chunks.
     fn decode_and_buffer_lines(&mut self, chunk: Bytes) {
         let mut lines = chunk.split_inclusive(|&b| b == b'\n' || b == b'\r');
+        trace!("decode_and_buffer_lines {:?}", lines);
         // The first and last elements in this split are special. The spec requires lines to be
         // terminated. But lines may span chunks, so:
         //  * the last line, if non-empty (i.e. if chunk didn't end with a line terminator),
         //    should be buffered as an incomplete line
         //  * the first line should be appended to the incomplete line, if any
 
         if let Some(incomplete_line) = self.incomplete_line.as_mut() {
+            trace!("incomplete_line {:?}", incomplete_line);
             if let Some(line) = lines.next() {
                 trace!(
                     "extending line from previous chunk: {:?}+{:?}",
@@ -301,24 +318,31 @@ impl EventParser {
                     // terminator, but also where the entire line is a terminator.
                     match line.last().unwrap() {
                         b'\r' => {
+                            trace!("\\r branch");
                             incomplete_line.extend_from_slice(&line[..line.len() - 1]);
                             let il = self.incomplete_line.take();
                             self.complete_lines.push_back(il.unwrap());
                             self.last_char_was_cr = true;
                         }
                         b'\n' => {
+                            trace!("\\n branch");
                             incomplete_line.extend_from_slice(&line[..line.len() - 1]);
                             let il = self.incomplete_line.take();
                             self.complete_lines.push_back(il.unwrap());
                         }
-                        _ => incomplete_line.extend_from_slice(line),
+                        _ => {
+                            trace!("other branch");
+                            incomplete_line.extend_from_slice(line);
+                        }
                     };
                 }
             }
         }
 
         let mut lines = lines.peekable();
+        trace!("lines {:?}", lines);
         while let Some(line) = lines.next() {
+            trace!("line {:?}", line);
             if let Some(actually_complete_line) = self.incomplete_line.take() {
                 // we saw the next line, so the previous one must have been complete after all
                 trace!(