make stateAndDiff also respect resource, enhance tests

dsc/tests/dsc_config_test.tests.ps1

@@ -33,11 +33,13 @@ Describe 'dsc config test tests' {
         }
     }
 
-    It '_inDesiredState returned is used when: <inDesiredState>' -TestCases @(
-        @{ inDesiredState = $true }
-        @{ inDesiredState = $false }
+    It '_inDesiredState returned is used when: inDesiredState = <inDesiredState> and same = <same>' -TestCases @(
+        @{ inDesiredState = $true; valueOne = 1; valueTwo = 2; same = $true }
+        @{ inDesiredState = $true; valueOne = 3; valueTwo = 4; same = $false }
+        @{ inDesiredState = $false; valueOne = 1; valueTwo = 2; same = $true }
+        @{ inDesiredState = $false; valueOne = 3; valueTwo = 4; same = $false }
     ) {
-        param($inDesiredState)
+        param($inDesiredState, $valueOne, $valueTwo)
 
         $configYaml = @"
   `$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
@@ -46,17 +48,18 @@ Describe 'dsc config test tests' {
       type: Test/InDesiredState
       properties:
         _inDesiredState: $inDesiredState
-        value: Hello
+        valueOne: $valueOne
+        valueTwo: $valueTwo
 "@
 
         $out = dsc config test -i $configYaml | ConvertFrom-Json
         $LASTEXITCODE | Should -Be 0
         $out.results[0].result.inDesiredState | Should -Be $inDesiredState
-        if ($inDesiredState) {
+        if ($same) {
             $out.results[0].result.differingProperties | Should -BeNullOrEmpty
         }
         else {
-            $out.results[0].result.differingProperties | Should -Contain 'value'
+            $out.results[0].result.differingProperties | Should -Be @('valueOne', 'valueTwo')
         }
     }
 }

dsc_lib/src/dscresources/command_resource.rs

@@ -283,25 +283,8 @@ pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Re
                     return Err(DscError::Operation(t!("dscresources.commandResource.failedParseJson", executable = &test.executable, stdout = stdout, stderr = stderr, err = err).to_string()))
                 }
             };
-            // if actual state contains _inDesiredState, we use that to determine if the resource is in desired state
-            let mut in_desired_state: Option<bool> = None;
-            if let Some(in_desired_state_value) = actual_value.get("_inDesiredState") {
-                if let Some(desired_state) = in_desired_state_value.as_bool() {
-                    in_desired_state = Some(desired_state);
-                } else {
-                    return Err(DscError::Operation(t!("dscresources.commandResource.inDesiredStateNotBool").to_string()));
-                }
-            }
-
-            let mut diff_properties: Vec<String> = Vec::new();
-            match in_desired_state {
-                Some(true) => {
-                    // if _inDesiredState is true, we don't need to check for diff properties
-                },
-                Some(false) | None => {
-                    diff_properties = get_diff(&expected_value, &actual_value);
-                }
-            }
+            let in_desired_state = get_desired_state(&actual_value)?;
+            let diff_properties = get_diff(&expected_value, &actual_value);
             Ok(TestResult::Resource(ResourceTestResponse {
                 desired_state: expected_value,
                 actual_state: actual_value,
@@ -320,10 +303,11 @@ pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Re
                 return Err(DscError::Command(resource.resource_type.clone(), exit_code, t!("dscresources.commandResource.testNoDiff").to_string()));
             };
             let diff_properties: Vec<String> = serde_json::from_str(diff_properties)?;
+            let in_desired_state = get_desired_state(&actual_value)?;
             Ok(TestResult::Resource(ResourceTestResponse {
                 desired_state: expected_value,
                 actual_state: actual_value,
-                in_desired_state: diff_properties.is_empty(),
+                in_desired_state: in_desired_state.unwrap_or(diff_properties.is_empty()),
                 diff_properties,
             }))
         },
@@ -353,6 +337,19 @@ pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Re
     }
 }
 
+fn get_desired_state(actual: &Value) -> Result<Option<bool>, DscError> {
+    // if actual state contains _inDesiredState, we use that to determine if the resource is in desired state
+    let mut in_desired_state: Option<bool> = None;
+    if let Some(in_desired_state_value) = actual.get("_inDesiredState") {
+        if let Some(desired_state) = in_desired_state_value.as_bool() {
+            in_desired_state = Some(desired_state);
+        } else {
+            return Err(DscError::Operation(t!("dscresources.commandResource.inDesiredStateNotBool").to_string()));
+        }
+    }
+    Ok(in_desired_state)
+}
+
 fn invoke_synthetic_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Result<TestResult, DscError> {
     let get_result = invoke_get(resource, cwd, expected)?;
     let actual_state = match get_result {

tools/dsctest/src/in_desired_state.rs

@@ -4,10 +4,14 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+#[allow(clippy::struct_field_names)]
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct InDesiredState {
     #[serde(rename = "_inDesiredState", skip_serializing_if = "Option::is_none")]
     pub in_desired_state: Option<bool>,
-    pub value: String,
+    #[serde(rename = "valueOne")]
+    pub value_one: i32,
+    #[serde(rename = "valueTwo")]
+    pub value_two: i32,
 }

tools/dsctest/src/main.rs

@@ -75,7 +75,8 @@ fn main() {
                     std::process::exit(1);
                 }
             };
-            in_desired_state.value = "SomethingElse".to_string();
+            in_desired_state.value_one = 1;
+            in_desired_state.value_two= 2;
             serde_json::to_string(&in_desired_state).unwrap()
         },
         SubCommand::Schema { subcommand } => {