SyntheticsTestRequestBodyFile

datadog_api_client::datadogV1::model::model_synthetics_test_request_body_file

Struct SyntheticsTestRequestBodyFile 

Source 
#[non_exhaustive]
pub struct SyntheticsTestRequestBodyFile {
    pub bucket_key: Option<String>,
    pub content: Option<String>,
    pub name: Option<String>,
    pub original_file_name: Option<String>,
    pub size: Option<i64>,
    pub type_: Option<String>,
    pub additional_properties: BTreeMap<String, Value>,
    /* private fields */
}
Expand description

Object describing a file to be used as part of the request in the test.

Fields (Non-exhaustive)§

This struct is marked as 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.
§bucket_key: Option<String>

Bucket key of the file.

§content: Option<String>

Content of the file.

§name: Option<String>

Name of the file.

§original_file_name: Option<String>

Original name of the file.

§size: Option<i64>

Size of the file.

§type_: Option<String>

Type of the file.

§additional_properties: BTreeMap<String, Value>

Implementations§

Source§

impl SyntheticsTestRequestBodyFile

Source

pub fn new() -> SyntheticsTestRequestBodyFile

Examples found in repository?
examples/v1_synthetics_UpdateBrowserTest.rs (line 55)
36async fn main() {
37    let body = SyntheticsBrowserTest::new(
38        SyntheticsBrowserTestConfig::new(
39            vec![],
40            SyntheticsTestRequest::new()
41                .basic_auth(SyntheticsBasicAuth::SyntheticsBasicAuthWeb(Box::new(
42                    SyntheticsBasicAuthWeb::new()
43                        .password("PaSSw0RD!".to_string())
44                        .type_(SyntheticsBasicAuthWebType::WEB)
45                        .username("my_username".to_string()),
46                )))
47                .body_type(SyntheticsTestRequestBodyType::TEXT_PLAIN)
48                .call_type(SyntheticsTestCallType::UNARY)
49                .certificate(
50                    SyntheticsTestRequestCertificate::new()
51                        .cert(SyntheticsTestRequestCertificateItem::new())
52                        .key(SyntheticsTestRequestCertificateItem::new()),
53                )
54                .certificate_domains(vec![])
55                .files(vec![SyntheticsTestRequestBodyFile::new()])
56                .http_version(SyntheticsTestOptionsHTTPVersion::HTTP1)
57                .proxy(SyntheticsTestRequestProxy::new(
58                    "https://example.com".to_string(),
59                ))
60                .service("Greeter".to_string())
61                .url("https://example.com".to_string()),
62        )
63        .config_variables(vec![SyntheticsConfigVariable::new(
64            "VARIABLE_NAME".to_string(),
65            SyntheticsConfigVariableType::TEXT,
66        )
67        .secure(false)])
68        .variables(vec![SyntheticsBrowserVariable::new(
69            "VARIABLE_NAME".to_string(),
70            SyntheticsBrowserVariableType::TEXT,
71        )]),
72        vec!["aws:eu-west-3".to_string()],
73        "".to_string(),
74        "Example test name".to_string(),
75        SyntheticsTestOptions::new()
76            .ci(SyntheticsTestCiOptions::new(
77                SyntheticsTestExecutionRule::BLOCKING,
78            ))
79            .device_ids(vec!["chrome.laptop_large".to_string()])
80            .http_version(SyntheticsTestOptionsHTTPVersion::HTTP1)
81            .monitor_options(
82                SyntheticsTestOptionsMonitorOptions::new().notification_preset_name(
83                    SyntheticsTestOptionsMonitorOptionsNotificationPresetName::SHOW_ALL,
84                ),
85            )
86            .restricted_roles(vec!["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".to_string()])
87            .retry(SyntheticsTestOptionsRetry::new())
88            .rum_settings(
89                SyntheticsBrowserTestRumSettings::new(true)
90                    .application_id("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".to_string())
91                    .client_token_id(12345),
92            )
93            .scheduling(SyntheticsTestOptionsScheduling::new(
94                vec![
95                    SyntheticsTestOptionsSchedulingTimeframe::new(
96                        1,
97                        "07:00".to_string(),
98                        "16:00".to_string(),
99                    ),
100                    SyntheticsTestOptionsSchedulingTimeframe::new(
101                        3,
102                        "07:00".to_string(),
103                        "16:00".to_string(),
104                    ),
105                ],
106                "America/New_York".to_string(),
107            )),
108        SyntheticsBrowserTestType::BROWSER,
109    )
110    .status(SyntheticsTestPauseStatus::LIVE)
111    .steps(vec![
112        SyntheticsStep::new().type_(SyntheticsStepType::ASSERT_ELEMENT_CONTENT)
113    ])
114    .tags(vec!["env:prod".to_string()]);
115    let configuration = datadog::Configuration::new();
116    let api = SyntheticsAPI::with_config(configuration);
117    let resp = api.update_browser_test("public_id".to_string(), body).await;
118    if let Ok(value) = resp {
119        println!("{:#?}", value);
120    } else {
121        println!("{:#?}", resp.unwrap_err());
122    }
123}
More examples
Hide additional examples
examples/v1_synthetics_CreateSyntheticsAPITest_1241981394.rs (line 146)
39async fn main() {
40    let body =
41        SyntheticsAPITest::new(
42            SyntheticsAPITestConfig::new()
43                .assertions(
44                    vec![
45                        SyntheticsAssertion::SyntheticsAssertionTarget(
46                            Box::new(
47                                SyntheticsAssertionTarget::new(
48                                    SyntheticsAssertionOperator::IS,
49                                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
50                                        "text/html".to_string(),
51                                    ),
52                                    SyntheticsAssertionType::HEADER,
53                                ).property("{{ PROPERTY }}".to_string()),
54                            ),
55                        ),
56                        SyntheticsAssertion::SyntheticsAssertionTarget(
57                            Box::new(
58                                SyntheticsAssertionTarget::new(
59                                    SyntheticsAssertionOperator::LESS_THAN,
60                                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueNumber(
61                                        2000.0 as f64,
62                                    ),
63                                    SyntheticsAssertionType::RESPONSE_TIME,
64                                ).timings_scope(SyntheticsAssertionTimingsScope::WITHOUT_DNS),
65                            ),
66                        ),
67                        SyntheticsAssertion::SyntheticsAssertionJSONPathTarget(
68                            Box::new(
69                                SyntheticsAssertionJSONPathTarget::new(
70                                    SyntheticsAssertionJSONPathOperator::VALIDATES_JSON_PATH,
71                                    SyntheticsAssertionType::BODY,
72                                ).target(
73                                    SyntheticsAssertionJSONPathTargetTarget::new()
74                                        .json_path("topKey".to_string())
75                                        .operator("isNot".to_string())
76                                        .target_value(
77                                            SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
78                                                "0".to_string(),
79                                            ),
80                                        ),
81                                ),
82                            ),
83                        ),
84                        SyntheticsAssertion::SyntheticsAssertionXPathTarget(
85                            Box::new(
86                                SyntheticsAssertionXPathTarget::new(
87                                    SyntheticsAssertionXPathOperator::VALIDATES_X_PATH,
88                                    SyntheticsAssertionType::BODY,
89                                ).target(
90                                    SyntheticsAssertionXPathTargetTarget::new()
91                                        .operator("contains".to_string())
92                                        .target_value(
93                                            SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
94                                                "0".to_string(),
95                                            ),
96                                        )
97                                        .x_path("target-xpath".to_string()),
98                                ),
99                            ),
100                        )
101                    ],
102                )
103                .config_variables(
104                    vec![
105                        SyntheticsConfigVariable::new("PROPERTY".to_string(), SyntheticsConfigVariableType::TEXT)
106                            .example("content-type".to_string())
107                            .pattern("content-type".to_string())
108                    ],
109                )
110                .request(
111                    SyntheticsTestRequest::new()
112                        .basic_auth(
113                            SyntheticsBasicAuth::SyntheticsBasicAuthOauthClient(
114                                Box::new(
115                                    SyntheticsBasicAuthOauthClient::new(
116                                        "https://datadog-token.com".to_string(),
117                                        "client-id".to_string(),
118                                        "client-secret".to_string(),
119                                        SyntheticsBasicAuthOauthTokenApiAuthentication::HEADER,
120                                        SyntheticsBasicAuthOauthClientType::OAUTH_CLIENT,
121                                    )
122                                        .audience("audience".to_string())
123                                        .resource("resource".to_string())
124                                        .scope("yoyo".to_string()),
125                                ),
126                            ),
127                        )
128                        .body_type(SyntheticsTestRequestBodyType::APPLICATION_OCTET_STREAM)
129                        .certificate(
130                            SyntheticsTestRequestCertificate::new()
131                                .cert(
132                                    SyntheticsTestRequestCertificateItem::new()
133                                        .content("cert-content".to_string())
134                                        .filename("cert-filename".to_string())
135                                        .updated_at("2020-10-16T09:23:24.857Z".to_string()),
136                                )
137                                .key(
138                                    SyntheticsTestRequestCertificateItem::new()
139                                        .content("key-content".to_string())
140                                        .filename("key-filename".to_string())
141                                        .updated_at("2020-10-16T09:23:24.857Z".to_string()),
142                                ),
143                        )
144                        .files(
145                            vec![
146                                SyntheticsTestRequestBodyFile::new()
147                                    .content("file content".to_string())
148                                    .name("file name".to_string())
149                                    .original_file_name("image.png".to_string())
150                                    .type_("file type".to_string())
151                            ],
152                        )
153                        .headers(BTreeMap::from([("unique".to_string(), "examplesynthetic".to_string())]))
154                        .method("GET".to_string())
155                        .persist_cookies(true)
156                        .proxy(
157                            SyntheticsTestRequestProxy::new(
158                                "https://datadoghq.com".to_string(),
159                            ).headers(BTreeMap::from([])),
160                        )
161                        .timeout(10.0 as f64)
162                        .url("https://datadoghq.com".to_string()),
163                ),
164            vec!["aws:us-east-2".to_string()],
165            "BDD test payload: synthetics_api_http_test_payload.json".to_string(),
166            "Example-Synthetic".to_string(),
167            SyntheticsTestOptions::new()
168                .accept_self_signed(false)
169                .allow_insecure(true)
170                .follow_redirects(true)
171                .http_version(SyntheticsTestOptionsHTTPVersion::HTTP2)
172                .min_failure_duration(10)
173                .min_location_failed(1)
174                .monitor_name("Example-Synthetic".to_string())
175                .monitor_priority(5)
176                .retry(SyntheticsTestOptionsRetry::new().count(3).interval(10.0 as f64))
177                .tick_every(60),
178            SyntheticsAPITestType::API,
179        )
180            .subtype(SyntheticsTestDetailsSubType::HTTP)
181            .tags(vec!["testing:api".to_string()]);
182    let configuration = datadog::Configuration::new();
183    let api = SyntheticsAPI::with_config(configuration);
184    let resp = api.create_synthetics_api_test(body).await;
185    if let Ok(value) = resp {
186        println!("{:#?}", value);
187    } else {
188        println!("{:#?}", resp.unwrap_err());
189    }
190}
Source

