Struct aws_sdk_cloudfront::model::TestResult

#[non_exhaustive]
pub struct TestResult { /* private fields */ }

Contains the result of testing a CloudFront function with TestFunction.

Implementations

impl TestResult

pub fn function_summary(&self) -> Option<&FunctionSummary>

Contains configuration information and metadata about the CloudFront function that was tested.

pub fn compute_utilization(&self) -> Option<&str>

The amount of time that the function took to run as a percentage of the maximum allowed time. For example, a compute utilization of 35 means that the function completed in 35% of the maximum allowed time.

pub fn function_execution_logs(&self) -> Option<&[String]>

Contains the log lines that the function wrote (if any) when running the test.

pub fn function_error_message(&self) -> Option<&str>

If the result of testing the function was an error, this field contains the error message.

pub fn function_output(&self) -> Option<&str>

The event object returned by the function. For more information about the structure of the event object, see Event object structure in the Amazon CloudFront Developer Guide.

impl TestResult

pub fn builder() -> Builder

Creates a new builder-style object to manufacture TestResult.

Examples found in repository

src/xml_deser.rs (line 9138)

pub fn deser_structure_crate_model_test_result(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TestResult, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TestResult::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("FunctionSummary") /* FunctionSummary com.amazonaws.cloudfront#TestResult$FunctionSummary */ =>  {
                let var_341 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_function_summary(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_function_summary(var_341);
            }
            ,
            s if s.matches("ComputeUtilization") /* ComputeUtilization com.amazonaws.cloudfront#TestResult$ComputeUtilization */ =>  {
                let var_342 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_compute_utilization(var_342);
            }
            ,
            s if s.matches("FunctionExecutionLogs") /* FunctionExecutionLogs com.amazonaws.cloudfront#TestResult$FunctionExecutionLogs */ =>  {
                let var_343 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_cloudfront_function_execution_log_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_function_execution_logs(var_343);
            }
            ,
            s if s.matches("FunctionErrorMessage") /* FunctionErrorMessage com.amazonaws.cloudfront#TestResult$FunctionErrorMessage */ =>  {
                let var_344 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_function_error_message(var_344);
            }
            ,
            s if s.matches("FunctionOutput") /* FunctionOutput com.amazonaws.cloudfront#TestResult$FunctionOutput */ =>  {
                let var_345 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_function_output(var_345);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for TestResult

fn clone(&self) -> TestResult

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TestResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<TestResult> for TestResult

fn eq(&self, other: &TestResult) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for TestResult