Struct SyntheticsAPIWaitStep

#[non_exhaustive]
pub struct SyntheticsAPIWaitStep {
    pub name: String,
    pub subtype: SyntheticsAPIWaitStepSubtype,
    pub value: i32,
    pub additional_properties: BTreeMap<String, Value>,
    /* private fields */
}

The Wait step used in a Synthetic multi-step API test.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

The name of the step.

subtype: SyntheticsAPIWaitStepSubtype

The subtype of the Synthetic multi-step API wait step.

value: i32

The time to wait in seconds. Minimum value: 0. Maximum value: 180.

additional_properties: BTreeMap<String, Value>

Implementations

impl SyntheticsAPIWaitStep

pub fn new( name: String, subtype: SyntheticsAPIWaitStepSubtype, value: i32, ) -> SyntheticsAPIWaitStep

Examples found in repository

examples/v1_synthetics_CreateSyntheticsAPITest_1279271422.rs (line 101)

async fn main() {
    let body =
        SyntheticsAPITest::new(
            SyntheticsAPITestConfig::new()
                .config_variables(
                    vec![
                        SyntheticsConfigVariable::new("PROPERTY".to_string(), SyntheticsConfigVariableType::TEXT)
                            .example("content-type".to_string())
                            .pattern("content-type".to_string())
                    ],
                )
                .steps(
                    vec![
                        SyntheticsAPIStep::SyntheticsAPITestStep(
                            Box::new(
                                SyntheticsAPITestStep::new(
                                    vec![
                                        SyntheticsAssertion::SyntheticsAssertionTarget(
                                            Box::new(
                                                SyntheticsAssertionTarget::new(
                                                    SyntheticsAssertionOperator::IS,
                                                    SyntheticsAssertionTargetValue
                                                    ::SyntheticsAssertionTargetValueNumber(
                                                        200.0 as f64,
                                                    ),
                                                    SyntheticsAssertionType::STATUS_CODE,
                                                ),
                                            ),
                                        )
                                    ],
                                    "request is sent".to_string(),
                                    SyntheticsTestRequest::new()
                                        .http_version(SyntheticsTestOptionsHTTPVersion::HTTP2)
                                        .method("GET".to_string())
                                        .timeout(10.0 as f64)
                                        .url("https://datadoghq.com".to_string()),
                                    SyntheticsAPITestStepSubtype::HTTP,
                                )
                                    .allow_failure(true)
                                    .exit_if_succeed(true)
                                    .extracted_values(
                                        vec![
                                            SyntheticsParsingOptions::new()
                                                .field("server".to_string())
                                                .name("EXTRACTED_VALUE".to_string())
                                                .parser(
                                                    SyntheticsVariableParser::new(
                                                        SyntheticsGlobalVariableParserType::RAW,
                                                    ),
                                                )
                                                .secure(true)
                                                .type_(SyntheticsLocalVariableParsingOptionsType::HTTP_HEADER)
                                        ],
                                    )
                                    .extracted_values_from_script(
                                        "dd.variable.set('STATUS_CODE', dd.response.statusCode);".to_string(),
                                    )
                                    .is_critical(true)
                                    .retry(SyntheticsTestOptionsRetry::new().count(5).interval(1000.0 as f64)),
                            ),
                        ),
                        SyntheticsAPIStep::SyntheticsAPIWaitStep(
                            Box::new(
                                SyntheticsAPIWaitStep::new("Wait".to_string(), SyntheticsAPIWaitStepSubtype::WAIT, 1),
                            ),
                        ),
                        SyntheticsAPIStep::SyntheticsAPITestStep(
                            Box::new(
                                SyntheticsAPITestStep::new(
                                    vec![
                                        SyntheticsAssertion::SyntheticsAssertionTarget(
                                            Box::new(
                                                SyntheticsAssertionTarget::new(
                                                    SyntheticsAssertionOperator::LESS_THAN,
                                                    SyntheticsAssertionTargetValue
                                                    ::SyntheticsAssertionTargetValueNumber(
                                                        1000.0 as f64,
                                                    ),
                                                    SyntheticsAssertionType::RESPONSE_TIME,
                                                ),
                                            ),
                                        )
                                    ],
                                    "GRPC CALL".to_string(),
                                    SyntheticsTestRequest::new()
                                        .call_type(SyntheticsTestCallType::UNARY)
                                        .compressed_json_descriptor(
                                            "eJy1lU1z2yAQhv+Lzj74I3ETH506bQ7OZOSm1w4Wa4epBARQppqM/3v5koCJJdvtxCdW77vPssCO3zMKUgHOFu/ZXvBiS6hZho/f8qe7pftYgXphWJrlA8XwxywEvNba+6PhkC2yVcVVswYp0R6ykRYlZ1SCV21SDrxsssPIeS9FJKqGfK2rqnmmSBwhWa2XlKgtaQPiDcRGCUDVfwGD2sKUqKEtc1cSoOrsMlaMOec1sySYCCgUYRSVLv2zSva2u+FQkB0pVkIw8bFuIudOOn3pOaKYVT3Iy97Pd0AYhOx5QcMsnxvRHlnuLf8ETDd3CNtrv2nejkDpRnANCmGkkFn/hsYzpBKE7jVbufgnKnV9HRM9zRPDDKPttYT61n0TdWkAAjggk9AhuxIeaXd69CYTcsGw7cBTakLVbNpRzGEgyWjkSOpMbZXkhGL6oX30R49qt3GoHrap7i0XdD41WQ+2icCNm5p1hmFqnHNlcla0riKmDZ183crDxChjbnurtxHPRE784sVhWvDfGP+SsTKibU3o5NtWHuZFGZOxP6P5VXqIOvaOSec4eYohyd7NslHuJbd1bewds85xYrNxkr2d+5IhFWF3NvaO684xjE2S5ulY+tu64Pna0fCPJgzw6vF5/WucLcYjt5xoq19O3UDptOg/OamJQRaCcPPnMTQ2QDFn+uhPvUfnCrMc99upyQY4Ui9Dlc/YoG3R/v4Cs9YE+g==".to_string(),
                                        )
                                        .host("grpcbin.test.k6.io".to_string())
                                        .message("{}".to_string())
                                        .metadata(BTreeMap::from([]))
                                        .method("Index".to_string())
                                        .port(SyntheticsTestRequestPort::SyntheticsTestRequestNumericalPort(9000))
                                        .service("grpcbin.GRPCBin".to_string()),
                                    SyntheticsAPITestStepSubtype::GRPC,
                                )
                                    .allow_failure(false)
                                    .extracted_values(vec![])
                                    .is_critical(true)
                                    .retry(SyntheticsTestOptionsRetry::new().count(0).interval(300.0 as f64)),
                            ),
                        ),
                        SyntheticsAPIStep::SyntheticsAPITestStep(
                            Box::new(
                                SyntheticsAPITestStep::new(
                                    vec![
                                        SyntheticsAssertion::SyntheticsAssertionTarget(
                                            Box::new(
                                                SyntheticsAssertionTarget::new(
                                                    SyntheticsAssertionOperator::IS_IN_MORE_DAYS_THAN,
                                                    SyntheticsAssertionTargetValue
                                                    ::SyntheticsAssertionTargetValueNumber(
                                                        10.0 as f64,
                                                    ),
                                                    SyntheticsAssertionType::CERTIFICATE,
                                                ),
                                            ),
                                        )
                                    ],
                                    "SSL step".to_string(),
                                    SyntheticsTestRequest::new()
                                        .check_certificate_revocation(true)
                                        .host("example.org".to_string())
                                        .port(SyntheticsTestRequestPort::SyntheticsTestRequestNumericalPort(443)),
                                    SyntheticsAPITestStepSubtype::SSL,
                                )
                                    .allow_failure(false)
                                    .is_critical(true)
                                    .retry(SyntheticsTestOptionsRetry::new().count(0).interval(300.0 as f64)),
                            ),
                        ),
                        SyntheticsAPIStep::SyntheticsAPITestStep(
                            Box::new(
                                SyntheticsAPITestStep::new(
                                    vec![
                                        SyntheticsAssertion::SyntheticsAssertionTarget(
                                            Box::new(
                                                SyntheticsAssertionTarget::new(
                                                    SyntheticsAssertionOperator::LESS_THAN,
                                                    SyntheticsAssertionTargetValue
                                                    ::SyntheticsAssertionTargetValueNumber(
                                                        1000.0 as f64,
                                                    ),
                                                    SyntheticsAssertionType::RESPONSE_TIME,
                                                ),
                                            ),
                                        )
                                    ],
                                    "DNS step".to_string(),
                                    SyntheticsTestRequest::new()
                                        .dns_server("8.8.8.8".to_string())
                                        .dns_server_port(
                                            SyntheticsTestRequestDNSServerPort
                                            ::SyntheticsTestRequestVariableDNSServerPort(
                                                "53".to_string(),
                                            ),
                                        )
                                        .host("troisdizaines.com".to_string()),
                                    SyntheticsAPITestStepSubtype::DNS,
                                )
                                    .allow_failure(false)
                                    .is_critical(true)
                                    .retry(SyntheticsTestOptionsRetry::new().count(0).interval(300.0 as f64)),
                            ),
                        ),
                        SyntheticsAPIStep::SyntheticsAPITestStep(
                            Box::new(
                                SyntheticsAPITestStep::new(
                                    vec![
                                        SyntheticsAssertion::SyntheticsAssertionTarget(
                                            Box::new(
                                                SyntheticsAssertionTarget::new(
                                                    SyntheticsAssertionOperator::LESS_THAN,
                                                    SyntheticsAssertionTargetValue
                                                    ::SyntheticsAssertionTargetValueNumber(
                                                        1000.0 as f64,
                                                    ),
                                                    SyntheticsAssertionType::RESPONSE_TIME,
                                                ),
                                            ),
                                        )
                                    ],
                                    "TCP step".to_string(),
                                    SyntheticsTestRequest::new()
                                        .host("34.95.79.70".to_string())
                                        .port(SyntheticsTestRequestPort::SyntheticsTestRequestNumericalPort(80))
                                        .should_track_hops(true)
                                        .timeout(32.0 as f64),
                                    SyntheticsAPITestStepSubtype::TCP,
                                )
                                    .allow_failure(false)
                                    .is_critical(true)
                                    .retry(SyntheticsTestOptionsRetry::new().count(0).interval(300.0 as f64)),
                            ),
                        ),
                        SyntheticsAPIStep::SyntheticsAPITestStep(
                            Box::new(
                                SyntheticsAPITestStep::new(
                                    vec![
                                        SyntheticsAssertion::SyntheticsAssertionTarget(
                                            Box::new(
                                                SyntheticsAssertionTarget::new(
                                                    SyntheticsAssertionOperator::IS,
                                                    SyntheticsAssertionTargetValue
                                                    ::SyntheticsAssertionTargetValueNumber(
                                                        0.0 as f64,
                                                    ),
                                                    SyntheticsAssertionType::PACKET_LOSS_PERCENTAGE,
                                                ),
                                            ),
                                        )
                                    ],
                                    "ICMP step".to_string(),
                                    SyntheticsTestRequest::new()
                                        .host("34.95.79.70".to_string())
                                        .number_of_packets(4)
                                        .should_track_hops(true)
                                        .timeout(38.0 as f64),
                                    SyntheticsAPITestStepSubtype::ICMP,
                                )
                                    .allow_failure(false)
                                    .is_critical(true)
                                    .retry(SyntheticsTestOptionsRetry::new().count(0).interval(300.0 as f64)),
                            ),
                        ),
                        SyntheticsAPIStep::SyntheticsAPITestStep(
                            Box::new(
                                SyntheticsAPITestStep::new(
                                    vec![
                                        SyntheticsAssertion::SyntheticsAssertionTarget(
                                            Box::new(
                                                SyntheticsAssertionTarget::new(
                                                    SyntheticsAssertionOperator::LESS_THAN,
                                                    SyntheticsAssertionTargetValue
                                                    ::SyntheticsAssertionTargetValueNumber(
                                                        1000.0 as f64,
                                                    ),
                                                    SyntheticsAssertionType::RESPONSE_TIME,
                                                ),
                                            ),
                                        )
                                    ],
                                    "Websocket step".to_string(),
                                    SyntheticsTestRequest::new()
                                        .basic_auth(
                                            SyntheticsBasicAuth::SyntheticsBasicAuthWeb(
                                                Box::new(
                                                    SyntheticsBasicAuthWeb::new()
                                                        .password("password".to_string())
                                                        .type_(SyntheticsBasicAuthWebType::WEB)
                                                        .username("user".to_string()),
                                                ),
                                            ),
                                        )
                                        .headers(BTreeMap::from([("f".to_string(), "g".to_string())]))
                                        .is_message_base64_encoded(true)
                                        .message("My message".to_string())
                                        .url("ws://34.95.79.70/web-socket".to_string()),
                                    SyntheticsAPITestStepSubtype::WEBSOCKET,
                                )
                                    .allow_failure(false)
                                    .is_critical(true)
                                    .retry(SyntheticsTestOptionsRetry::new().count(0).interval(300.0 as f64)),
                            ),
                        ),
                        SyntheticsAPIStep::SyntheticsAPITestStep(
                            Box::new(
                                SyntheticsAPITestStep::new(
                                    vec![
                                        SyntheticsAssertion::SyntheticsAssertionTarget(
                                            Box::new(
                                                SyntheticsAssertionTarget::new(
                                                    SyntheticsAssertionOperator::LESS_THAN,
                                                    SyntheticsAssertionTargetValue
                                                    ::SyntheticsAssertionTargetValueNumber(
                                                        1000.0 as f64,
                                                    ),
                                                    SyntheticsAssertionType::RESPONSE_TIME,
                                                ),
                                            ),
                                        )
                                    ],
                                    "UDP step".to_string(),
                                    SyntheticsTestRequest::new()
                                        .host("8.8.8.8".to_string())
                                        .message("A image.google.com".to_string())
                                        .port(SyntheticsTestRequestPort::SyntheticsTestRequestNumericalPort(53)),
                                    SyntheticsAPITestStepSubtype::UDP,
                                )
                                    .allow_failure(false)
                                    .is_critical(true)
                                    .retry(SyntheticsTestOptionsRetry::new().count(0).interval(300.0 as f64)),
                            ),
                        )
                    ],
                ),
            vec!["aws:us-east-2".to_string()],
            "BDD test payload: synthetics_api_test_multi_step_payload.json".to_string(),
            "Example-Synthetic".to_string(),
            SyntheticsTestOptions::new()
                .accept_self_signed(false)
                .allow_insecure(true)
                .follow_redirects(true)
                .min_failure_duration(10)
                .min_location_failed(1)
                .monitor_name("Example-Synthetic".to_string())
                .monitor_priority(5)
                .retry(SyntheticsTestOptionsRetry::new().count(3).interval(1000.0 as f64))
                .tick_every(60),
            SyntheticsAPITestType::API,
        )
            .subtype(SyntheticsTestDetailsSubType::MULTI)
            .tags(vec!["testing:api".to_string()]);
    let configuration = datadog::Configuration::new();
    let api = SyntheticsAPI::with_config(configuration);
    let resp = api.create_synthetics_api_test(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub fn additional_properties(self, value: BTreeMap<String, Value>) -> Self

Trait Implementations

impl Clone for SyntheticsAPIWaitStep

fn clone(&self) -> SyntheticsAPIWaitStep

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyntheticsAPIWaitStep

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SyntheticsAPIWaitStep

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SyntheticsAPIWaitStep

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for SyntheticsAPIWaitStep

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SyntheticsAPIWaitStep