ci: test get_blob_stream against old/new skopeo

Run tests in containers with skopeo 1.18 and >=1.19 to exercise both GetBlob fallback and GetRawBlob paths.

Assisted-by: Codex CLI (GPT-5.2)

Author: 0verflowme

.github/workflows/ci.yaml

@@ -51,3 +51,51 @@ jobs:
           fetch-depth: 20
       - name: Test ostree-rs-ext
         run: ./ci/test-ostree-rs-ext.sh
+
+  test-old-skopeo:
+    name: Test (old skopeo)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+          fetch-depth: 20
+      - name: Test in AlmaLinux bootc container (skopeo 1.18)
+        run: |
+          set -euxo pipefail
+          rm -rf .ci-cargo-home
+          mkdir -p .ci-cargo-home
+          docker run --rm \
+            -e CARGO_TARGET_DIR=/tmp/target \
+            -e EXPECT_BLOB_STREAM_SOURCE=GetBlob \
+            -v "$PWD:/src:ro" \
+            -v "$PWD/.ci-cargo-home:/root/.cargo" \
+            -w /src \
+            quay.io/almalinuxorg/almalinux-bootc:10.0 \
+            sh -lc 'dnf -y install cargo rustc >/dev/null && skopeo --version && cargo test --all-features -- --nocapture --quiet'
+          sudo rm -rf .ci-cargo-home
+
+  test-new-skopeo:
+    name: Test (new skopeo)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+          fetch-depth: 20
+      - name: Test in Fedora container (skopeo >= 1.19)
+        run: |
+          set -euxo pipefail
+          rm -rf .ci-cargo-home
+          mkdir -p .ci-cargo-home
+          docker run --rm \
+            -e CARGO_TARGET_DIR=/tmp/target \
+            -e EXPECT_BLOB_STREAM_SOURCE=GetRawBlob \
+            -v "$PWD:/src:ro" \
+            -v "$PWD/.ci-cargo-home:/root/.cargo" \
+            -w /src \
+            quay.io/fedora/fedora:41 \
+            sh -lc 'dnf -y install cargo rustc skopeo >/dev/null && skopeo --version && cargo test --all-features -- --nocapture --quiet'
+          sudo rm -rf .ci-cargo-home

src/imageproxy.rs

@@ -950,7 +950,7 @@ impl ImageProxy {
     ) -> Result<BlobStream<'a>> {
         let fallback_to_get_blob = || async move {
             let (reader, driver) = self.get_blob(img, digest, expected_size).await?;
-            let driver = async move { driver.await }.boxed();
+            let driver = driver.boxed();
             Ok(BlobStream {
                 source: BlobStreamSource::GetBlob,
                 expected_size,
@@ -1317,6 +1317,130 @@ mod tests {
         Ok(())
     }
 
+    #[tokio::test]
+    async fn test_get_blob_stream_oci_dir() -> Result<()> {
+        use std::str::FromStr;
+
+        if !check_skopeo() {
+            return Ok(());
+        }
+
+        fn sha256_digest(bytes: &[u8]) -> Digest {
+            let mut h = sha2::Sha256::new();
+            h.update(bytes);
+            Digest::from_str(&format!("sha256:{}", hex::encode(h.finalize()))).unwrap()
+        }
+
+        fn write_blob(root: &std::path::Path, bytes: &[u8]) -> Result<(Digest, u64)> {
+            let digest = sha256_digest(bytes);
+            let size = bytes.len() as u64;
+            let dir = root.join("blobs").join("sha256");
+            std::fs::create_dir_all(&dir)?;
+            std::fs::write(dir.join(digest.digest()), bytes)?;
+            Ok((digest, size))
+        }
+
+        let td = tempfile::tempdir()?;
+        std::fs::write(
+            td.path().join("oci-layout"),
+            serde_json::to_vec(&serde_json::json!({"imageLayoutVersion":"1.0.0"}))?,
+        )?;
+
+        let layer_bytes = b"layer bytes";
+        let (layer_digest, layer_size) = write_blob(td.path(), layer_bytes)?;
+
+        let config_bytes = serde_json::to_vec(&serde_json::json!({
+            "architecture": "amd64",
+            "os": "linux",
+            "rootfs": {
+                "type": "layers",
+                "diff_ids": [layer_digest.to_string()],
+            },
+            "config": {},
+        }))?;
+        let (config_digest, config_size) = write_blob(td.path(), &config_bytes)?;
+
+        let manifest_bytes = serde_json::to_vec(&serde_json::json!({
+            "schemaVersion": 2,
+            "mediaType": "application/vnd.oci.image.manifest.v1+json",
+            "config": {
+                "mediaType": "application/vnd.oci.image.config.v1+json",
+                "digest": config_digest.to_string(),
+                "size": config_size,
+            },
+            "layers": [{
+                "mediaType": "application/vnd.oci.image.layer.v1.tar",
+                "digest": layer_digest.to_string(),
+                "size": layer_size,
+            }],
+        }))?;
+        let (manifest_digest, manifest_size) = write_blob(td.path(), &manifest_bytes)?;
+
+        std::fs::write(
+            td.path().join("index.json"),
+            serde_json::to_vec(&serde_json::json!({
+                "schemaVersion": 2,
+                "mediaType": "application/vnd.oci.image.index.v1+json",
+                "manifests": [{
+                    "mediaType": "application/vnd.oci.image.manifest.v1+json",
+                    "digest": manifest_digest.to_string(),
+                    "size": manifest_size,
+                    "annotations": {
+                        "org.opencontainers.image.ref.name": "test",
+                    }
+                }]
+            }))?,
+        )?;
+
+        let proxy = ImageProxy::new().await?;
+        let imgref = format!("oci:{}:test", td.path().display());
+        let img = proxy.open_image(&imgref).await?;
+
+        let expected_source = match std::env::var("EXPECT_BLOB_STREAM_SOURCE").ok().as_deref() {
+            Some("GetRawBlob") => BlobStreamSource::GetRawBlob,
+            Some("GetBlob") => BlobStreamSource::GetBlob,
+            Some(v) => {
+                return Err(Error::Other(
+                    format!(
+                        "Invalid EXPECT_BLOB_STREAM_SOURCE={v}; expected GetRawBlob or GetBlob"
+                    )
+                    .into(),
+                ));
+            }
+            None => {
+                if proxy.supports_get_raw_blob() {
+                    BlobStreamSource::GetRawBlob
+                } else {
+                    BlobStreamSource::GetBlob
+                }
+            }
+        };
+
+        let BlobStream {
+            source,
+            reader,
+            driver,
+            ..
+        } = proxy
+            .get_blob_stream(&img, &layer_digest, layer_size)
+            .await?;
+        assert_eq!(source, expected_source);
+
+        let mut reader = reader;
+        let mut sink = tokio::io::sink();
+        let read = async move {
+            let n = tokio::io::copy(&mut *reader, &mut sink).await?;
+            Result::Ok(n)
+        };
+        let (n, driver) = tokio::join!(read, driver);
+        assert_eq!(n?, layer_size);
+        driver?;
+
+        proxy.close_image(&img).await?;
+        proxy.finalize().await?;
+        Ok(())
+    }
+
     // Helper to create a dummy OwnedFd using memfd_create for testing.
     fn create_dummy_fd() -> OwnedFd {
         memfd_create(c"test-fd", MemfdFlags::CLOEXEC).unwrap()