pub fn bucket_key(self, value: String) -> Self

Source

pub fn content(self, value: String) -> Self

Examples found in repository?
examples/v1_synthetics_CreateSyntheticsAPITest_1241981394.rs (line 147)
39async fn main() {
40    let body =
41        SyntheticsAPITest::new(
42            SyntheticsAPITestConfig::new()
43                .assertions(
44                    vec![
45                        SyntheticsAssertion::SyntheticsAssertionTarget(
46                            Box::new(
47                                SyntheticsAssertionTarget::new(
48                                    SyntheticsAssertionOperator::IS,
49                                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
50                                        "text/html".to_string(),
51                                    ),
52                                    SyntheticsAssertionType::HEADER,
53                                ).property("{{ PROPERTY }}".to_string()),
54                            ),
55                        ),
56                        SyntheticsAssertion::SyntheticsAssertionTarget(
57                            Box::new(
58                                SyntheticsAssertionTarget::new(
59                                    SyntheticsAssertionOperator::LESS_THAN,
60                                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueNumber(
61                                        2000.0 as f64,
62                                    ),
63                                    SyntheticsAssertionType::RESPONSE_TIME,
64                                ).timings_scope(SyntheticsAssertionTimingsScope::WITHOUT_DNS),
65                            ),
66                        ),
67                        SyntheticsAssertion::SyntheticsAssertionJSONPathTarget(
68                            Box::new(
69                                SyntheticsAssertionJSONPathTarget::new(
70                                    SyntheticsAssertionJSONPathOperator::VALIDATES_JSON_PATH,
71                                    SyntheticsAssertionType::BODY,
72                                ).target(
73                                    SyntheticsAssertionJSONPathTargetTarget::new()
74                                        .json_path("topKey".to_string())
75                                        .operator("isNot".to_string())
76                                        .target_value(
77                                            SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
78                                                "0".to_string(),
79                                            ),
80                                        ),
81                                ),
82                            ),
83                        ),
84                        SyntheticsAssertion::SyntheticsAssertionXPathTarget(
85                            Box::new(
86                                SyntheticsAssertionXPathTarget::new(
87                                    SyntheticsAssertionXPathOperator::VALIDATES_X_PATH,
88                                    SyntheticsAssertionType::BODY,
89                                ).target(
90                                    SyntheticsAssertionXPathTargetTarget::new()
91                                        .operator("contains".to_string())
92                                        .target_value(
93                                            SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
94                                                "0".to_string(),
95                                            ),
96                                        )
97                                        .x_path("target-xpath".to_string()),
98                                ),
99                            ),
100                        )
101                    ],
102                )
103                .config_variables(
104                    vec![
105                        SyntheticsConfigVariable::new("PROPERTY".to_string(), SyntheticsConfigVariableType::TEXT)
106                            .example("content-type".to_string())
107                            .pattern("content-type".to_string())
108                    ],
109                )
110                .request(
111                    SyntheticsTestRequest::new()
112                        .basic_auth(
113                            SyntheticsBasicAuth::SyntheticsBasicAuthOauthClient(
114                                Box::new(
115                                    SyntheticsBasicAuthOauthClient::new(
116                                        "https://datadog-token.com".to_string(),
117                                        "client-id".to_string(),
118                                        "client-secret".to_string(),
119                                        SyntheticsBasicAuthOauthTokenApiAuthentication::HEADER,
120                                        SyntheticsBasicAuthOauthClientType::OAUTH_CLIENT,
121                                    )
122                                        .audience("audience".to_string())
123                                        .resource("resource".to_string())
124                                        .scope("yoyo".to_string()),
125                                ),
126                            ),
127                        )
128                        .body_type(SyntheticsTestRequestBodyType::APPLICATION_OCTET_STREAM)
129                        .certificate(
130                            SyntheticsTestRequestCertificate::new()
131                                .cert(
132                                    SyntheticsTestRequestCertificateItem::new()
133                                        .content("cert-content".to_string())
134                                        .filename("cert-filename".to_string())
135                                        .updated_at("2020-10-16T09:23:24.857Z".to_string()),
136                                )
137                                .key(
138                                    SyntheticsTestRequestCertificateItem::new()
139                                        .content("key-content".to_string())
140                                        .filename("key-filename".to_string())
141                                        .updated_at("2020-10-16T09:23:24.857Z".to_string()),
142                                ),
143                        )
144                        .files(
145                            vec![
146                                SyntheticsTestRequestBodyFile::new()
147                                    .content("file content".to_string())
148                                    .name("file name".to_string())
149                                    .original_file_name("image.png".to_string())
150                                    .type_("file type".to_string())
151                            ],
152                        )
153                        .headers(BTreeMap::from([("unique".to_string(), "examplesynthetic".to_string())]))
154                        .method("GET".to_string())
155                        .persist_cookies(true)
156                        .proxy(
157                            SyntheticsTestRequestProxy::new(
158                                "https://datadoghq.com".to_string(),
159                            ).headers(BTreeMap::from([])),
160                        )
161                        .timeout(10.0 as f64)
162                        .url("https://datadoghq.com".to_string()),
163                ),
164            vec!["aws:us-east-2".to_string()],
165            "BDD test payload: synthetics_api_http_test_payload.json".to_string(),
166            "Example-Synthetic".to_string(),
167            SyntheticsTestOptions::new()
168                .accept_self_signed(false)
169                .allow_insecure(true)
170                .follow_redirects(true)
171                .http_version(SyntheticsTestOptionsHTTPVersion::HTTP2)
172                .min_failure_duration(10)
173                .min_location_failed(1)
174                .monitor_name("Example-Synthetic".to_string())
175                .monitor_priority(5)
176                .retry(SyntheticsTestOptionsRetry::new().count(3).interval(10.0 as f64))
177                .tick_every(60),
178            SyntheticsAPITestType::API,
179        )
180            .subtype(SyntheticsTestDetailsSubType::HTTP)
181            .tags(vec!["testing:api".to_string()]);
182    let configuration = datadog::Configuration::new();
183    let api = SyntheticsAPI::with_config(configuration);
184    let resp = api.create_synthetics_api_test(body).await;
185    if let Ok(value) = resp {
186        println!("{:#?}", value);
187    } else {
188        println!("{:#?}", resp.unwrap_err());
189    }
190}
Source

