Implement custom deserializer for resources

Author: andyleejordan

lib/dsc-lib/src/configure/config_doc.rs

@@ -8,7 +8,7 @@ use dsc_lib_jsonschema::transforms::{
 };
 use rust_i18n::t;
 use schemars::{JsonSchema, json_schema};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::{Map, Value};
 use std::{collections::HashMap, fmt::Display};
 
@@ -174,6 +174,7 @@ pub struct Configuration {
     pub outputs: Option<HashMap<String, Output>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub parameters: Option<HashMap<String, Parameter>>,
+    #[serde(deserialize_with = "deserialize_resources")]
     pub resources: Vec<Resource>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub variables: Option<Map<String, Value>>,
@@ -184,6 +185,35 @@ pub struct Configuration {
     pub extensions: Option<Map<String, Value>>,
 }
 
+/// Simplest implementation of a custom deserializer that will map a JSON object
+/// of resources (where the keys are symbolic names) as found in ARMv2 back to a
+/// vector, so the rest of this codebase can remain untouched.
+fn deserialize_resources<'de, D>(deserializer: D) -> Result<Vec<Resource>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let value = Value::deserialize(deserializer)?;
+
+    match value {
+        Value::Array(resources) => {
+            resources.into_iter()
+                .map(|resource| serde_json::from_value(resource).map_err(serde::de::Error::custom))
+                .collect()
+        }
+        Value::Object(resources) => {
+            resources.into_iter()
+                .map(|(name, resource)| {
+                    let mut resource: Resource = serde_json::from_value(resource).map_err(serde::de::Error::custom)?;
+                    // TODO: Decide what to do if resource.name is already set.
+                    resource.name = name;
+                    Ok(resource)
+                })
+                .collect()
+        }
+        other => Err(serde::de::Error::custom(format!("Expected resources to be either an array or an object, but was {:?}", other))),
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct Parameter {
@@ -326,6 +356,7 @@ pub struct Resource {
     #[serde(skip_serializing_if = "Option::is_none", rename = "apiVersion")]
     pub api_version: Option<String>,
     /// A friendly name for the resource instance
+    #[serde(default)]
     pub name: String, // friendly unique instance name
     #[serde(skip_serializing_if = "Option::is_none")]
     pub comments: Option<String>,
@@ -486,4 +517,80 @@ mod test {
 
         assert!(result.is_ok());
     }
+
+    #[test]
+    fn test_resources_as_array() {
+        let config_json = r#"{
+            "$schema": "https://aka.ms/dsc/schemas/v3/bundled/config/document.json",
+            "resources": [
+                {
+                    "type": "Microsoft.DSC.Debug/Echo",
+                    "name": "echoResource",
+                    "apiVersion": "1.0.0"
+                },
+                {
+                    "type": "Microsoft/Process",
+                    "name": "processResource",
+                    "apiVersion": "0.1.0"
+                }
+            ]
+        }"#;
+
+        let config: Configuration = serde_json::from_str(config_json).unwrap();
+
+        assert_eq!(config.resources.len(), 2);
+        assert_eq!(config.resources[0].name, "echoResource");
+        assert_eq!(config.resources[0].resource_type, "Microsoft.DSC.Debug/Echo");
+        assert_eq!(config.resources[0].api_version.as_deref(), Some("1.0.0"));
+
+        assert_eq!(config.resources[1].name, "processResource");
+        assert_eq!(config.resources[1].resource_type, "Microsoft/Process");
+        assert_eq!(config.resources[1].api_version.as_deref(), Some("0.1.0"));
+    }
+
+    #[test]
+    fn test_resources_with_symbolic_names() {
+        let config_json = r#"{
+            "$schema": "https://aka.ms/dsc/schemas/v3/bundled/config/document.json",
+            "languageVersion": "2.2-experimental",
+            "extensions": {
+                "dsc": {
+                    "name": "DesiredStateConfiguration",
+                    "version": "0.1.0"
+                }
+            },
+            "resources": {
+                "echoResource": {
+                    "extension": "dsc",
+                    "type": "Microsoft.DSC.Debug/Echo",
+                    "apiVersion": "1.0.0",
+                    "properties": {
+                        "output": "Hello World"
+                    }
+                },
+                "processResource": {
+                    "extension": "dsc",
+                    "type": "Microsoft/Process",
+                    "apiVersion": "0.1.0",
+                    "properties": {
+                        "name": "pwsh",
+                        "pid": 1234
+                    }
+                }
+            }
+        }"#;
+
+        let config: Configuration = serde_json::from_str(config_json).unwrap();
+        assert_eq!(config.resources.len(), 2);
+
+        // Find resources by name (order may vary in HashMap)
+        let echo_resource = config.resources.iter().find(|r| r.name == "echoResource").unwrap();
+        let process_resource = config.resources.iter().find(|r| r.name == "processResource").unwrap();
+
+        assert_eq!(echo_resource.resource_type, "Microsoft.DSC.Debug/Echo");
+        assert_eq!(echo_resource.api_version.as_deref(), Some("1.0.0"));
+
+        assert_eq!(process_resource.resource_type, "Microsoft/Process");
+        assert_eq!(process_resource.api_version.as_deref(), Some("0.1.0"));
+    }
 }