adapt to changes in gix-transport and add V2 test for unshallow fetching

Author: Byron

gix-protocol/src/fetch/response/async_io.rs

@@ -1,6 +1,5 @@
 use std::io;
 
-use futures_lite::AsyncBufReadExt;
 use gix_transport::{client, Protocol};
 
 use crate::fetch::{
@@ -16,7 +15,7 @@ async fn parse_v2_section<T>(
     parse: impl Fn(&str) -> Result<T, response::Error>,
 ) -> Result<bool, response::Error> {
     line.clear();
-    while reader.read_line(line).await? != 0 {
+    while reader.readline_str(line).await? != 0 {
         res.push(parse(line)?);
         line.clear();
     }
@@ -62,7 +61,7 @@ impl Response {
                                 Some(client::MessageKind::Flush),
                                 "If this isn't a flush packet, we don't know what's going on"
                             );
-                            reader.read_line(&mut line).await?;
+                            reader.readline_str(&mut line).await?;
                             reader.reset(Protocol::V1);
                             match reader.peek_data_line().await {
                                 Some(Ok(Ok(line))) => String::from_utf8_lossy(line),
@@ -76,7 +75,11 @@ impl Response {
                     if Response::parse_v1_ack_or_shallow_or_assume_pack(&mut acks, &mut shallows, &peeked_line) {
                         break 'lines true;
                     }
-                    assert_ne!(reader.read_line(&mut line).await?, 0, "consuming a peeked line works");
+                    assert_ne!(
+                        reader.readline_str(&mut line).await?,
+                        0,
+                        "consuming a peeked line works"
+                    );
                 };
                 Ok(Response {
                     acks,
@@ -94,7 +97,7 @@ impl Response {
                 let mut wanted_refs = Vec::<WantedRef>::new();
                 let has_pack = 'section: loop {
                     line.clear();
-                    if reader.read_line(&mut line).await? == 0 {
+                    if reader.readline_str(&mut line).await? == 0 {
                         return Err(response::Error::Io(io::Error::new(
                             io::ErrorKind::UnexpectedEof,
                             "Could not read message headline",

gix-protocol/src/fetch/response/blocking_io.rs

@@ -15,7 +15,7 @@ fn parse_v2_section<T>(
     parse: impl Fn(&str) -> Result<T, response::Error>,
 ) -> Result<bool, response::Error> {
     line.clear();
-    while reader.read_line(line)? != 0 {
+    while reader.readline_str(line)? != 0 {
         res.push(parse(line)?);
         line.clear();
     }
@@ -61,7 +61,7 @@ impl Response {
                                 Some(client::MessageKind::Flush),
                                 "If this isn't a flush packet, we don't know what's going on"
                             );
-                            reader.read_line(&mut line)?;
+                            reader.readline_str(&mut line)?;
                             reader.reset(Protocol::V1);
                             match reader.peek_data_line() {
                                 Some(Ok(Ok(line))) => String::from_utf8_lossy(line),
@@ -75,7 +75,7 @@ impl Response {
                     if Response::parse_v1_ack_or_shallow_or_assume_pack(&mut acks, &mut shallows, &peeked_line) {
                         break 'lines true;
                     }
-                    assert_ne!(reader.read_line(&mut line)?, 0, "consuming a peeked line works");
+                    assert_ne!(reader.readline_str(&mut line)?, 0, "consuming a peeked line works");
                 };
                 Ok(Response {
                     acks,
@@ -93,7 +93,7 @@ impl Response {
                 let mut wanted_refs = Vec::<WantedRef>::new();
                 let has_pack = 'section: loop {
                     line.clear();
-                    if reader.read_line(&mut line)? == 0 {
+                    if reader.readline_str(&mut line)? == 0 {
                         return Err(response::Error::Io(io::Error::new(
                             io::ErrorKind::UnexpectedEof,
                             "Could not read message headline",

gix-protocol/src/handshake/refs/tests.rs

@@ -170,6 +170,20 @@ impl<'a> gix_transport::client::ReadlineBufRead for Fixture<'a> {
         self.0 = lines.as_bytes();
         Some(Ok(Ok(gix_packetline::PacketLineRef::Data(res))))
     }
+
+    fn readline_str(&mut self, line: &mut String) -> std::io::Result<usize> {
+        use bstr::{BStr, ByteSlice};
+        let bytes: &BStr = self.0.into();
+        let mut lines = bytes.lines();
+        let res = match lines.next() {
+            None => return Ok(0),
+            Some(line) => line,
+        };
+        self.0 = lines.as_bytes();
+        let len = res.len();
+        line.push_str(res.to_str().expect("valid UTF8 in fixture"));
+        Ok(len)
+    }
 }
 
 #[cfg(feature = "async-client")]
@@ -220,4 +234,17 @@ impl<'a> gix_transport::client::ReadlineBufRead for Fixture<'a> {
         self.0 = lines.as_bytes();
         Some(Ok(Ok(gix_packetline::PacketLineRef::Data(res))))
     }
+    async fn readline_str(&mut self, line: &mut String) -> std::io::Result<usize> {
+        use bstr::{BStr, ByteSlice};
+        let bytes: &BStr = self.0.into();
+        let mut lines = bytes.lines();
+        let res = match lines.next() {
+            None => return Ok(0),
+            Some(line) => line,
+        };
+        self.0 = lines.as_bytes();
+        let len = res.len();
+        line.push_str(res.to_str().expect("valid UTF8 in fixture"));
+        Ok(len)
+    }
 }

gix-protocol/tests/fetch/response.rs

@@ -69,6 +69,37 @@ mod v1 {
             Ok(())
         }
 
+        #[maybe_async::test(feature = "blocking-client", async(feature = "async-client", async_std::test))]
+        async fn unshallow_fetch() -> crate::Result {
+            let mut provider = mock_reader("v1/fetch-unshallow.response");
+            let mut reader = provider.as_read_without_sidebands();
+            let r = fetch::Response::from_line_reader(Protocol::V1, &mut reader).await?;
+            assert_eq!(
+                r.acknowledgements(),
+                &[
+                    Acknowledgement::Common(id("f99771fe6a1b535783af3163eba95a927aae21d5")),
+                    Acknowledgement::Common(id("2d9d136fb0765f2e24c44a0f91984318d580d03b")),
+                    Acknowledgement::Common(id("dfd0954dabef3b64f458321ef15571cc1a46d552")),
+                ]
+            );
+            assert_eq!(
+                r.shallow_updates(),
+                &[
+                    ShallowUpdate::Unshallow(id("2d9d136fb0765f2e24c44a0f91984318d580d03b")),
+                    ShallowUpdate::Unshallow(id("dfd0954dabef3b64f458321ef15571cc1a46d552"))
+                ]
+            );
+            assert!(r.has_pack());
+            let mut pack = Vec::new();
+            reader.read_to_end(&mut pack).await?;
+            assert_eq!(
+                pack.len(),
+                2662,
+                "should be able to read the whole pack (and progress info)"
+            );
+            Ok(())
+        }
+
         #[maybe_async::test(feature = "blocking-client", async(feature = "async-client", async_std::test))]
         async fn fetch_acks_without_pack() -> crate::Result {
             let mut provider = mock_reader("v1/fetch-no-pack.response");
@@ -159,6 +190,38 @@ mod v2 {
             Ok(())
         }
 
+        #[maybe_async::test(feature = "blocking-client", async(feature = "async-client", async_std::test))]
+        async fn unshallow_fetch() -> crate::Result {
+            let mut provider = mock_reader("v2/fetch-unshallow.response");
+            let mut reader = provider.as_read_without_sidebands();
+            let r = fetch::Response::from_line_reader(Protocol::V2, &mut reader).await?;
+            assert_eq!(
+                r.acknowledgements(),
+                &[
+                    Acknowledgement::Common(id("f99771fe6a1b535783af3163eba95a927aae21d5")),
+                    Acknowledgement::Common(id("2d9d136fb0765f2e24c44a0f91984318d580d03b")),
+                    Acknowledgement::Common(id("dfd0954dabef3b64f458321ef15571cc1a46d552")),
+                    Acknowledgement::Ready,
+                ]
+            );
+            assert_eq!(
+                r.shallow_updates(),
+                &[
+                    ShallowUpdate::Unshallow(id("2d9d136fb0765f2e24c44a0f91984318d580d03b")),
+                    ShallowUpdate::Unshallow(id("dfd0954dabef3b64f458321ef15571cc1a46d552"))
+                ]
+            );
+            assert!(r.has_pack());
+            let mut pack = Vec::new();
+            reader.read_to_end(&mut pack).await?;
+            assert_eq!(
+                pack.len(),
+                2664,
+                "should be able to read the whole pack (and progress info)"
+            );
+            Ok(())
+        }
+
         #[maybe_async::test(feature = "blocking-client", async(feature = "async-client", async_std::test))]
         async fn empty_shallow_clone() -> crate::Result {
             let mut provider = mock_reader("v2/clone-deepen-5.response");
@@ -199,7 +262,7 @@ mod v2 {
         async fn fetch_acks_without_pack() -> crate::Result {
             let mut provider = mock_reader("v2/fetch-no-pack.response");
             let r = fetch::Response::from_line_reader(Protocol::V2, &mut provider.as_read_without_sidebands()).await?;
-            assert_eq!(r.acknowledgements(), &[Acknowledgement::Nak,]);
+            assert_eq!(r.acknowledgements(), &[Acknowledgement::Nak]);
             Ok(())
         }