Fix SkipWhitespace returning early EOF on whitespace-only chunks (#2461)

Author: gabrielrondon

cmd/soroban-cli/src/commands/tx/xdr.rs

@@ -54,20 +54,26 @@ impl<R: Read> SkipWhitespace<R> {
 
 impl<R: Read> Read for SkipWhitespace<R> {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        let n = self.inner.read(buf)?;
+        loop {
+            let n = self.inner.read(buf)?;
+            if n == 0 {
+                return Ok(0);
+            }
 
-        let mut written = 0;
-        for read in 0..n {
-            if !buf[read].is_ascii_whitespace() {
-                buf[written] = buf[read];
-                written += 1;
+            let mut written = 0;
+            for read in 0..n {
+                if !buf[read].is_ascii_whitespace() {
+                    buf[written] = buf[read];
+                    written += 1;
+                }
             }
-        }
 
-        Ok(written)
+            if written > 0 {
+                return Ok(written);
+            }
+        }
     }
 }
-//
 
 pub fn unwrap_envelope_v1(tx_env: TransactionEnvelope) -> Result<Transaction, Error> {
     let TransactionEnvelope::Tx(TransactionV1Envelope { tx, .. }) = tx_env else {
@@ -83,3 +89,93 @@ pub fn add_op(tx_env: TransactionEnvelope, op: Operation) -> Result<TransactionE
     tx.operations = ops.try_into().map_err(|_| Error::TooManyOperations)?;
     Ok(tx.into())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Cursor;
+
+    struct ChunkedReader {
+        chunks: Vec<Vec<u8>>,
+        pos: usize,
+    }
+
+    impl ChunkedReader {
+        fn new(chunks: Vec<&[u8]>) -> Self {
+            Self {
+                chunks: chunks.iter().map(|c| c.to_vec()).collect(),
+                pos: 0,
+            }
+        }
+    }
+
+    impl Read for ChunkedReader {
+        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+            if self.pos >= self.chunks.len() {
+                return Ok(0);
+            }
+            let chunk = &self.chunks[self.pos];
+            let n = chunk.len().min(buf.len());
+            buf[..n].copy_from_slice(&chunk[..n]);
+            self.pos += 1;
+            Ok(n)
+        }
+    }
+
+    #[test]
+    fn skip_whitespace_preserves_content() {
+        let input = Cursor::new(b"helloworld");
+        let mut reader = SkipWhitespace::new(input);
+        let mut result = String::new();
+        reader.read_to_string(&mut result).unwrap();
+        assert_eq!(result, "helloworld");
+    }
+
+    #[test]
+    fn skip_whitespace_strips_all_whitespace_types() {
+        let input = Cursor::new(b"hello \t\n\r world");
+        let mut reader = SkipWhitespace::new(input);
+        let mut result = String::new();
+        reader.read_to_string(&mut result).unwrap();
+        assert_eq!(result, "helloworld");
+    }
+
+    #[test]
+    fn skip_whitespace_handles_only_whitespace() {
+        let input = Cursor::new(b"\n \t \r\n");
+        let mut reader = SkipWhitespace::new(input);
+        let mut result = String::new();
+        reader.read_to_string(&mut result).unwrap();
+        assert_eq!(result, "");
+    }
+
+    #[test]
+    fn skip_whitespace_handles_empty_input() {
+        let input = Cursor::new(b"");
+        let mut reader = SkipWhitespace::new(input);
+        let mut result = String::new();
+        reader.read_to_string(&mut result).unwrap();
+        assert_eq!(result, "");
+    }
+
+    #[test]
+    fn skip_whitespace_loops_past_whitespace_only_chunks() {
+        // Exercises the loop iterating more than once: first chunk is all
+        // whitespace, second chunk has content. A Cursor would satisfy both
+        // reads in one shot and would never trigger the loop.
+        let reader = ChunkedReader::new(vec![b"\n\n", b"hello", b""]);
+        let mut skipper = SkipWhitespace::new(reader);
+        let mut result = String::new();
+        skipper.read_to_string(&mut result).unwrap();
+        assert_eq!(result, "hello");
+    }
+
+    #[test]
+    fn skip_whitespace_handles_leading_trailing_whitespace() {
+        let input = Cursor::new(b"\n\nhello\n\n");
+        let mut reader = SkipWhitespace::new(input);
+        let mut result = String::new();
+        reader.read_to_string(&mut result).unwrap();
+        assert_eq!(result, "hello");
+    }
+}