Method test

lib/dsc-lib/src/dscresources/dscresource.rs:437–486

(&self, expected: &str)

    }

    fn test(&self, expected: &str) -> Result<TestResult, DscError> {
        debug!("{}", t!("dscresources.dscresource.invokeTest", resource = self.type_name));
        if let Some(deprecation_message) = self.deprecation_message.as_ref() {
            warn!("{}", t!("dscresources.dscresource.deprecationMessage", resource = self.type_name, message = deprecation_message));
        }
        if let Some(adapter) = &self.require_adapter {
            return self.invoke_test_with_adapter(adapter, self, expected);
        }

        match &self.implemented_as {
            Some(ImplementedAs::Command) => {
                let Some(manifest) = &self.manifest else {
                    return Err(DscError::MissingManifest(self.type_name.to_string()));
                };

                // if test is not directly implemented, then we need to handle it here
                if manifest.test.is_none() {
                    let get_result = self.get(expected)?;
                    let mut desired_state = serde_json::from_str(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 diff_properties = get_diff( &desired_state, &actual_state);
                    desired_state = redact(&desired_state);
                    let test_result = TestResult::Resource(ResourceTestResponse {
                        desired_state,
                        actual_state,
                        in_desired_state: diff_properties.is_empty(),
                        diff_properties,
                    });
                    Ok(test_result)
                }
                else {
                    command_resource::invoke_test(self, expected, self.target_resource.as_deref())
                }
            },
            _ => {
                Err(DscError::NotImplemented(t!("dscresources.dscresource.customResourceNotSupported").to_string()))
            },
        }
    }

    fn delete(&self, filter: &str, execution_type: &ExecutionKind) -> Result<DeleteResultKind, DscError> {
        debug!("{}", t!("dscresources.dscresource.invokeDelete", resource = self.type_name));