pub fn name(self, value: String) -> Self

Examples found in repository?
examples/v1_synthetics_CreateSyntheticsAPITest_1241981394.rs (line 148)
39async fn main() {
40    let body =
41        SyntheticsAPITest::new(
42            SyntheticsAPITestConfig::new()
43                .assertions(
44                    vec![
45                        SyntheticsAssertion::SyntheticsAssertionTarget(
46                            Box::new(
47                                SyntheticsAssertionTarget::new(
48                                    SyntheticsAssertionOperator::IS,
49                                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
50                                        "text/html".to_string(),
51                                    ),
52                                    SyntheticsAssertionType::HEADER,
53                                ).property("{{ PROPERTY }}".to_string()),
54                            ),
55                        ),
56                        SyntheticsAssertion::SyntheticsAssertionTarget(
57                            Box::new(
58                                SyntheticsAssertionTarget::new(
59                                    SyntheticsAssertionOperator::LESS_THAN,
60                                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueNumber(
61                                        2000.0 as f64,
62                                    ),
63                                    SyntheticsAssertionType::RESPONSE_TIME,
64                                ).timings_scope(SyntheticsAssertionTimingsScope::WITHOUT_DNS),
65                            ),
66                        ),
67                        SyntheticsAssertion::SyntheticsAssertionJSONPathTarget(
68                            Box::new(
69                                SyntheticsAssertionJSONPathTarget::new(
70                                    SyntheticsAssertionJSONPathOperator::VALIDATES_JSON_PATH,
71                                    SyntheticsAssertionType::BODY,
72                                ).target(
73                                    SyntheticsAssertionJSONPathTargetTarget::new()
74                                        .json_path("topKey".to_string())
75                                        .operator("isNot".to_string())
76                                        .target_value(
77                                            SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
78                                                "0".to_string(),
79                                            ),
80                                        ),
81                                ),
82                            ),
83                        ),
84                        SyntheticsAssertion::SyntheticsAssertionXPathTarget(
85                            Box::new(
86                                SyntheticsAssertionXPathTarget::new(
87                                    SyntheticsAssertionXPathOperator::VALIDATES_X_PATH,
88                                    SyntheticsAssertionType::BODY,
89                                ).target(
90                                    SyntheticsAssertionXPathTargetTarget::new()
91                                        .operator("contains".to_string())
92                                        .target_value(
93                                            SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
94                                                "0".to_string(),
95                                            ),
96                                        )
97                                        .x_path("target-xpath".to_string()),
98                                ),
99                            ),
100                        )
101                    ],
102                )
103                .config_variables(
104                    vec![
105                        SyntheticsConfigVariable::new("PROPERTY".to_string(), SyntheticsConfigVariableType::TEXT)
106                            .example("content-type".to_string())
107                            .pattern("content-type".to_string())
108                    ],
109                )
110                .request(
111                    SyntheticsTestRequest::new()
112                        .basic_auth(
113                            SyntheticsBasicAuth::SyntheticsBasicAuthOauthClient(
114                                Box::new(
115                                    SyntheticsBasicAuthOauthClient::new(
116                                        "https://datadog-token.com".to_string(),
117                                        "client-id".to_string(),
118                                        "client-secret".to_string(),
119                                        SyntheticsBasicAuthOauthTokenApiAuthentication::HEADER,
120                                        SyntheticsBasicAuthOauthClientType::OAUTH_CLIENT,
121                                    )
122                                        .audience("audience".to_string())
123                                        .resource("resource".to_string())
124                                        .scope("yoyo".to_string()),
125                                ),
126                            ),
127                        )
128                        .body_type(SyntheticsTestRequestBodyType::APPLICATION_OCTET_STREAM)
129                        .certificate(
130                            SyntheticsTestRequestCertificate::new()
131                                .cert(
132                                    SyntheticsTestRequestCertificateItem::new()
133                                        .content("cert-content".to_string())
134                                        .filename("cert-filename".to_string())
135                                        .updated_at("2020-10-16T09:23:24.857Z".to_string()),
136                                )
137                                .key(
138                                    SyntheticsTestRequestCertificateItem::new()
139                                        .content("key-content".to_string())
140                                        .filename("key-filename".to_string())
141                                        .updated_at("2020-10-16T09:23:24.857Z".to_string()),
142                                ),
143                        )
144                        .files(
145                            vec![
146                                SyntheticsTestRequestBodyFile::new()
147                                    .content("file content".to_string())
148                                    .name("file name".to_string())
149                                    .original_file_name("image.png".to_string())
150                                    .type_("file type".to_string())
151                            ],
152                        )
153                        .headers(BTreeMap::from([("unique".to_string(), "examplesynthetic".to_string())]))
154                        .method("GET".to_string())
155                        .persist_cookies(true)
156                        .proxy(
157                            SyntheticsTestRequestProxy::new(
158                                "https://datadoghq.com".to_string(),
159                            ).headers(BTreeMap::from([])),
160                        )
161                        .timeout(10.0 as f64)
162                        .url("https://datadoghq.com".to_string()),
163                ),
164            vec!["aws:us-east-2".to_string()],
165            "BDD test payload: synthetics_api_http_test_payload.json".to_string(),
166            "Example-Synthetic".to_string(),
167            SyntheticsTestOptions::new()
168                .accept_self_signed(false)
169                .allow_insecure(true)
170                .follow_redirects(true)
171                .http_version(SyntheticsTestOptionsHTTPVersion::HTTP2)
172                .min_failure_duration(10)
173                .min_location_failed(1)
174                .monitor_name("Example-Synthetic".to_string())
175                .monitor_priority(5)
176                .retry(SyntheticsTestOptionsRetry::new().count(3).interval(10.0 as f64))
177                .tick_every(60),
178            SyntheticsAPITestType::API,
179        )
180            .subtype(SyntheticsTestDetailsSubType::HTTP)
181            .tags(vec!["testing:api".to_string()]);
182    let configuration = datadog::Configuration::new();
183    let api = SyntheticsAPI::with_config(configuration);
184    let resp = api.create_synthetics_api_test(body).await;
185    if let Ok(value) = resp {
186        println!("{:#?}", value);
187    } else {
188        println!("{:#?}", resp.unwrap_err());
189    }
190}
Source

