change include resource to group type resource

Author: SteveL-MSFT

dsc/include.dsc.resource.json

@@ -3,12 +3,13 @@
   "type": "Microsoft.DSC/Include",
   "version": "0.1.0",
   "description": "Allows including a configuration file with optional parameter file.",
-  "kind": "Group",
+  "kind": "Import",
   "get": {
     "executable": "dsc",
     "args": [
       "config",
       "--as-include",
+      "--as-group",
       "get"
     ],
     "input": "stdin"
@@ -18,6 +19,7 @@
     "args": [
       "config",
       "--as-include",
+      "--as-group",
       "set"
     ],
     "input": "stdin",
@@ -29,10 +31,10 @@
     "args": [
       "config",
       "--as-include",
+      "--as-group",
       "test"
     ],
-    "input": "stdin",
-    "return": "state"
+    "input": "stdin"
   },
   "exitCodes": {
     "0": "Success",

dsc/src/subcommand.rs

@@ -2,11 +2,11 @@
 // Licensed under the MIT License.
 
 use crate::args::{ConfigSubCommand, DscType, OutputFormat, ResourceSubCommand};
-use crate::resolve::get_contents;
+use crate::resolve::{get_contents, Include};
 use crate::resource_command::{get_resource, self};
 use crate::Stream;
 use crate::tablewriter::Table;
-use crate::util::{DSC_CONFIG_ROOT, EXIT_DSC_ERROR, EXIT_INVALID_INPUT, EXIT_JSON_ERROR, EXIT_VALIDATION_FAILED, get_schema, write_output, get_input, set_dscconfigroot, validate_json};
+use crate::util::{DSC_CONFIG_ROOT, EXIT_DSC_ERROR, EXIT_INVALID_INPUT, EXIT_JSON_ERROR, get_schema, write_output, get_input, set_dscconfigroot, validate_json};
 use dsc_lib::configure::{Configurator, config_doc::{Configuration, ExecutionKind}, config_result::ResourceGetResult};
 use dsc_lib::dscerror::DscError;
 use dsc_lib::dscresources::invoke_result::ResolveResult;
@@ -285,31 +285,41 @@ pub fn config(subcommand: &ConfigSubCommand, parameters: &Option<String>, stdin:
         ConfigSubCommand::Test { format, as_get, .. } => {
             config_test(&mut configurator, format, as_group, as_get);
         },
-        ConfigSubCommand::Validate { format, .. } => {
+        ConfigSubCommand::Validate { document, path, format} => {
             let mut result = ValidateResult {
                 valid: true,
                 reason: None,
             };
-            let valid = match validate_config(&configurator.get_config()) {
-                Ok(()) => {
-                    true
-                },
-                Err(err) => {
-                    error!("{err}");
-                    result.valid = false;
-                    false
+            if *as_include {
+                let new_path = initialize_config_root(path);
+                let input = get_input(document, stdin, &new_path);
+                match serde_json::from_str::<Include>(&input) {
+                    Ok(_) => {
+                        // valid, so do nothing
+                    },
+                    Err(err) => {
+                        error!("Error: Failed to deserialize Include input: {err}");
+                        result.valid = false;
+                    }
                 }
-            };
+            } else {
+                match validate_config(configurator.get_config()) {
+                    Ok(()) => {
+                        // valid, so do nothing
+                    },
+                    Err(err) => {
+                        error!("{err}");
+                        result.valid = false;
+                    }
+                };
+            }
 
             let Ok(json) = serde_json::to_string(&result) else {
                 error!("Failed to convert validation result to JSON");
                 exit(EXIT_JSON_ERROR);
             };
 
             write_output(&json, format);
-            if !valid {
-                exit(EXIT_VALIDATION_FAILED);
-            }
         },
         ConfigSubCommand::Export { format, .. } => {
             config_export(&mut configurator, format);

dsc/tests/dsc_include.tests.ps1

@@ -170,9 +170,9 @@ resources:
         $out.results[0].result[0].result.actualState.output | Should -Be 'one'
         $out.results[1].result[0].name | Should -Be 'nested'
         $out.results[1].result[0].type | Should -Be 'Microsoft.DSC/Include'
-        $out.results[1].result[0].result[0].name | Should -Be 'one'
-        $out.results[1].result[0].result[0].type | Should -Be 'Test/Echo'
-        $out.results[1].result[0].result[0].result[0].actualState.output | Should -Be 'one'
+        $out.results[1].result[0].result.actualState.name | Should -Be 'one'
+        $out.results[1].result[0].result.actualState.type | Should -Be 'Test/Echo'
+        $out.results[1].result[0].result.actualState.result.actualState.output | Should -Be 'one'
     }
 
     It 'Set with include works' {
@@ -203,9 +203,39 @@ resources:
 
         $out = dsc config set -d $includeConfig | ConvertFrom-Json
         $LASTEXITCODE | Should -Be 0
-        $out.results[0].result[0].name | Should -Be 'one'
-        $out.results[0].result[0].type | Should -Be 'Test/Echo'
-        $out.results[0].result[0].result.afterState.output | Should -Be 'Hello World'
+        $out.results[0].result.beforeState[0].name | Should -Be 'one'
+        $out.results[0].result.beforeState[0].type | Should -Be 'Test/Echo'
+        $out.results[0].result.afterState[0].result.afterState.output | Should -Be 'Hello World'
         $out.hadErrors | Should -Be $false
     }
+
+    It 'Test with include works' {
+        $includeYaml = Join-Path $PSScriptRoot ../../dsc/examples/include.dsc.yaml
+        $out = dsc config test -p $includeYaml | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].type | Should -BeExactly 'Microsoft.DSC/Include'
+        $out.results[0].result[0].name | Should -BeExactly 'os'
+        $out.results[0].result[0].type | Should -BeExactly 'Microsoft/OSInfo'
+        $out.results[0].result[0].result.desiredState.family | Should -BeExactly 'macOS'
+
+        $family = if ($isWindows) {
+            'Windows'
+        } elseif ($IsLinux) {
+            'Linux'
+        } elseif ($IsMacOS) {
+            'macOS'
+        } else {
+            'Unknown'
+        }
+
+        $out.results[0].result[0].result.actualState.family | Should -BeExactly $family
+        $expectedState = if ($IsMacOS) {
+            $true
+        } else {
+            $false
+        }
+
+        $out.results[0].result[0].result.inDesiredState | Should -Be $expectedState
+        $out.results[0].result[0].result.differingProperties.Count | Should -Be 0
+    }
 }

dsc_lib/src/configure/mod.rs

@@ -219,6 +219,7 @@ impl Configurator {
     /// # Returns
     ///
     /// * `&Configuration` - The configuration.
+    #[must_use]
     pub fn get_config(&self) -> &Configuration {
         &self.config
     }

dsc_lib/src/dscresources/command_resource.rs

@@ -4,30 +4,13 @@
 use jsonschema::JSONSchema;
 use serde_json::Value;
 use std::{collections::HashMap, env, io::{Read, Write}, process::{Command, Stdio}};
-use crate::{configure::{config_doc::ExecutionKind, {config_result::ResourceGetResult, parameters, Configurator}}, util::parse_input_to_json};
+use crate::configure::{config_doc::ExecutionKind, config_result::{ResourceGetResult, ResourceTestResult}};
 use crate::dscerror::DscError;
 use super::{dscresource::get_diff, invoke_result::{ExportResult, GetResult, ResolveResult, SetResult, TestResult, ValidateResult, ResourceGetResponse, ResourceSetResponse, ResourceTestResponse, get_in_desired_state}, resource_manifest::{ArgKind, InputKind, Kind, ResourceManifest, ReturnKind, SchemaKind}};
 use tracing::{error, warn, info, debug, trace};
 
 pub const EXIT_PROCESS_TERMINATED: i32 = 0x102;
 
-fn get_configurator(resource: &ResourceManifest, cwd: &str, filter: &str) -> Result<Configurator, DscError> {
-    let resolve_result = invoke_resolve(resource, cwd, filter)?;
-    let configuration = serde_json::to_string(&resolve_result.configuration)?;
-    let configuration_json = parse_input_to_json(&configuration)?;
-    let mut configurator = Configurator::new(&configuration_json)?;
-    let parameters = if let Some(parameters) = resolve_result.parameters {
-        let parameters_input = parameters::Input {
-            parameters,
-        };
-        Some(serde_json::to_value(parameters_input)?)
-    } else {
-        None
-    };
-    configurator.set_parameters(&parameters)?;
-    Ok(configurator)
-}
-
 /// Invoke the get operation on a resource
 ///
 /// # Arguments
@@ -40,12 +23,6 @@ fn get_configurator(resource: &ResourceManifest, cwd: &str, filter: &str) -> Res
 /// Error returned if the resource does not successfully get the current state
 pub fn invoke_get(resource: &ResourceManifest, cwd: &str, filter: &str) -> Result<GetResult, DscError> {
     debug!("Invoking get for '{}'", &resource.resource_type);
-    if resource.kind == Some(Kind::Import) {
-        let mut configurator = get_configurator(resource, cwd, filter)?;
-        let config_result = configurator.invoke_get()?;
-        return Ok(GetResult::Group(config_result.results));
-    }
-
     let mut command_input = CommandInput { env: None, stdin: None };
     let Some(get) = &resource.get else {
         return Err(DscError::NotImplemented("get".to_string()));
@@ -95,12 +72,6 @@ pub fn invoke_get(resource: &ResourceManifest, cwd: &str, filter: &str) -> Resul
 #[allow(clippy::too_many_lines)]
 pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_test: bool, execution_type: &ExecutionKind) -> Result<SetResult, DscError> {
     debug!("Invoking set for '{}'", &resource.resource_type);
-    if resource.kind == Some(Kind::Import) {
-        let mut configurator = get_configurator(resource, cwd, desired)?;
-        let config_result = configurator.invoke_set(skip_test)?;
-        return Ok(SetResult::Group(config_result.results));
-    }
-
     let operation_type: String;
     let mut is_synthetic_what_if = false;
     let set_method = match execution_type {
@@ -275,12 +246,6 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
 /// Error is returned if the underlying command returns a non-zero exit code.
 pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Result<TestResult, DscError> {
     debug!("Invoking test for '{}'", &resource.resource_type);
-    if resource.kind == Some(Kind::Import) {
-        let mut configurator = get_configurator(resource, cwd, expected)?;
-        let config_result = configurator.invoke_test()?;
-        return Ok(TestResult::Group(config_result.results));
-    }
-
     let Some(test) = &resource.test else {
         info!("Resource '{}' does not implement test, performing synthetic test", &resource.resource_type);
         return invoke_synthetic_test(resource, cwd, expected);
@@ -299,6 +264,12 @@ pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Re
         verify_json(resource, cwd, &stdout)?;
     }
 
+    if resource.kind == Some(Kind::Import) {
+        debug!("Import resource kind, returning group test response");
+        let group_test_response: Vec<ResourceTestResult> = serde_json::from_str(&stdout)?;
+        return Ok(TestResult::Group(group_test_response));
+    }
+
     let expected_value: Value = serde_json::from_str(expected)?;
     match test.returns {
         Some(ReturnKind::State) => {

dsc_lib/src/dscresources/dscresource.rs

@@ -234,15 +234,7 @@ impl Invoke for DscResource {
                 let resource_manifest = import_manifest(manifest.clone())?;
                 if resource_manifest.test.is_none() {
                     let get_result = self.get(expected)?;
-                    let desired_state = if self.kind == Kind::Import {
-                        let config = self.resolve(expected)?.configuration;
-                        // TODO: implement way to resolve entire config doc including expressions and parameters
-                        // as the raw configuration (desired state) won't match the result, also convert the desired
-                        // state to a TestResult so the comparison is consistent
-                        serde_json::to_value(config["resources"].clone())?
-                    } else {
-                        serde_json::from_str(expected)?
-                    };
+                    let desired_state = serde_json::from_str(expected)?;
                     let actual_state = match get_result {
                         GetResult::Group(results) => {
                             let mut result_array: Vec<Value> = Vec::new();