Update engine to call delete for resources that don't support _exist directly

dsc/tests/dsc_config_set.tests.ps1

@@ -0,0 +1,30 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+Describe 'dsc config set tests' {
+    It 'can use _exist with resources that support and do not support it' {
+        $config_yaml = @"
+            `$schema: https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2023/10/config/document.json
+            resources:
+            - name: Exist
+              type: Test/Exist
+              properties:
+                _exist: false
+            - name: Delete
+              type: Test/Delete
+              properties:
+                _exist: false
+"@
+        $out = $config_yaml | dsc config set | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].type | Should -BeExactly 'Test/Exist'
+        $out.results[0].result.beforeState._exist | Should -BeFalse
+        $out.results[0].result.afterState.state | Should -BeExactly 'Absent'
+        $out.results[0].result.afterState._exist | Should -BeFalse
+        $out.results[1].type | Should -BeExactly 'Test/Delete'
+        $out.results[1].result.beforeState.deleteCalled | Should -BeTrue
+        $out.results[1].result.beforeState._exist | Should -BeFalse
+        $out.results[1].result.afterState.deleteCalled | Should -BeTrue
+        $out.results[1].result.afterState._exist | Should -BeFalse
+    }
+}

dsc_lib/src/configure/mod.rs

@@ -3,7 +3,9 @@
 
 use crate::configure::parameters::Input;
 use crate::dscerror::DscError;
-use crate::dscresources::dscresource::Invoke;
+use crate::dscresources::dscresource::get_diff;
+use crate::dscresources::invoke_result::GetResult;
+use crate::dscresources::{dscresource::{Capability, Invoke}, invoke_result::{SetResult, ResourceSetResponse}};
 use crate::dscresources::resource_manifest::Kind;
 use crate::DscResource;
 use crate::discovery::Discovery;
@@ -278,16 +280,67 @@ impl Configurator {
                 return Err(DscError::ResourceNotFound(resource.resource_type));
             };
             debug!("resource_type {}", &resource.resource_type);
+
+            // see if the properties contains `_exist` and is false
+            let exist = match &properties {
+                Some(property_map) => {
+                    if let Some(exist) = property_map.get("_exist") {
+                        !matches!(exist, Value::Bool(false))
+                    } else {
+                        true
+                    }
+                },
+                _ => {
+                    true
+                }
+            };
+
             let desired = add_metadata(&dsc_resource.kind, properties)?;
             trace!("desired: {desired}");
-            let set_result = dsc_resource.set(&desired, skip_test)?;
-            self.context.outputs.insert(format!("{}:{}", resource.resource_type, resource.name), serde_json::to_value(&set_result)?);
-            let resource_result = config_result::ResourceSetResult {
-                name: resource.name.clone(),
-                resource_type: resource.resource_type.clone(),
-                result: set_result,
-            };
-            result.results.push(resource_result);
+
+            if exist || dsc_resource.capabilities.contains(&Capability::SetHandlesExist) {
+                debug!("Resource handles _exist or _exist is true");
+                let set_result = dsc_resource.set(&desired, skip_test)?;
+                self.context.outputs.insert(format!("{}:{}", resource.resource_type, resource.name), serde_json::to_value(&set_result)?);
+                let resource_result = config_result::ResourceSetResult {
+                    name: resource.name.clone(),
+                    resource_type: resource.resource_type.clone(),
+                    result: set_result,
+                };
+                result.results.push(resource_result);    
+            } else if dsc_resource.capabilities.contains(&Capability::Delete) {
+                debug!("Resource implements delete and _exist is false");
+                let before_result = dsc_resource.get(&desired)?;
+                dsc_resource.delete(&desired)?;
+                let after_result = dsc_resource.get(&desired)?;
+                // convert get result to set result                
+                let set_result = match before_result {
+                    GetResult::Resource(before_response) => {
+                        let GetResult::Resource(after_result) = after_result else { 
+                            return Err(DscError::NotSupported("Group resources not supported for delete".to_string()))
+                        };
+                        let before_value = serde_json::to_value(&before_response.actual_state)?;
+                        let after_value = serde_json::to_value(&after_result.actual_state)?;
+                        ResourceSetResponse {
+                            before_state: before_response.actual_state,
+                            after_state: after_result.actual_state,
+                            changed_properties: Some(get_diff(&before_value, &after_value)),
+                        }
+                    },
+                    GetResult::Group(_) => {
+                        return Err(DscError::NotSupported("Group resources not supported for delete".to_string()));
+                    },
+                };
+                self.context.outputs.insert(format!("{}:{}", resource.resource_type, resource.name), serde_json::to_value(&set_result)?);
+                let resource_result = config_result::ResourceSetResult {
+                    name: resource.name.clone(),
+                    resource_type: resource.resource_type.clone(),
+                    result: SetResult::Resource(set_result),
+                };
+                result.results.push(resource_result);
+            } else {
+                return Err(DscError::NotImplemented(format!("Resource '{}' does not support `delete` and does not handle `_exist` as false", resource.resource_type)));
+            }
         }
 
         mem::drop(pb_span_enter);

dsc_lib/src/dscerror.rs

@@ -71,6 +71,9 @@ pub enum DscError {
     #[error("Not implemented: {0}")]
     NotImplemented(String),
 
+    #[error("Not supported: {0}")]
+    NotSupported(String),
+
     #[error("Number conversion error: {0}")]
     NumberConversion(#[from] std::num::TryFromIntError),
 

dsc_lib/src/dscresources/command_resource.rs

@@ -120,7 +120,7 @@ pub fn invoke_set(resource: &ResourceManifest, cwd: &str, desired: &str, skip_te
     verify_json(resource, cwd, desired)?;
 
     // if resource doesn't implement a pre-test, we execute test first to see if a set is needed
-    if !skip_test && !set.pre_test.unwrap_or_default() {
+    if !skip_test && set.pre_test != Some(true) {
         info!("No pretest, invoking test {}", &resource.resource_type);
         let (in_desired_state, actual_state) = match invoke_test(resource, cwd, desired)? {
             TestResult::Group(group_response) => {
@@ -282,7 +282,8 @@ 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> {
     let Some(test) = &resource.test else {
-        return Err(DscError::NotImplemented("test".to_string()));
+        info!("Resource '{}' does not implement test, performing synthetic test", &resource.resource_type);
+        return invoke_synthetic_test(resource, cwd, expected);
     };
 
     verify_json(resource, cwd, expected)?;
@@ -375,6 +376,30 @@ pub fn invoke_test(resource: &ResourceManifest, cwd: &str, expected: &str) -> Re
     }
 }
 
+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 {
+        GetResult::Group(results) => {
+            let mut result_array: Vec<Value> = Vec::new();
+            for result in results {
+                result_array.push(serde_json::to_value(&result)?);
+            }
+            Value::from(result_array)
+        },
+        GetResult::Resource(response) => {
+            response.actual_state
+        }
+    };
+    let expected_value: Value = serde_json::from_str(expected)?;
+    let diff_properties = get_diff(&expected_value, &actual_state);
+    Ok(TestResult::Resource(ResourceTestResponse {
+        desired_state: expected_value,
+        actual_state,
+        in_desired_state: diff_properties.is_empty(),
+        diff_properties,
+    }))
+}
+
 /// Invoke the delete operation against a command resource.
 /// 
 /// # Arguments
@@ -393,7 +418,7 @@ pub fn invoke_delete(resource: &ResourceManifest, cwd: &str, filter: &str) -> Re
 
     let mut env: Option<HashMap<String, String>> = None;
     let mut input_filter: Option<&str> = None;
-    let mut get_args = resource.get.args.clone();
+    let mut delete_args = delete.args.clone();
     verify_json(resource, cwd, filter)?;
     match &delete.input {
         InputKind::Env => {
@@ -403,12 +428,12 @@ pub fn invoke_delete(resource: &ResourceManifest, cwd: &str, filter: &str) -> Re
             input_filter = Some(filter);
         },
         InputKind::Arg(arg_name) => {
-            replace_token(&mut get_args, arg_name, filter)?;
+            replace_token(&mut delete_args, arg_name, filter)?;
         },
     }
 
     info!("Invoking delete '{}' using '{}'", &resource.resource_type, &delete.executable);
-    let (exit_code, _stdout, stderr) = invoke_command(&delete.executable, get_args, input_filter, Some(cwd), env)?;
+    let (exit_code, _stdout, stderr) = invoke_command(&delete.executable, delete_args, input_filter, Some(cwd), env)?;
     log_resource_traces(&stderr);
     if exit_code != 0 {
         return Err(DscError::Command(resource.resource_type.clone(), exit_code, stderr));

registry/registry.dsc.resource.json

@@ -34,7 +34,7 @@
         "executable": "registry",
         "args": [
             "config",
-            "remove",
+            "delete",
             "--input",
             "{json}"
         ],

registry/tests/registry.config.set.tests.ps1

@@ -2,6 +2,12 @@
 # Licensed under the MIT License.
 
 Describe 'registry config set tests' {
+    AfterEach {
+        if ($IsWindows) {
+            Remove-Item -Path 'HKCU:\1' -Recurse -ErrorAction Ignore
+        }
+    }
+
     It 'Can set a deeply nested key and value' -Skip:(!$IsWindows) {
         $json = @'
         {
@@ -29,4 +35,41 @@ Describe 'registry config set tests' {
         $result.valueData.String | Should -Be 'World'
         ($result.psobject.properties | Measure-Object).Count | Should -Be 3
     }
+
+    It 'delete called when _exist is false' -Skip:(!$IsWindows) {
+        $config = @{
+            '$schema' = 'https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2023/08/config/document.json'
+            resources = @(
+                @{
+                    name = 'reg'
+                    type = 'Microsoft.Windows/Registry'
+                    properties = @{
+                        keyPath = 'HKCU\1\2'
+                        valueName = 'Test'
+                        valueData = @{
+                            String = 'Test'
+                        }
+                        _exist = $true
+                    }
+                }
+            )
+        }
+
+        $out = dsc config set -d ($config | ConvertTo-Json -Depth 10)
+        $LASTEXITCODE | Should -Be 0
+
+        $config.resources[0].properties._exist = $false
+        $out = dsc config set -d ($config | ConvertTo-Json -Depth 10) | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].result.afterState._exist | Should -Be $false
+
+        Get-ItemProperty -Path 'HKCU:\1\2' -Name 'Test' -ErrorAction Ignore | Should -BeNullOrEmpty
+
+        $config.resources[0].properties.valueName = $null
+        $out = dsc config set -d ($config | ConvertTo-Json -Depth 10) | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].result.afterState._exist | Should -Be $false
+
+        Get-Item -Path 'HKCU:\1\2' -ErrorAction Ignore | Should -BeNullOrEmpty
+    }
 }

tools/dsctest/dscdelete.dsc.resource.json

@@ -0,0 +1,37 @@
+{
+    "$schema": "https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2023/08/bundled/resource/manifest.json",
+    "type": "Test/Delete",
+    "version": "0.1.0",
+    "get": {
+        "executable": "dsctest",
+        "args": [
+            "delete",
+            "--input",
+            "{json}"
+        ],
+        "input": {
+            "arg": "{json}"
+        }
+    },
+    "delete": {
+        "executable": "dsctest",
+        "args": [
+            "delete",
+            "--input",
+            "{json}"
+        ],
+        "input": {
+            "arg": "{json}"
+        }
+    },
+    "schema": {
+        "command": {
+            "executable": "dsctest",
+            "args": [
+                "schema",
+                "-s",
+                "delete"
+            ]
+        }
+    }
+}

tools/dsctest/src/args.rs

@@ -5,6 +5,7 @@ use clap::{Parser, Subcommand, ValueEnum};
 
 #[derive(Debug, Clone, PartialEq, Eq, ValueEnum)]
 pub enum Schemas {
+    Delete,
     Echo,
     Exist,
     Sleep,
@@ -20,12 +21,24 @@ pub struct Args {
 
 #[derive(Debug, PartialEq, Eq, Subcommand)]
 pub enum SubCommand {
+    #[clap(name = "delete", about = "delete operation")]
+    Delete {
+        #[clap(name = "input", short, long, help = "The input to the delete command as JSON")]
+        input: String,
+    },
+
     #[clap(name = "echo", about = "Return the input")]
     Echo {
         #[clap(name = "input", short, long, help = "The input to the echo command as JSON")]
         input: String,
     },
 
+    #[clap(name = "exist", about = "Check if a resource exists")]
+    Exist {
+        #[clap(name = "input", short, long, help = "The input to the exist command as JSON")]
+        input: String,
+    },
+
     #[clap(name = "schema", about = "Get the JSON schema for a subcommand")]
     Schema {
         #[clap(name = "subcommand", short, long, help = "The subcommand to get the schema for")]
@@ -37,10 +50,4 @@ pub enum SubCommand {
         #[clap(name = "input", short, long, help = "The input to the sleep command as JSON")]
         input: String,
     },
-
-    #[clap(name = "exist", about = "Check if a resource exists")]
-    Exist {
-        #[clap(name = "input", short, long, help = "The input to the exist command as JSON")]
-        input: String,
-    },
 }

tools/dsctest/src/delete.rs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct Delete {
+    #[serde(rename = "deleteCalled", skip_serializing_if = "Option::is_none")]
+    pub delete_called: Option<bool>,
+    #[serde(rename = "_exist")]
+    pub exist: bool,
+}