pub fn original_file_name(self, value: String) -> Self

Examples found in repository?
examples/v1_synthetics_CreateSyntheticsAPITest_1241981394.rs (line 149)
39async fn main() {
40    let body =
41        SyntheticsAPITest::new(
42            SyntheticsAPITestConfig::new()
43                .assertions(
44                    vec![
45                        SyntheticsAssertion::SyntheticsAssertionTarget(
46                            Box::new(
47                                SyntheticsAssertionTarget::new(
48                                    SyntheticsAssertionOperator::IS,
49                                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
50                                        "text/html".to_string(),
51                                    ),
52                                    SyntheticsAssertionType::HEADER,
53                                ).property("{{ PROPERTY }}".to_string()),
54                            ),
55                        ),
56                        SyntheticsAssertion::SyntheticsAssertionTarget(
57                            Box::new(
58                                SyntheticsAssertionTarget::new(
59                                    SyntheticsAssertionOperator::LESS_THAN,
60                                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueNumber(
61                                        2000.0 as f64,
62                                    ),
63                                    SyntheticsAssertionType::RESPONSE_TIME,
64                                ).timings_scope(SyntheticsAssertionTimingsScope::WITHOUT_DNS),
65                            ),
66                        ),
67                        SyntheticsAssertion::SyntheticsAssertionJSONPathTarget(
68                            Box::new(
69                                SyntheticsAssertionJSONPathTarget::new(
70                                    SyntheticsAssertionJSONPathOperator::VALIDATES_JSON_PATH,
71                                    SyntheticsAssertionType::BODY,
72                                ).target(
73                                    SyntheticsAssertionJSONPathTargetTarget::new()
74                                        .json_path("topKey".to_string())
75                                        .operator("isNot".to_string())
76                                        .target_value(
77                                            SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
78                                                "0".to_string(),
79                                            ),
80                                        ),
81                                ),
82                            ),
83                        ),
84                        SyntheticsAssertion::SyntheticsAssertionXPathTarget(
85                            Box::new(
86                                SyntheticsAssertionXPathTarget::new(
87                                    SyntheticsAssertionXPathOperator::VALIDATES_X_PATH,
88                                    SyntheticsAssertionType::BODY,
89                                ).target(
90                                    SyntheticsAssertionXPathTargetTarget::new()
91                                        .operator("contains".to_string())
92                                        .target_value(
93                                            SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
94                                                "0".to_string(),
95                                            ),
96                                        )
97                                        .x_path("target-xpath".to_string()),
98                                ),
99                            ),
100                        )
101                    ],
102                )
103                .config_variables(
104                    vec![
105                        SyntheticsConfigVariable::new("PROPERTY".to_string(), SyntheticsConfigVariableType::TEXT)
106                            .example("content-type".to_string())
107                            .pattern("content-type".to_string())
108                    ],
109                )
110                .request(
111                    SyntheticsTestRequest::new()
112                        .basic_auth(
113                            SyntheticsBasicAuth::SyntheticsBasicAuthOauthClient(
114                                Box::new(
115                                    SyntheticsBasicAuthOauthClient::new(
116                                        "https://datadog-token.com".to_string(),
117                                        "client-id".to_string(),
118                                        "client-secret".to_string(),
119                                        SyntheticsBasicAuthOauthTokenApiAuthentication::HEADER,
120                                        SyntheticsBasicAuthOauthClientType::OAUTH_CLIENT,
121                                    )
122                                        .audience("audience".to_string())
123                                        .resource("resource".to_string())
124                                        .scope("yoyo".to_string()),
125                                ),
126                            ),
127                        )
128                        .body_type(SyntheticsTestRequestBodyType::APPLICATION_OCTET_STREAM)
129                        .certificate(
130                            SyntheticsTestRequestCertificate::new()
131                                .cert(
132                                    SyntheticsTestRequestCertificateItem::new()
133                                        .content("cert-content".to_string())
134                                        .filename("cert-filename".to_string())
135                                        .updated_at("2020-10-16T09:23:24.857Z".to_string()),
136                                )
137                                .key(
138                                    SyntheticsTestRequestCertificateItem::new()
139                                        .content("key-content".to_string())
140                                        .filename("key-filename".to_string())
141                                        .updated_at("2020-10-16T09:23:24.857Z".to_string()),
142                                ),
143                        )
144                        .files(
145                            vec![
146                                SyntheticsTestRequestBodyFile::new()
147                                    .content("file content".to_string())
148                                    .name("file name".to_string())
149                                    .original_file_name("image.png".to_string())
150                                    .type_("file type".to_string())
151                            ],
152                        )
153                        .headers(BTreeMap::from([("unique".to_string(), "examplesynthetic".to_string())]))
154                        .method("GET".to_string())
155                        .persist_cookies(true)
156                        .proxy(
157                            SyntheticsTestRequestProxy::new(
158                                "https://datadoghq.com".to_string(),
159                            ).headers(BTreeMap::from([])),
160                        )
161                        .timeout(10.0 as f64)
162                        .url("https://datadoghq.com".to_string()),
163                ),
164            vec!["aws:us-east-2".to_string()],
165            "BDD test payload: synthetics_api_http_test_payload.json".to_string(),
166            "Example-Synthetic".to_string(),
167            SyntheticsTestOptions::new()
168                .accept_self_signed(false)
169                .allow_insecure(true)
170                .follow_redirects(true)
171                .http_version(SyntheticsTestOptionsHTTPVersion::HTTP2)
172                .min_failure_duration(10)
173                .min_location_failed(1)
174                .monitor_name("Example-Synthetic".to_string())
175                .monitor_priority(5)
176                .retry(SyntheticsTestOptionsRetry::new().count(3).interval(10.0 as f64))
177                .tick_every(60),
178            SyntheticsAPITestType::API,
179        )
180            .subtype(SyntheticsTestDetailsSubType::HTTP)
181            .tags(vec!["testing:api".to_string()]);
182    let configuration = datadog::Configuration::new();
183    let api = SyntheticsAPI::with_config(configuration);
184    let resp = api.create_synthetics_api_test(body).await;
185    if let Ok(value) = resp {
186        println!("{:#?}", value);
187    } else {
188        println!("{:#?}", resp.unwrap_err());
189    }
190}
Source

