Function invoke_test

lib/dsc-lib/src/dscresources/command_resource.rs:344–453

Invoke the test operation against a command resource. # Arguments `resource` - The resource manifest for the command resource. `expected` - The expected state of the resource in JSON. # Errors Error is returned if the underlying command returns a non-zero exit code.

(resource: &DscResource, expected: &str, target_resource: Option<&DscResource>)

///
/// Error is returned if the underlying command returns a non-zero exit code.
pub fn invoke_test(resource: &DscResource, expected: &str, target_resource: Option<&DscResource>) -> Result<TestResult, DscError> {
    debug!("{}", t!("dscresources.commandResource.invokeTest", resource = &resource.type_name));
    let Some(manifest) = &resource.manifest else {
        return Err(DscError::MissingManifest(resource.type_name.to_string()));
    };
    let Some(test) = &manifest.test else {
        info!("{}", t!("dscresources.commandResource.testSyntheticTest", resource = &resource.type_name));
        return invoke_synthetic_test(resource, expected, target_resource);
    };

    verify_json_from_manifest(resource, expected, target_resource)?;

    let resource_type = match target_resource {
        Some(r) => r.type_name.clone(),
        None => resource.type_name.clone(),
    };
    validate_security_context(&test.require_security_context, &resource_type, "test")?;
    let path = target_resource.map(|target_resource| target_resource.path.clone());
    let command_resource_info = CommandResourceInfo {
        type_name: resource_type.clone(),
        path,
    };
    let args = process_get_args(test.args.as_ref(), expected, &command_resource_info);
    let command_input = get_command_input(test.input.as_ref(), expected)?;

    info!("{}", t!("dscresources.commandResource.invokeTestUsing", resource = &resource.type_name, executable = &test.executable));
    let (exit_code, stdout, stderr) = invoke_command(&test.executable, args, command_input.stdin.as_deref(), Some(&resource.directory), command_input.env, manifest.exit_codes.as_ref())?;

    if resource.kind == Kind::Importer {
        debug!("{}", t!("dscresources.commandResource.testGroupTestResponse"));
        let group_test_response: Vec<ResourceTestResult> = serde_json::from_str(&stdout)?;
        return Ok(TestResult::Group(group_test_response));
    }

    let mut expected_value: Value = serde_json::from_str(expected)?;
    match test.returns {
        Some(ReturnKind::State) => {
            if resource.kind == Kind::Resource {
                debug!("{}", t!("dscresources.commandResource.testVerifyOutput", resource = &resource.type_name, executable = &test.executable));
                verify_json_from_manifest(resource, &stdout, target_resource)?;
            }

            let actual_value: Value = match serde_json::from_str(&stdout){
                Result::Ok(r) => {r},
                Result::Err(err) => {
                    return Err(DscError::Operation(t!("dscresources.commandResource.failedParseJson", executable = &test.executable, stdout = stdout, stderr = stderr, err = err).to_string()))
                }
            };
            let in_desired_state = get_desired_state(&actual_value)?;
            let diff_properties = get_diff(&expected_value, &actual_value);
            expected_value = redact(&expected_value);
            Ok(TestResult::Resource(ResourceTestResponse {
                desired_state: expected_value,
                actual_state: actual_value,
                in_desired_state: in_desired_state.unwrap_or(diff_properties.is_empty()),
                diff_properties,
            }))
        },