wip test case

lib/src/fixture.rs

@@ -2,6 +2,8 @@
 
 #![allow(missing_docs)]
 
+use crate::chunking::ObjectMetaSized;
+use crate::container::{Config, ExportOpts, ImageReference, Transport};
 use crate::objectsource::{ObjectMeta, ObjectSourceMeta};
 use crate::prelude::*;
 use crate::{gio, glib};
@@ -587,4 +589,42 @@ impl Fixture {
         outf.flush()?;
         Ok(path.into())
     }
+
+    /// Export the current ref as a container image.
+    /// This defaults to using chunking.
+    #[context("Exporting container")]
+    pub async fn export_container(&self) -> Result<(ImageReference, String)> {
+        let container_path = &self.path.join("oci");
+        if container_path.exists() {
+            std::fs::remove_dir_all(container_path)?;
+        }
+        let imgref = ImageReference {
+            transport: Transport::OciDir,
+            name: container_path.as_str().to_string(),
+        };
+        let config = Config {
+            labels: Some(
+                [("foo", "bar"), ("test", "value")]
+                    .iter()
+                    .map(|(k, v)| (k.to_string(), v.to_string()))
+                    .collect(),
+            ),
+            ..Default::default()
+        };
+        let contentmeta = self.get_object_meta().context("Computing object meta")?;
+        let contentmeta = ObjectMetaSized::compute_sizes(self.srcrepo(), contentmeta)
+            .context("Computing sizes")?;
+        let opts = ExportOpts::default();
+        let digest = crate::container::encapsulate(
+            self.srcrepo(),
+            self.testref(),
+            &config,
+            Some(opts),
+            Some(contentmeta),
+            &imgref,
+        )
+        .await
+        .context("exporting")?;
+        Ok((imgref, digest))
+    }
 }

lib/tests/it/main.rs

@@ -515,6 +515,75 @@ async fn impl_test_container_import_export(chunked: bool) -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn impl_test_container_chunked() -> Result<()> {
+    let mut fixture = Fixture::new_v1()?;
+
+    let (imgref, expected_digest) = fixture.export_container().await.unwrap();
+    let imgref = OstreeImageReference {
+        sigverify: SignatureSource::ContainerPolicyAllowInsecure,
+        imgref: imgref,
+    };
+
+    let mut imp = ostree_ext::container::store::ImageImporter::new(
+        fixture.destrepo(),
+        &imgref,
+        Default::default(),
+    )
+    .await?;
+    let prep = match imp.prepare().await.context("Init prep derived")? {
+        PrepareResult::AlreadyPresent(_) => panic!("should not be already imported"),
+        PrepareResult::Ready(r) => r,
+    };
+    let digest = prep.manifest_digest.clone();
+    assert!(prep.ostree_commit_layer.commit.is_none());
+    assert_eq!(prep.ostree_layers.len(), 6);
+    assert_eq!(prep.layers.len(), 0);
+    for layer in prep.layers.iter() {
+        assert!(layer.commit.is_none());
+    }
+    assert_eq!(digest, expected_digest);
+    let import = imp.import(prep).await.context("Init pull derived").unwrap();
+    dbg!(import);
+
+    const ADDITIONS: &str = indoc::indoc! { "
+r usr/bin/bash bash-v0
+"};
+    fixture
+        .update(FileDef::iter_from(ADDITIONS), std::iter::empty())
+        .context("Failed to update")?;
+
+    let expected_digest = fixture.export_container().await.unwrap().1;
+    assert_ne!(digest, expected_digest);
+
+    let mut imp = ostree_ext::container::store::ImageImporter::new(
+        fixture.destrepo(),
+        &imgref,
+        Default::default(),
+    )
+    .await?;
+    let prep = match imp.prepare().await.context("Init prep derived")? {
+        PrepareResult::AlreadyPresent(_) => panic!("should not be already imported"),
+        PrepareResult::Ready(r) => r,
+    };
+    dbg!(&prep);
+    let digest = prep.manifest_digest.clone();
+    assert!(prep.ostree_commit_layer.commit.is_none());
+    assert_eq!(prep.ostree_layers.len(), 6);
+    assert_eq!(prep.layers.len(), 0);
+    for (i, layer) in prep.ostree_layers.iter().enumerate() {
+        dbg!(i);
+        if i == 6 {
+            assert!(layer.commit.is_none());
+        } else {
+            assert!(layer.commit.is_some());
+        }
+    }
+    assert_eq!(digest, expected_digest);
+
+    Ok(())
+}
+
 /// Copy an OCI directory.
 async fn oci_clone(src: impl AsRef<Utf8Path>, dest: impl AsRef<Utf8Path>) -> Result<()> {
     let src = src.as_ref();