pub fn size(self, value: i64) -> Self

Source

pub fn type_(self, value: String) -> Self

Examples found in repository?
examples/v1_synthetics_CreateSyntheticsAPITest_1241981394.rs (line 150)
39async fn main() {
40    let body =
41        SyntheticsAPITest::new(
42            SyntheticsAPITestConfig::new()
43                .assertions(
44                    vec![
45                        SyntheticsAssertion::SyntheticsAssertionTarget(
46                            Box::new(
47                                SyntheticsAssertionTarget::new(
48                                    SyntheticsAssertionOperator::IS,
49                                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
50                                        "text/html".to_string(),
51                                    ),
52                                    SyntheticsAssertionType::HEADER,
53                                ).property("{{ PROPERTY }}".to_string()),
54                            ),
55                        ),
56                        SyntheticsAssertion::SyntheticsAssertionTarget(
57                            Box::new(
58                                SyntheticsAssertionTarget::new(
59                                    SyntheticsAssertionOperator::LESS_THAN,
60                                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueNumber(
61                                        2000.0 as f64,
62                                    ),
63                                    SyntheticsAssertionType::RESPONSE_TIME,
64                                ).timings_scope(SyntheticsAssertionTimingsScope::WITHOUT_DNS),
65                            ),
66                        ),
67                        SyntheticsAssertion::SyntheticsAssertionJSONPathTarget(
68                            Box::new(
69                                SyntheticsAssertionJSONPathTarget::new(
70                                    SyntheticsAssertionJSONPathOperator::VALIDATES_JSON_PATH,
71                                    SyntheticsAssertionType::BODY,
72                                ).target(
73                                    SyntheticsAssertionJSONPathTargetTarget::new()
74                                        .json_path("topKey".to_string())
75                                        .operator("isNot".to_string())
76                                        .target_value(
77                                            SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
78                                                "0".to_string(),
79                                            ),
80                                        ),
81                                ),
82                            ),
83                        ),
84                        SyntheticsAssertion::SyntheticsAssertionXPathTarget(
85                            Box::new(
86                                SyntheticsAssertionXPathTarget::new(
87                                    SyntheticsAssertionXPathOperator::VALIDATES_X_PATH,
88                                    SyntheticsAssertionType::BODY,
89                                ).target(
90                                    SyntheticsAssertionXPathTargetTarget::new()
91                                        .operator("contains".to_string())
92                                        .target_value(
93                                            SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueString(
94                                                "0".to_string(),
95                                            ),
96                                        )
97                                        .x_path("target-xpath".to_string()),
98                                ),
99                            ),
100                        )
101                    ],
102                )
103                .config_variables(
104                    vec![
105                        SyntheticsConfigVariable::new("PROPERTY".to_string(), SyntheticsConfigVariableType::TEXT)
106                            .example("content-type".to_string())
107                            .pattern("content-type".to_string())
108                    ],
109                )
110                .request(
111                    SyntheticsTestRequest::new()
112                        .basic_auth(
113                            SyntheticsBasicAuth::SyntheticsBasicAuthOauthClient(
114                                Box::new(
115                                    SyntheticsBasicAuthOauthClient::new(
116                                        "https://datadog-token.com".to_string(),
117                                        "client-id".to_string(),
118                                        "client-secret".to_string(),
119                                        SyntheticsBasicAuthOauthTokenApiAuthentication::HEADER,
120                                        SyntheticsBasicAuthOauthClientType::OAUTH_CLIENT,
121                                    )
122                                        .audience("audience".to_string())
123                                        .resource("resource".to_string())
124                                        .scope("yoyo".to_string()),
125                                ),
126                            ),
127                        )
128                        .body_type(SyntheticsTestRequestBodyType::APPLICATION_OCTET_STREAM)
129                        .certificate(
130                            SyntheticsTestRequestCertificate::new()
131                                .cert(
132                                    SyntheticsTestRequestCertificateItem::new()
133                                        .content("cert-content".to_string())
134                                        .filename("cert-filename".to_string())
135                                        .updated_at("2020-10-16T09:23:24.857Z".to_string()),
136                                )
137                                .key(
138                                    SyntheticsTestRequestCertificateItem::new()
139                                        .content("key-content".to_string())
140                                        .filename("key-filename".to_string())
141                                        .updated_at("2020-10-16T09:23:24.857Z".to_string()),
142                                ),
143                        )
144                        .files(
145                            vec![
146                                SyntheticsTestRequestBodyFile::new()
147                                    .content("file content".to_string())
148                                    .name("file name".to_string())
149                                    .original_file_name("image.png".to_string())
150                                    .type_("file type".to_string())
151                            ],
152                        )
153                        .headers(BTreeMap::from([("unique".to_string(), "examplesynthetic".to_string())]))
154                        .method("GET".to_string())
155                        .persist_cookies(true)
156                        .proxy(
157                            SyntheticsTestRequestProxy::new(
158                                "https://datadoghq.com".to_string(),
159                            ).headers(BTreeMap::from([])),
160                        )
161                        .timeout(10.0 as f64)
162                        .url("https://datadoghq.com".to_string()),
163                ),
164            vec!["aws:us-east-2".to_string()],
165            "BDD test payload: synthetics_api_http_test_payload.json".to_string(),
166            "Example-Synthetic".to_string(),
167            SyntheticsTestOptions::new()
168                .accept_self_signed(false)
169                .allow_insecure(true)
170                .follow_redirects(true)
171                .http_version(SyntheticsTestOptionsHTTPVersion::HTTP2)
172                .min_failure_duration(10)
173                .min_location_failed(1)
174                .monitor_name("Example-Synthetic".to_string())
175                .monitor_priority(5)
176                .retry(SyntheticsTestOptionsRetry::new().count(3).interval(10.0 as f64))
177                .tick_every(60),
178            SyntheticsAPITestType::API,
179        )
180            .subtype(SyntheticsTestDetailsSubType::HTTP)
181            .tags(vec!["testing:api".to_string()]);
182    let configuration = datadog::Configuration::new();
183    let api = SyntheticsAPI::with_config(configuration);
184    let resp = api.create_synthetics_api_test(body).await;
185    if let Ok(value) = resp {
186        println!("{:#?}", value);
187    } else {
188        println!("{:#?}", resp.unwrap_err());
189    }
190}
Source

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

Trait Implementations§

Source§

impl Clone for SyntheticsTestRequestBodyFile

Source§

fn clone(&self) -> SyntheticsTestRequestBodyFile

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for SyntheticsTestRequestBodyFile

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for SyntheticsTestRequestBodyFile

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl<'de> Deserialize<'de> for SyntheticsTestRequestBodyFile

Source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
Source§

impl PartialEq for SyntheticsTestRequestBodyFile

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl Serialize for SyntheticsTestRequestBodyFile

Source§

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

Serialize this value into the given Serde serializer. Read more
Source§

impl StructuralPartialEq for SyntheticsTestRequestBodyFile

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

Source§

impl<T> ErasedDestructor for T
where T: 'static,