Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Support local devcontainer features (#55225)
KyleBarton707c00b474b7
diff --git a/Cargo.lock b/Cargo.lockindex 3dc93b90add..225d5ca6dbb 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4939,6 +4939,7 @@ dependencies = ["gpui","http 1.3.1","http_client",+ "indoc","log","menu","paths",@@ -4948,6 +4949,7 @@ dependencies = ["serde","serde_json","serde_json_lenient",+ "serde_yaml","settings","shlex","ui",diff --git a/Cargo.toml b/Cargo.tomlindex 6db9f292287..817018a9509 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -724,6 +724,7 @@ serde_json_lenient = { version = "0.2", features = ["preserve_order","raw_value",] }+serde_yaml = "0.9.34"serde_path_to_error = "0.1.17"serde_urlencoded = "0.7"sha2 = "0.10"diff --git a/crates/dev_container/Cargo.toml b/crates/dev_container/Cargo.tomlindex d051b51e8bf..c235b24db4a 100644--- a/crates/dev_container/Cargo.toml+++ b/crates/dev_container/Cargo.toml@@ -11,6 +11,7 @@ async-trait.workspace = trueserde.workspace = trueserde_json.workspace = trueserde_json_lenient.workspace = true+serde_yaml.workspace = trueyaml-rust2.workspace = trueshlex.workspace = truehttp_client.workspace = true@@ -33,6 +34,7 @@ workspace.workspace = true[dev-dependencies]fs = { workspace = true, features = ["test-support"] }+indoc.workspace = truegpui = { workspace = true, features = ["test-support"] }project = { workspace = true, features = ["test-support"] }serde_json.workspace = truediff --git a/crates/dev_container/src/command_json.rs b/crates/dev_container/src/command_json.rsindex 8226767f579..be15c9016dc 100644--- a/crates/dev_container/src/command_json.rs+++ b/crates/dev_container/src/command_json.rs@@ -43,6 +43,43 @@ where})}+pub(crate) async fn evaluate_yaml_command<T>(+ mut command: Command,+) -> Result<Option<T>, DevContainerError>+where+ T: for<'de> Deserialize<'de>,+{+ let output = command.output().await.map_err(|e| {+ log::error!("Error running command {:?}: {e}", command);+ DevContainerError::CommandFailed(command.get_program().display().to_string())+ })?;++ deserialize_yaml_output(output).map_err(|e| {+ log::error!("Error running command {:?}: {e}", command);+ DevContainerError::CommandFailed(command.get_program().display().to_string())+ })+}++pub(crate) fn deserialize_yaml_output<T>(output: Output) -> Result<Option<T>, String>+where+ T: for<'de> Deserialize<'de>,+{+ if output.status.success() {+ let raw = String::from_utf8_lossy(&output.stdout);+ if raw.is_empty() || raw.trim() == "[]" || raw.trim() == "{}" {+ return Ok(None);+ }+ serde_yaml::from_str(&raw)+ .map(Some)+ .map_err(|e| format!("Error deserializing from raw yaml: {e}"))+ } else {+ let std_err = String::from_utf8_lossy(&output.stderr);+ Err(format!(+ "Sent non-successful output; cannot deserialize. StdErr: {std_err}"+ ))+ }+}+pub(crate) fn deserialize_json_output<T>(output: Output) -> Result<Option<T>, String>whereT: for<'de> Deserialize<'de>,@@ -66,6 +103,8 @@ wheremod tests {use std::process::ExitStatus;+ use crate::docker::{DockerComposeConfig, DockerComposeServiceBuild};+use super::*;fn success_output(stdout: &str) -> Output {@@ -104,4 +143,65 @@ mod tests {let result: Option<TestItem> = deserialize_json_output(output).unwrap();assert_eq!(result, None);}++ #[test]+ fn test_deserialize_yaml_docker_compose_config() {+ let yaml = indoc::indoc! {"+ name: my-project+ services:+ app:+ image: node:18+ command:+ - sleep+ - infinity+ build:+ context: .+ dockerfile: Dockerfile+ db:+ image: postgres:15+ volumes: {}+ "};+ let output = success_output(yaml);+ let result: DockerComposeConfig = deserialize_yaml_output(output)+ .expect("deserialization should succeed")+ .expect("result should not be None");++ assert_eq!(result.name, Some("my-project".to_string()));+ assert_eq!(result.services.len(), 2);++ let app = result+ .services+ .get("app")+ .expect("app service should exist");+ assert_eq!(app.image, Some("node:18".to_string()));+ assert_eq!(+ app.command,+ vec!["sleep".to_string(), "infinity".to_string()]+ );+ assert_eq!(+ app.build,+ Some(DockerComposeServiceBuild {+ context: Some(".".to_string()),+ dockerfile: Some("Dockerfile".to_string()),+ ..Default::default()+ })+ );++ let db = result.services.get("db").expect("db service should exist");+ assert_eq!(db.image, Some("postgres:15".to_string()));+ }++ #[test]+ fn test_deserialize_yaml_empty_output() {+ let output = success_output("");+ let result: Option<DockerComposeConfig> = deserialize_yaml_output(output).unwrap();+ assert_eq!(result, None);+ }++ #[test]+ fn test_deserialize_yaml_empty_object() {+ let output = success_output("{}");+ let result: Option<DockerComposeConfig> = deserialize_yaml_output(output).unwrap();+ assert_eq!(result, None);+ }}diff --git a/crates/dev_container/src/devcontainer_manifest.rs b/crates/dev_container/src/devcontainer_manifest.rsindex fe1dbe7b9a8..c88c4df995a 100644--- a/crates/dev_container/src/devcontainer_manifest.rs+++ b/crates/dev_container/src/devcontainer_manifest.rs@@ -362,6 +362,59 @@ impl DevContainerManifest {}}+ async fn copy_local_feature(+ &self,+ feature_ref: &str,+ destination: &Path,+ ) -> Result<(), DevContainerError> {+ let source_path = normalize_path(&self.config_directory.join(feature_ref));++ if !self.fs.is_dir(&source_path).await {+ log::error!(+ "Local feature directory '{}' not found at {:?}",+ feature_ref,+ source_path+ );+ return Err(DevContainerError::ResourceFetchFailed);+ }++ let items = fs::read_dir_items(&*self.fs, &source_path)+ .await+ .map_err(|e| {+ log::error!(+ "Failed to read local feature directory {:?}: {e}",+ source_path+ );+ DevContainerError::FilesystemError+ })?;++ for (item_path, is_dir) in &items {+ let relative = item_path.strip_prefix(&source_path).map_err(|e| {+ log::error!("Failed to compute relative path for {:?}: {e}", item_path);+ DevContainerError::FilesystemError+ })?;+ let dest_path = destination.join(relative);++ if *is_dir {+ self.fs.create_dir(&dest_path).await.map_err(|e| {+ log::error!("Failed to create directory {:?}: {e}", dest_path);+ DevContainerError::FilesystemError+ })?;+ } else {+ let content = self.fs.load_bytes(item_path).await.map_err(|e| {+ log::error!("Failed to read file {:?}: {e}", item_path);+ DevContainerError::FilesystemError+ })?;+ self.fs.write(&dest_path, &content).await.map_err(|e| {+ log::error!("Failed to write file {:?}: {e}", dest_path);+ DevContainerError::FilesystemError+ })?;+ }+ }++ Ok(())+ }+async fn download_feature_and_dockerfile_resources(&mut self) -> Result<(), DevContainerError> {let dev_container = match &self.config {ConfigStatus::Deserialized(_) => {@@ -458,59 +511,66 @@ impl DevContainerManifest {DevContainerError::FilesystemError})?;- let oci_ref = parse_oci_feature_ref(feature_ref).ok_or_else(|| {- log::error!(- "Feature '{}' is not a supported OCI feature reference",- feature_ref- );- DevContainerError::DevContainerParseFailed- })?;- let TokenResponse { token } =- get_oci_token(&oci_ref.registry, &oci_ref.path, &self.http_client)- .await- .map_err(|e| {- log::error!("Failed to get OCI token for feature '{}': {e}", feature_ref);- DevContainerError::ResourceFetchFailed- })?;- let manifest = get_oci_manifest(- &oci_ref.registry,- &oci_ref.path,- &token,- &self.http_client,- &oci_ref.version,- None,- )- .await- .map_err(|e| {- log::error!(- "Failed to fetch OCI manifest for feature '{}': {e}",- feature_ref- );- DevContainerError::ResourceFetchFailed- })?;- let digest = &manifest- .layers- .first()- .ok_or_else(|| {+ if is_local_feature_ref(feature_ref) {+ self.copy_local_feature(feature_ref, &feature_dir).await?;+ } else {+ let oci_ref = parse_oci_feature_ref(feature_ref).ok_or_else(|| {log::error!(- "OCI manifest for feature '{}' contains no layers",+ "Feature '{}' is not a supported OCI feature reference",+ feature_ref+ );+ DevContainerError::DevContainerParseFailed+ })?;+ let TokenResponse { token } =+ get_oci_token(&oci_ref.registry, &oci_ref.path, &self.http_client)+ .await+ .map_err(|e| {+ log::error!(+ "Failed to get OCI token for feature '{}': {e}",+ feature_ref+ );+ DevContainerError::ResourceFetchFailed+ })?;+ let manifest = get_oci_manifest(+ &oci_ref.registry,+ &oci_ref.path,+ &token,+ &self.http_client,+ &oci_ref.version,+ None,+ )+ .await+ .map_err(|e| {+ log::error!(+ "Failed to fetch OCI manifest for feature '{}': {e}",feature_ref);DevContainerError::ResourceFetchFailed- })?- .digest;- download_oci_tarball(- &token,- &oci_ref.registry,- &oci_ref.path,- digest,- "application/vnd.devcontainers.layer.v1+tar",- &feature_dir,- &self.http_client,- &self.fs,- None,- )- .await?;+ })?;+ let digest = &manifest+ .layers+ .first()+ .ok_or_else(|| {+ log::error!(+ "OCI manifest for feature '{}' contains no layers",+ feature_ref+ );+ DevContainerError::ResourceFetchFailed+ })?+ .digest;+ download_oci_tarball(+ &token,+ &oci_ref.registry,+ &oci_ref.path,+ digest,+ "application/vnd.devcontainers.layer.v1+tar",+ &feature_dir,+ &self.http_client,+ &self.fs,+ None,+ )+ .await?;+ }let feature_json_path = &feature_dir.join("devcontainer-feature.json");if !self.fs.is_file(feature_json_path).await {@@ -537,7 +597,7 @@ impl DevContainerManifest {let feature_manifest = FeatureManifest::new(consecutive_id, feature_dir, feature_json);- log::debug!("Downloaded OCI feature content for '{}'", feature_ref);+ log::debug!("Prepared feature content for '{}'", feature_ref);let env_content = feature_manifest.write_feature_env(&self.fs, options)@@ -1176,7 +1236,7 @@ RUN sed -i -E 's/((^|\s)PATH=)([^\$]*)$/\1\${{PATH:-\3}}/g' /etc/profile || trueSome((source.clone(),DockerComposeVolume {- name: source.clone(),+ name: Some(source.clone()),},))} else {@@ -2565,6 +2625,10 @@ fn extract_feature_id(feature_ref: &str) -> &str {}}+fn is_local_feature_ref(feature_ref: &str) -> bool {+ feature_ref.starts_with("./") || feature_ref.starts_with("../")+}+/// Generates a shell command that looks up a user's passwd entry.////// Mirrors the CLI's `getEntPasswdShellCommand` in `commonUtils.ts`.@@ -2836,7 +2900,7 @@ mod test {devcontainer_manifest::{ConfigStatus, DevContainerManifest, DockerBuildResources, DockerComposeResources,DockerInspect, extract_feature_id, find_primary_service, get_remote_user_from_config,- image_from_dockerfile, resolve_compose_dockerfile,+ image_from_dockerfile, is_local_feature_ref, resolve_compose_dockerfile,},docker::{DockerClient, DockerComposeConfig, DockerComposeService, DockerComposeServiceBuild,@@ -3061,6 +3125,16 @@ mod test {);}+ #[test]+ fn should_identify_local_feature_refs() {+ assert!(is_local_feature_ref("./lsp-devtools"));+ assert!(is_local_feature_ref("./some/nested/feature"));+ assert!(is_local_feature_ref("../sibling-feature"));+ assert!(!is_local_feature_ref("ghcr.io/devcontainers/features/go:1"));+ assert!(!is_local_feature_ref("ghcr.io/user/repo/node:18.0.0"));+ assert!(!is_local_feature_ref("https://example.com/feature.tgz"));+ }+#[gpui::test]async fn should_create_correct_docker_run_command(cx: &mut TestAppContext) {let mut metadata = HashMap::new();@@ -4145,7 +4219,7 @@ ENV DOCKER_BUILDKIT=1volumes: HashMap::from([("dind-var-lib-docker-42dad4b4ca7b8ced".to_string(),DockerComposeVolume {- name: "dind-var-lib-docker-42dad4b4ca7b8ced".to_string(),+ name: Some("dind-var-lib-docker-42dad4b4ca7b8ced".to_string()),},)]),};@@ -5156,6 +5230,116 @@ chmod +x ./install.sh}))}+ #[cfg(not(target_os = "windows"))]+ #[gpui::test]+ async fn test_spawns_devcontainer_with_local_feature(cx: &mut TestAppContext) {+ cx.executor().allow_parking();+ env_logger::try_init().ok();+ let given_devcontainer_contents = r#"+ {+ "name": "cli-local-feature-test",+ "image": "test_image:latest",+ "features": {+ "./lsp-devtools": {+ "version": "0.1.0"+ }+ }+ }+ "#;++ let (test_dependencies, mut devcontainer_manifest) =+ init_default_devcontainer_manifest(cx, given_devcontainer_contents)+ .await+ .unwrap();++ test_dependencies+ .fs+ .insert_tree(+ format!("{TEST_PROJECT_PATH}/.devcontainer/lsp-devtools"),+ serde_json::json!({+ "devcontainer-feature.json": r#"{+ "id": "lsp-devtools",+ "version": "0.1.0",+ "name": "LSP Devtools",+ "options": {+ "version": {+ "type": "string",+ "default": "latest"+ }+ }+ }"#,+ "install.sh": "#!/bin/sh\nset -e\necho 'Installing lsp-devtools'",+ }),+ )+ .await;++ devcontainer_manifest.parse_nonremote_vars().unwrap();++ let _devcontainer_up = devcontainer_manifest.build_and_run().await.unwrap();++ let files = test_dependencies.fs.files();++ let feature_dockerfile = files+ .iter()+ .find(|f| {+ f.file_name()+ .is_some_and(|s| s.display().to_string() == "Dockerfile.extended")+ })+ .expect("Dockerfile.extended should be generated");+ let feature_dockerfile = test_dependencies.fs.load(feature_dockerfile).await.unwrap();++ assert!(+ feature_dockerfile.contains("lsp-devtools_0"),+ "Dockerfile.extended should reference the local feature. Got:\n{}",+ feature_dockerfile+ );++ let install_wrapper = files+ .iter()+ .find(|f| {+ f.file_name()+ .is_some_and(|s| s.display().to_string() == "devcontainer-features-install.sh")+ && f.to_str().is_some_and(|s| s.contains("/lsp-devtools_"))+ })+ .expect("Install wrapper should be generated for local feature");+ let install_wrapper = test_dependencies.fs.load(install_wrapper).await.unwrap();+ assert!(+ install_wrapper.contains("./lsp-devtools"),+ "Install wrapper should reference the local feature path. Got:\n{}",+ install_wrapper+ );++ let feature_env = files+ .iter()+ .find(|f| {+ f.file_name()+ .is_some_and(|s| s.display().to_string() == "devcontainer-features.env")+ && f.to_str().is_some_and(|s| s.contains("/lsp-devtools_"))+ })+ .expect("Feature env file should be generated for local feature");+ let feature_env = test_dependencies.fs.load(feature_env).await.unwrap();+ assert!(+ feature_env.contains("VERSION=0.1.0"),+ "Feature env should contain user-provided version override. Got:\n{}",+ feature_env+ );++ let install_sh = files+ .iter()+ .find(|f| {+ f.file_name()+ .is_some_and(|s| s.display().to_string() == "install.sh")+ && f.to_str().is_some_and(|s| s.contains("/lsp-devtools_"))+ })+ .expect("install.sh should be copied from the local feature directory");+ let install_sh = test_dependencies.fs.load(install_sh).await.unwrap();+ assert!(+ install_sh.contains("Installing lsp-devtools"),+ "install.sh should have the original content. Got:\n{}",+ install_sh+ );+ }+#[cfg(not(target_os = "windows"))]#[gpui::test]async fn test_spawns_devcontainer_with_plain_image(cx: &mut TestAppContext) {diff --git a/crates/dev_container/src/docker.rs b/crates/dev_container/src/docker.rsindex be0fe0ed81b..cccbb4373ed 100644--- a/crates/dev_container/src/docker.rs+++ b/crates/dev_container/src/docker.rs@@ -5,7 +5,8 @@ use serde::{Deserialize, Deserializer, Serialize, de};use util::command::Command;use crate::{- command_json::evaluate_json_command, devcontainer_api::DevContainerError,+ command_json::{evaluate_json_command, evaluate_yaml_command},+ devcontainer_api::DevContainerError,devcontainer_json::MountDefinition,};@@ -126,6 +127,7 @@ where#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]pub(crate) struct DockerComposeService {+ #[serde(skip_serializing_if = "Option::is_none")]pub(crate) image: Option<String>,#[serde(skip_serializing_if = "Option::is_none")]pub(crate) entrypoint: Option<Vec<String>>,@@ -143,7 +145,11 @@ pub(crate) struct DockerComposeService {pub(crate) build: Option<DockerComposeServiceBuild>,#[serde(skip_serializing_if = "Option::is_none")]pub(crate) privileged: Option<bool>,- #[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[serde(+ default,+ skip_serializing_if = "Vec::is_empty",+ deserialize_with = "deserialize_compose_volumes"+ )]pub(crate) volumes: Vec<MountDefinition>,#[serde(skip_serializing_if = "Option::is_none")]pub(crate) env_file: Option<Vec<String>>,@@ -161,7 +167,8 @@ pub(crate) struct DockerComposeService {#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]pub(crate) struct DockerComposeVolume {- pub(crate) name: String,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub(crate) name: Option<String>,}#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]@@ -169,7 +176,7 @@ pub(crate) struct DockerComposeConfig {#[serde(skip_serializing_if = "Option::is_none")]pub(crate) name: Option<String>,pub(crate) services: HashMap<String, DockerComposeService>,- #[serde(default)]+ #[serde(default, deserialize_with = "deserialize_compose_top_level_volumes")]pub(crate) volumes: HashMap<String, DockerComposeVolume>,}@@ -251,7 +258,7 @@ impl Docker {for file_path in config_files {command.args(&["-f", &file_path.display().to_string()]);}- command.args(&["config", "--format", "json"]);+ command.arg("config");command}}@@ -277,7 +284,7 @@ impl DockerClient for Docker {config_files: &Vec<PathBuf>,) -> Result<Option<DockerComposeConfig>, DevContainerError> {let command = self.create_docker_compose_config_command(config_files);- evaluate_json_command(command).await+ evaluate_yaml_command(command).await}async fn docker_compose_build(@@ -526,6 +533,106 @@ wheredeserializer.deserialize_any(LabelsVisitor)}+fn deserialize_compose_volumes<'de, D>(deserializer: D) -> Result<Vec<MountDefinition>, D::Error>+where+ D: Deserializer<'de>,+{+ #[derive(Deserialize)]+ #[serde(untagged)]+ enum VolumeItem {+ Object(MountDefinition),+ String(String),+ }++ let items = Vec::<VolumeItem>::deserialize(deserializer)?;+ items+ .into_iter()+ .map(|item| match item {+ VolumeItem::Object(mount) => Ok(mount),+ VolumeItem::String(s) => parse_compose_volume_string(&s)+ .ok_or_else(|| de::Error::custom(format!("invalid volume string: {s}"))),+ })+ .collect()+}++/// Parses Docker Compose short volume syntax: `[SOURCE:]TARGET[:MODE]`.+/// A leading drive letter (e.g. `C:`) on the source is treated as part of the+/// path rather than as a source/target separator.+fn parse_compose_volume_string(s: &str) -> Option<MountDefinition> {+ let bytes = s.as_bytes();++ // Find the colon that separates source from target, skipping a possible+ // Windows drive-letter prefix (single ASCII letter followed by `:`).+ let separator_start = if bytes.len() >= 2+ && bytes[0].is_ascii_alphabetic()+ && bytes[1] == b':'+ && bytes.get(2).map_or(false, |&b| b == b'/' || b == b'\\')+ {+ // Skip past the drive letter prefix (e.g. "C:\")+ 3+ } else {+ 0+ };++ if let Some(colon_pos) = s[separator_start..].find(':') {+ let colon_pos = colon_pos + separator_start;+ let source = &s[..colon_pos];++ let rest = &s[colon_pos + 1..];++ // `rest` may itself start with a Windows drive letter, so skip past+ // that before looking for a second colon that would delimit the mode.+ let mode_search_start = if rest.len() >= 2+ && rest.as_bytes()[0].is_ascii_alphabetic()+ && rest.as_bytes()[1] == b':'+ {+ 2+ } else {+ 0+ };++ let (target, _mode) = if let Some(pos) = rest[mode_search_start..].find(':') {+ let pos = pos + mode_search_start;+ (&rest[..pos], Some(&rest[pos + 1..]))+ } else {+ (rest, None)+ };++ if target.is_empty() {+ return None;+ }++ Some(MountDefinition {+ source: Some(source.to_string()),+ target: target.to_string(),+ mount_type: None,+ })+ } else {+ // No colon at all — anonymous volume with only a target path+ if s.is_empty() {+ return None;+ }+ Some(MountDefinition {+ source: None,+ target: s.to_string(),+ mount_type: None,+ })+ }+}++fn deserialize_compose_top_level_volumes<'de, D>(+ deserializer: D,+) -> Result<HashMap<String, DockerComposeVolume>, D::Error>+where+ D: Deserializer<'de>,+{+ let map: HashMap<String, Option<DockerComposeVolume>> = HashMap::deserialize(deserializer)?;+ Ok(map+ .into_iter()+ .map(|(key, value)| (key, value.unwrap_or_default()))+ .collect())+}+fn deserialize_nullable_vec<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>whereD: Deserializer<'de>,@@ -966,7 +1073,7 @@ mod test {volumes: HashMap::from([("postgres-data".to_string(),DockerComposeVolume {- name: "devcontainer_postgres-data".to_string(),+ name: Some("devcontainer_postgres-data".to_string()),},)]),};@@ -1093,6 +1200,73 @@ mod test {assert_eq!(service.volumes[0].mount_type, Some("tmpfs".to_string()));}+ #[test]+ fn should_deserialize_compose_inline_volume_strings() {+ let given_yaml = indoc::indoc! {r#"+ name: devcontainer+ services:+ app:+ image: node:18+ volumes:+ - postgres-data:/var/lib/postgresql/data+ - /host/path:/container/path+ - /anonymous/volume+ - type: bind+ source: /explicit+ target: /mnt/explicit+ volumes:+ postgres-data:+ name: devcontainer_postgres-data+ "#};++ let config: DockerComposeConfig = serde_yaml::from_str(given_yaml).unwrap();+ let service = config.services.get("app").unwrap();+ assert_eq!(service.volumes.len(), 4);++ assert_eq!(service.volumes[0].source, Some("postgres-data".to_string()));+ assert_eq!(service.volumes[0].target, "/var/lib/postgresql/data");+ assert_eq!(service.volumes[0].mount_type, None);++ assert_eq!(service.volumes[1].source, Some("/host/path".to_string()));+ assert_eq!(service.volumes[1].target, "/container/path");++ assert_eq!(service.volumes[2].source, None);+ assert_eq!(service.volumes[2].target, "/anonymous/volume");++ assert_eq!(service.volumes[3].source, Some("/explicit".to_string()));+ assert_eq!(service.volumes[3].target, "/mnt/explicit");+ assert_eq!(service.volumes[3].mount_type, Some("bind".to_string()));+ }++ #[test]+ fn should_deserialize_compose_top_level_volumes_with_null_value() {+ let given_yaml = indoc::indoc! {r#"+ name: devcontainer+ services:+ app:+ image: node:18+ volumes:+ postgres-data:+ named-vol:+ name: custom-name+ "#};++ let config: DockerComposeConfig = serde_yaml::from_str(given_yaml).unwrap();+ assert_eq!(config.volumes.len(), 2);++ let bare = config+ .volumes+ .get("postgres-data")+ .expect("bare volume should exist");+ assert_eq!(bare.name, None);++ let named = config+ .volumes+ .get("named-vol")+ .expect("named volume should exist");+ assert_eq!(named.name, Some("custom-name".to_string()));+ }+#[test]fn should_deserialize_inspect_without_labels() {let given_config = r#"