You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: integration.rs
    path of file: ./repos/holochain/crates/mr_bundle/tests
    
    the code of the file until where you have to start completion: use mr_bundle::{Bundle, Location, Manifest, ResourceBytes};
use std::{collections::HashSet, path::PathBuf};

#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(tag = "manifest_version")]
#[allow(missing_docs)]
enum TestManifest {
    #[serde(rename = "1")]
    #[serde(alias = "\"1\"")]
    V1(ManifestV1),
}

impl Manifest for TestManifest {
    fn locations(&self) -> Vec<Location> {
        match self {
            Self::V1(mani) => mani.things.iter().map(|b| b.location.clone()).collect(),
        }
    }

    #[cfg(feature = "packing")]
    fn path() -> PathBuf {
        "test-manifest.yaml".into()
    }

    #[cfg(feature = "packing")]
    fn bundle_extension()
    
async fn unpack_roundtrip() {
    let dir = tempfile::tempdir().unwrap();
    let dir_path = dir.path().canonicalize().unwrap();

    // Write a ResourceBytes to disk
    let local_thing = Thing("local".into());
    let local_path = dir_path.join("deeply/nested/local.thing");
    std::fs::create_dir_all(local_path.parent().unwrap()).unwrap();
    std::fs::write(&local_path, mr_bundle::encode(&local_thing).unwrap()).unwrap();

    let bundled_thing = Thing("bundled".into());
    let bundled_thing_encoded: ResourceBytes = mr_bundle::encode(&bundled_thing).unwrap().into();
    let bundled_path = PathBuf::from("another/nested/bundled.thing");

    // Create a Manifest that references these resources
    let bundled_location = Location::Bundled(bundled_path.clone());
    let local_location = Location::Path(local_path.clone());
    let manifest = TestManifest::V1(ManifestV1 {
        name: "name".to_string(),
        things: vec![
            ThingManifest {
                location: bundled_location.clone(),
            },
            ThingManifest {
                location: local_location.clone(),
            },
        ],
    });

    let unpacked_dir = dir_path.join("unpacked");

    // Put the bundled resource into a Bundle (excluding the local resource)
    let bundle = Bundle::new(
        manifest,
        vec![(bundled_path.clone(), bundled_thing_encoded.clone())],
        unpacked_dir.clone(),
    )
    .unwrap();
    assert_eq!(
        bundle
            .bundled_resources()
            .iter()
            .collect::<HashSet<(&PathBuf, &ResourceBytes)>>(),
        maplit::hashset![(&bundled_path, &bundled_thing_encoded)]
    );

    // Unpack the bundle to a directory on the filesystem
    bundle.unpack_yaml(&unpacked_dir, false).await.unwrap();

    assert!(unpacked_dir.join("test-manifest.yaml").is_file());
    assert!(unpacked_dir.join("another/nested/bundled.thing").is_file());
    assert!(!unpacked_dir.join("deeply/nested/local.thing").exists());

    let reconstructed = Bundle::<TestManifest>::pack_yaml(&unpacked_dir.join("test-manifest.yaml"))
        .await
        .unwrap();

    assert_eq!(bundle, reconstructed);
}