From 5b267589edc4d36f8acbe319c1c83b35a5b53fb7 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Thu, 9 Apr 2026 11:56:02 +0000 Subject: [PATCH] Regenerate client from commit fe29175 of spec repo --- .generator/schemas/v2/openapi.yaml | 372 ++++++++++++++++++ ...ization_GetFlakyTestsManagementPolicies.rs | 30 ++ ...tion_UpdateFlakyTestsManagementPolicies.rs | 88 +++++ src/datadog/configuration.rs | 5 + src/datadogV2/api/api_test_optimization.rs | 358 +++++++++++++++++ src/datadogV2/model/mod.rs | 42 ++ ...ests_management_policies_attempt_to_fix.rs | 106 +++++ ...ky_tests_management_policies_attributes.rs | 173 ++++++++ ...s_management_policies_auto_disable_rule.rs | 154 ++++++++ ...anagement_policies_auto_quarantine_rule.rs | 124 ++++++ ...y_tests_management_policies_branch_rule.rs | 158 ++++++++ ...on_flaky_tests_management_policies_data.rs | 159 ++++++++ ...laky_tests_management_policies_disabled.rs | 170 ++++++++ ...ent_policies_disabled_failure_rate_rule.rs | 190 +++++++++ ...sts_management_policies_disabled_status.rs | 51 +++ ...y_tests_management_policies_get_request.rs | 94 +++++ ...agement_policies_get_request_attributes.rs | 98 +++++ ...ts_management_policies_get_request_data.rs | 117 ++++++ ...y_tests_management_policies_quarantined.rs | 170 ++++++++ ..._policies_quarantined_failure_rate_rule.rs | 163 ++++++++ ...laky_tests_management_policies_response.rs | 110 ++++++ ...on_flaky_tests_management_policies_type.rs | 52 +++ ...ests_management_policies_update_request.rs | 96 +++++ ...ment_policies_update_request_attributes.rs | 168 ++++++++ ...management_policies_update_request_data.rs | 116 ++++++ ...s_management_policies_request_data_type.rs | 52 +++ ...s_management_policies_request_data_type.rs | 52 +++ .../features/v2/test_optimization.feature | 64 +++ tests/scenarios/features/v2/undo.json | 12 + tests/scenarios/function_mappings.rs | 64 +++ 30 files changed, 3608 insertions(+) create mode 100644 examples/v2_test-optimization_GetFlakyTestsManagementPolicies.rs create mode 100644 examples/v2_test-optimization_UpdateFlakyTestsManagementPolicies.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_attempt_to_fix.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_attributes.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_auto_disable_rule.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_auto_quarantine_rule.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_branch_rule.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_data.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled_failure_rate_rule.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled_status.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request_attributes.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request_data.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_quarantined.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_quarantined_failure_rate_rule.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_response.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_type.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request_attributes.rs create mode 100644 src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request_data.rs create mode 100644 src/datadogV2/model/model_test_optimization_get_flaky_tests_management_policies_request_data_type.rs create mode 100644 src/datadogV2/model/model_test_optimization_update_flaky_tests_management_policies_request_data_type.rs diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index d235bdcd3d..1b3abec107 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -70243,6 +70243,286 @@ components: type: string x-enum-varnames: - TEST_OPTIMIZATION_DELETE_SERVICE_SETTINGS_REQUEST + TestOptimizationFlakyTestsManagementPoliciesAttemptToFix: + description: Configuration for the attempt-to-fix Flaky Tests Management policy. + properties: + retries: + description: Number of retries when attempting to fix a flaky test. Must be greater than 0. + example: 3 + format: int64 + type: integer + type: object + TestOptimizationFlakyTestsManagementPoliciesAttributes: + description: Attributes of the Flaky Tests Management policies for a repository. + properties: + attempt_to_fix: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesAttemptToFix" + disabled: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesDisabled" + quarantined: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesQuarantined" + repository_id: + description: The repository identifier. + example: github.com/datadog/shopist + type: string + type: object + TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule: + description: Automatic disable triggering rule based on a time window and test status. + properties: + enabled: + description: Whether this auto-disable rule is enabled. + example: false + type: boolean + status: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesDisabledStatus" + window_seconds: + description: Time window in seconds over which flakiness is evaluated. Must be greater than 0. + example: 3600 + format: int64 + type: integer + type: object + TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule: + description: Automatic quarantine triggering rule based on a time window. + properties: + enabled: + description: Whether this auto-quarantine rule is enabled. + example: true + type: boolean + window_seconds: + description: Time window in seconds over which flakiness is evaluated. Must be greater than 0. + example: 3600 + format: int64 + type: integer + type: object + TestOptimizationFlakyTestsManagementPoliciesBranchRule: + description: Branch filtering rule for a Flaky Tests Management policy. + properties: + branches: + description: List of branches to which the policy applies. + example: + - main + items: + description: A branch name. + type: string + type: array + enabled: + description: Whether this branch rule is enabled. + example: true + type: boolean + excluded_branches: + description: List of branches excluded from the policy. + example: [] + items: + description: A branch name. + type: string + type: array + excluded_test_services: + description: List of test services excluded from the policy. + example: [] + items: + description: A test service name. + type: string + type: array + type: object + TestOptimizationFlakyTestsManagementPoliciesData: + description: Data object for Flaky Tests Management policies response. + properties: + attributes: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesAttributes" + id: + description: The repository identifier used as the resource ID. + example: github.com/datadog/shopist + type: string + type: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesType" + type: object + TestOptimizationFlakyTestsManagementPoliciesDisabled: + description: Configuration for the disabled Flaky Tests Management policy. + properties: + auto_disable_rule: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule" + branch_rule: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesBranchRule" + enabled: + description: Whether the disabled policy is enabled. + example: false + type: boolean + failure_rate_rule: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule" + type: object + TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule: + description: Failure-rate-based rule for the disabled policy. + properties: + branches: + description: List of branches to which this rule applies. + example: [] + items: + description: A branch name. + type: string + type: array + enabled: + description: Whether this failure rate rule is enabled. + example: false + type: boolean + min_runs: + description: Minimum number of runs required before the rule is evaluated. Must be greater than or equal to 0. + example: 10 + format: int64 + type: integer + status: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesDisabledStatus" + threshold: + description: Failure rate threshold (0.0–1.0) above which the rule triggers. + example: 0.5 + format: double + type: number + type: object + TestOptimizationFlakyTestsManagementPoliciesDisabledStatus: + description: |- + Test status that the disable policy applies to. + Must be either `active` or `quarantined`. + enum: + - active + - quarantined + example: active + type: string + x-enum-varnames: + - ACTIVE + - QUARANTINED + TestOptimizationFlakyTestsManagementPoliciesGetRequest: + description: Request object for getting Flaky Tests Management policies. + properties: + data: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesGetRequestData" + required: + - data + type: object + TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes: + description: Attributes for requesting Flaky Tests Management policies. + properties: + repository_id: + description: The repository identifier. + example: github.com/datadog/shopist + minLength: 1 + type: string + required: + - repository_id + type: object + TestOptimizationFlakyTestsManagementPoliciesGetRequestData: + description: Data object for get Flaky Tests Management policies request. + properties: + attributes: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes" + type: + $ref: "#/components/schemas/TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType" + required: + - type + - attributes + type: object + TestOptimizationFlakyTestsManagementPoliciesQuarantined: + description: Configuration for the quarantined Flaky Tests Management policy. + properties: + auto_quarantine_rule: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule" + branch_rule: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesBranchRule" + enabled: + description: Whether the quarantined policy is enabled. + example: true + type: boolean + failure_rate_rule: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule" + type: object + TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule: + description: Failure-rate-based rule for the quarantined policy. + properties: + branches: + description: List of branches to which this rule applies. + example: + - main + items: + description: A branch name. + type: string + type: array + enabled: + description: Whether this failure rate rule is enabled. + example: true + type: boolean + min_runs: + description: Minimum number of runs required before the rule is evaluated. Must be greater than or equal to 0. + example: 10 + format: int64 + type: integer + threshold: + description: Failure rate threshold (0.0–1.0) above which the rule triggers. + example: 0.5 + format: double + type: number + type: object + TestOptimizationFlakyTestsManagementPoliciesResponse: + description: Response object containing Flaky Tests Management policies for a repository. + properties: + data: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesData" + type: object + TestOptimizationFlakyTestsManagementPoliciesType: + description: |- + JSON:API type for Flaky Tests Management policies response. + The value must always be `test_optimization_flaky_tests_management_policies`. + enum: + - test_optimization_flaky_tests_management_policies + example: test_optimization_flaky_tests_management_policies + type: string + x-enum-varnames: + - TEST_OPTIMIZATION_FLAKY_TESTS_MANAGEMENT_POLICIES + TestOptimizationFlakyTestsManagementPoliciesUpdateRequest: + description: Request object for updating Flaky Tests Management policies. + properties: + data: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData" + required: + - data + type: object + TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes: + description: |- + Attributes for updating Flaky Tests Management policies. + Only provided policy blocks are updated; omitted blocks are left unchanged. + properties: + attempt_to_fix: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesAttemptToFix" + disabled: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesDisabled" + quarantined: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesQuarantined" + repository_id: + description: The repository identifier. + example: github.com/datadog/shopist + minLength: 1 + type: string + required: + - repository_id + type: object + TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData: + description: Data object for update Flaky Tests Management policies request. + properties: + attributes: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes" + type: + $ref: "#/components/schemas/TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType" + required: + - type + - attributes + type: object + TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType: + description: |- + JSON:API type for get Flaky Tests Management policies request. + The value must always be `test_optimization_get_flaky_tests_management_policies_request`. + enum: + - test_optimization_get_flaky_tests_management_policies_request + example: test_optimization_get_flaky_tests_management_policies_request + type: string + x-enum-varnames: + - TEST_OPTIMIZATION_GET_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST TestOptimizationGetServiceSettingsRequest: description: Request object for getting Test Optimization service settings. properties: @@ -70361,6 +70641,16 @@ components: type: string x-enum-varnames: - TEST_OPTIMIZATION_SERVICE_SETTINGS + TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType: + description: |- + JSON:API type for update Flaky Tests Management policies request. + The value must always be `test_optimization_update_flaky_tests_management_policies_request`. + enum: + - test_optimization_update_flaky_tests_management_policies_request + example: test_optimization_update_flaky_tests_management_policies_request + type: string + x-enum-varnames: + - TEST_OPTIMIZATION_UPDATE_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST TestOptimizationUpdateServiceSettingsRequest: description: Request object for updating Test Optimization service settings. properties: @@ -81119,6 +81409,88 @@ paths: operator: OR permissions: - ci_visibility_read + /api/v2/ci/test-optimization/settings/policies: + patch: + description: |- + Partially update Flaky Tests Management repository-level policies for the given repository. + Only provided policy blocks are updated; omitted blocks are left unchanged. + operationId: UpdateFlakyTestsManagementPolicies + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesUpdateRequest" + required: true + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesResponse" + description: OK + "400": + $ref: "#/components/responses/BadRequestResponse" + "403": + $ref: "#/components/responses/NotAuthorizedResponse" + "404": + $ref: "#/components/responses/NotFoundResponse" + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - test_optimization_settings_write + summary: Update Flaky Tests Management policies + tags: ["Test Optimization"] + x-codegen-request-body-name: body + x-permission: + operator: OR + permissions: + - test_optimization_settings_write + x-unstable: |- + **Note**: This endpoint is in preview and may be subject to change. + If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/). + post: + description: |- + Retrieve Flaky Tests Management repository-level policies for the given repository. + operationId: GetFlakyTestsManagementPolicies + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesGetRequest" + required: true + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/TestOptimizationFlakyTestsManagementPoliciesResponse" + description: OK + "400": + $ref: "#/components/responses/BadRequestResponse" + "403": + $ref: "#/components/responses/NotAuthorizedResponse" + "404": + $ref: "#/components/responses/NotFoundResponse" + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - test_optimization_read + summary: Get Flaky Tests Management policies + tags: ["Test Optimization"] + x-codegen-request-body-name: body + x-permission: + operator: OR + permissions: + - test_optimization_read + x-unstable: |- + **Note**: This endpoint is in preview and may be subject to change. + If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/). /api/v2/ci/test-optimization/settings/service: delete: description: |- diff --git a/examples/v2_test-optimization_GetFlakyTestsManagementPolicies.rs b/examples/v2_test-optimization_GetFlakyTestsManagementPolicies.rs new file mode 100644 index 0000000000..d6b115db80 --- /dev/null +++ b/examples/v2_test-optimization_GetFlakyTestsManagementPolicies.rs @@ -0,0 +1,30 @@ +// Get Flaky Tests Management policies returns "OK" response +use datadog_api_client::datadog; +use datadog_api_client::datadogV2::api_test_optimization::TestOptimizationAPI; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesGetRequest; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesGetRequestData; +use datadog_api_client::datadogV2::model::TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType; + +#[tokio::main] +async fn main() { + let body = + TestOptimizationFlakyTestsManagementPoliciesGetRequest::new( + TestOptimizationFlakyTestsManagementPoliciesGetRequestData::new( + TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes::new( + "github.com/datadog/shopist".to_string(), + ), + TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType + ::TEST_OPTIMIZATION_GET_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST, + ), + ); + let mut configuration = datadog::Configuration::new(); + configuration.set_unstable_operation_enabled("v2.GetFlakyTestsManagementPolicies", true); + let api = TestOptimizationAPI::with_config(configuration); + let resp = api.get_flaky_tests_management_policies(body).await; + if let Ok(value) = resp { + println!("{:#?}", value); + } else { + println!("{:#?}", resp.unwrap_err()); + } +} diff --git a/examples/v2_test-optimization_UpdateFlakyTestsManagementPolicies.rs b/examples/v2_test-optimization_UpdateFlakyTestsManagementPolicies.rs new file mode 100644 index 0000000000..6f30155dbb --- /dev/null +++ b/examples/v2_test-optimization_UpdateFlakyTestsManagementPolicies.rs @@ -0,0 +1,88 @@ +// Update Flaky Tests Management policies returns "OK" response +use datadog_api_client::datadog; +use datadog_api_client::datadogV2::api_test_optimization::TestOptimizationAPI; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesAttemptToFix; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesBranchRule; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabled; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabledStatus; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesQuarantined; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesUpdateRequest; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes; +use datadog_api_client::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData; +use datadog_api_client::datadogV2::model::TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType; + +#[tokio::main] +async fn main() { + let body = + TestOptimizationFlakyTestsManagementPoliciesUpdateRequest::new( + TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData::new( + TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes::new( + "github.com/datadog/shopist".to_string(), + ) + .attempt_to_fix(TestOptimizationFlakyTestsManagementPoliciesAttemptToFix::new().retries(3)) + .disabled( + TestOptimizationFlakyTestsManagementPoliciesDisabled::new() + .auto_disable_rule( + TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule::new() + .enabled(false) + .status(TestOptimizationFlakyTestsManagementPoliciesDisabledStatus::ACTIVE) + .window_seconds(3600), + ) + .branch_rule( + TestOptimizationFlakyTestsManagementPoliciesBranchRule::new() + .branches(vec!["main".to_string()]) + .enabled(true) + .excluded_branches(vec![]) + .excluded_test_services(vec![]), + ) + .enabled(false) + .failure_rate_rule( + TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule::new() + .branches(vec![]) + .enabled(false) + .min_runs(10) + .status(TestOptimizationFlakyTestsManagementPoliciesDisabledStatus::ACTIVE) + .threshold(0.5 as f64), + ), + ) + .quarantined( + TestOptimizationFlakyTestsManagementPoliciesQuarantined::new() + .auto_quarantine_rule( + TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule::new() + .enabled(true) + .window_seconds(3600), + ) + .branch_rule( + TestOptimizationFlakyTestsManagementPoliciesBranchRule::new() + .branches(vec!["main".to_string()]) + .enabled(true) + .excluded_branches(vec![]) + .excluded_test_services(vec![]), + ) + .enabled(true) + .failure_rate_rule( + TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule::new() + .branches(vec!["main".to_string()]) + .enabled(true) + .min_runs(10) + .threshold(0.5 as f64), + ), + ), + TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType + ::TEST_OPTIMIZATION_UPDATE_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST, + ), + ); + let mut configuration = datadog::Configuration::new(); + configuration.set_unstable_operation_enabled("v2.UpdateFlakyTestsManagementPolicies", true); + let api = TestOptimizationAPI::with_config(configuration); + let resp = api.update_flaky_tests_management_policies(body).await; + if let Ok(value) = resp { + println!("{:#?}", value); + } else { + println!("{:#?}", resp.unwrap_err()); + } +} diff --git a/src/datadog/configuration.rs b/src/datadog/configuration.rs index eb6ed44853..21300c57a5 100644 --- a/src/datadog/configuration.rs +++ b/src/datadog/configuration.rs @@ -158,12 +158,17 @@ impl Default for Configuration { "v2.delete_test_optimization_service_settings".to_owned(), false, ), + ("v2.get_flaky_tests_management_policies".to_owned(), false), ( "v2.get_test_optimization_service_settings".to_owned(), false, ), ("v2.search_flaky_tests".to_owned(), false), ("v2.update_flaky_tests".to_owned(), false), + ( + "v2.update_flaky_tests_management_policies".to_owned(), + false, + ), ( "v2.update_test_optimization_service_settings".to_owned(), false, diff --git a/src/datadogV2/api/api_test_optimization.rs b/src/datadogV2/api/api_test_optimization.rs index c76c8e7e85..40c224adda 100644 --- a/src/datadogV2/api/api_test_optimization.rs +++ b/src/datadogV2/api/api_test_optimization.rs @@ -35,6 +35,14 @@ pub enum DeleteTestOptimizationServiceSettingsError { UnknownValue(serde_json::Value), } +/// GetFlakyTestsManagementPoliciesError is a struct for typed errors of method [`TestOptimizationAPI::get_flaky_tests_management_policies`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum GetFlakyTestsManagementPoliciesError { + APIErrorResponse(crate::datadogV2::model::APIErrorResponse), + UnknownValue(serde_json::Value), +} + /// GetTestOptimizationServiceSettingsError is a struct for typed errors of method [`TestOptimizationAPI::get_test_optimization_service_settings`] #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(untagged)] @@ -59,6 +67,14 @@ pub enum UpdateFlakyTestsError { UnknownValue(serde_json::Value), } +/// UpdateFlakyTestsManagementPoliciesError is a struct for typed errors of method [`TestOptimizationAPI::update_flaky_tests_management_policies`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum UpdateFlakyTestsManagementPoliciesError { + APIErrorResponse(crate::datadogV2::model::APIErrorResponse), + UnknownValue(serde_json::Value), +} + /// UpdateTestOptimizationServiceSettingsError is a struct for typed errors of method [`TestOptimizationAPI::update_test_optimization_service_settings`] #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(untagged)] @@ -290,6 +306,176 @@ impl TestOptimizationAPI { } } + /// Retrieve Flaky Tests Management repository-level policies for the given repository. + pub async fn get_flaky_tests_management_policies( + &self, + body: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesGetRequest, + ) -> Result< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesResponse, + datadog::Error, + > { + match self + .get_flaky_tests_management_policies_with_http_info(body) + .await + { + Ok(response_content) => { + if let Some(e) = response_content.entity { + Ok(e) + } else { + Err(datadog::Error::Serde(serde::de::Error::custom( + "response content was None", + ))) + } + } + Err(err) => Err(err), + } + } + + /// Retrieve Flaky Tests Management repository-level policies for the given repository. + pub async fn get_flaky_tests_management_policies_with_http_info( + &self, + body: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesGetRequest, + ) -> Result< + datadog::ResponseContent< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesResponse, + >, + datadog::Error, + > { + let local_configuration = &self.config; + let operation_id = "v2.get_flaky_tests_management_policies"; + if local_configuration.is_unstable_operation_enabled(operation_id) { + warn!("Using unstable operation {operation_id}"); + } else { + let local_error = datadog::UnstableOperationDisabledError { + msg: "Operation 'v2.get_flaky_tests_management_policies' is not enabled" + .to_string(), + }; + return Err(datadog::Error::UnstableOperationDisabledError(local_error)); + } + + let local_client = &self.client; + + let local_uri_str = format!( + "{}/api/v2/ci/test-optimization/settings/policies", + local_configuration.get_operation_host(operation_id) + ); + let mut local_req_builder = + local_client.request(reqwest::Method::POST, local_uri_str.as_str()); + + // build headers + let mut headers = HeaderMap::new(); + headers.insert("Content-Type", HeaderValue::from_static("application/json")); + headers.insert("Accept", HeaderValue::from_static("application/json")); + + // build user agent + match HeaderValue::from_str(local_configuration.user_agent.as_str()) { + Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent), + Err(e) => { + log::warn!("Failed to parse user agent header: {e}, falling back to default"); + headers.insert( + reqwest::header::USER_AGENT, + HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()), + ) + } + }; + + // build auth + if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") { + headers.insert( + "DD-API-KEY", + HeaderValue::from_str(local_key.key.as_str()) + .expect("failed to parse DD-API-KEY header"), + ); + }; + if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") { + headers.insert( + "DD-APPLICATION-KEY", + HeaderValue::from_str(local_key.key.as_str()) + .expect("failed to parse DD-APPLICATION-KEY header"), + ); + }; + + // build body parameters + let output = Vec::new(); + let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter); + if body.serialize(&mut ser).is_ok() { + if let Some(content_encoding) = headers.get("Content-Encoding") { + match content_encoding.to_str().unwrap_or_default() { + "gzip" => { + let mut enc = GzEncoder::new(Vec::new(), Compression::default()); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + "deflate" => { + let mut enc = ZlibEncoder::new(Vec::new(), Compression::default()); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + #[cfg(feature = "zstd")] + "zstd1" => { + let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap(); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + _ => { + local_req_builder = local_req_builder.body(ser.into_inner()); + } + } + } else { + local_req_builder = local_req_builder.body(ser.into_inner()); + } + } + + local_req_builder = local_req_builder.headers(headers); + let local_req = local_req_builder.build()?; + log::debug!("request content: {:?}", local_req.body()); + let local_resp = local_client.execute(local_req).await?; + + let local_status = local_resp.status(); + let local_content = local_resp.text().await?; + log::debug!("response content: {}", local_content); + + if !local_status.is_client_error() && !local_status.is_server_error() { + match serde_json::from_str::< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesResponse, + >(&local_content) + { + Ok(e) => { + return Ok(datadog::ResponseContent { + status: local_status, + content: local_content, + entity: Some(e), + }) + } + Err(e) => return Err(datadog::Error::Serde(e)), + }; + } else { + let local_entity: Option = + serde_json::from_str(&local_content).ok(); + let local_error = datadog::ResponseContent { + status: local_status, + content: local_content, + entity: local_entity, + }; + Err(datadog::Error::ResponseError(local_error)) + } + } + /// Retrieve Test Optimization settings for a specific service identified by repository, service name, and environment. pub async fn get_test_optimization_service_settings( &self, @@ -860,6 +1046,178 @@ impl TestOptimizationAPI { } } + /// Partially update Flaky Tests Management repository-level policies for the given repository. + /// Only provided policy blocks are updated; omitted blocks are left unchanged. + pub async fn update_flaky_tests_management_policies( + &self, + body: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesUpdateRequest, + ) -> Result< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesResponse, + datadog::Error, + > { + match self + .update_flaky_tests_management_policies_with_http_info(body) + .await + { + Ok(response_content) => { + if let Some(e) = response_content.entity { + Ok(e) + } else { + Err(datadog::Error::Serde(serde::de::Error::custom( + "response content was None", + ))) + } + } + Err(err) => Err(err), + } + } + + /// Partially update Flaky Tests Management repository-level policies for the given repository. + /// Only provided policy blocks are updated; omitted blocks are left unchanged. + pub async fn update_flaky_tests_management_policies_with_http_info( + &self, + body: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesUpdateRequest, + ) -> Result< + datadog::ResponseContent< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesResponse, + >, + datadog::Error, + > { + let local_configuration = &self.config; + let operation_id = "v2.update_flaky_tests_management_policies"; + if local_configuration.is_unstable_operation_enabled(operation_id) { + warn!("Using unstable operation {operation_id}"); + } else { + let local_error = datadog::UnstableOperationDisabledError { + msg: "Operation 'v2.update_flaky_tests_management_policies' is not enabled" + .to_string(), + }; + return Err(datadog::Error::UnstableOperationDisabledError(local_error)); + } + + let local_client = &self.client; + + let local_uri_str = format!( + "{}/api/v2/ci/test-optimization/settings/policies", + local_configuration.get_operation_host(operation_id) + ); + let mut local_req_builder = + local_client.request(reqwest::Method::PATCH, local_uri_str.as_str()); + + // build headers + let mut headers = HeaderMap::new(); + headers.insert("Content-Type", HeaderValue::from_static("application/json")); + headers.insert("Accept", HeaderValue::from_static("application/json")); + + // build user agent + match HeaderValue::from_str(local_configuration.user_agent.as_str()) { + Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent), + Err(e) => { + log::warn!("Failed to parse user agent header: {e}, falling back to default"); + headers.insert( + reqwest::header::USER_AGENT, + HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()), + ) + } + }; + + // build auth + if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") { + headers.insert( + "DD-API-KEY", + HeaderValue::from_str(local_key.key.as_str()) + .expect("failed to parse DD-API-KEY header"), + ); + }; + if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") { + headers.insert( + "DD-APPLICATION-KEY", + HeaderValue::from_str(local_key.key.as_str()) + .expect("failed to parse DD-APPLICATION-KEY header"), + ); + }; + + // build body parameters + let output = Vec::new(); + let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter); + if body.serialize(&mut ser).is_ok() { + if let Some(content_encoding) = headers.get("Content-Encoding") { + match content_encoding.to_str().unwrap_or_default() { + "gzip" => { + let mut enc = GzEncoder::new(Vec::new(), Compression::default()); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + "deflate" => { + let mut enc = ZlibEncoder::new(Vec::new(), Compression::default()); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + #[cfg(feature = "zstd")] + "zstd1" => { + let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap(); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + _ => { + local_req_builder = local_req_builder.body(ser.into_inner()); + } + } + } else { + local_req_builder = local_req_builder.body(ser.into_inner()); + } + } + + local_req_builder = local_req_builder.headers(headers); + let local_req = local_req_builder.build()?; + log::debug!("request content: {:?}", local_req.body()); + let local_resp = local_client.execute(local_req).await?; + + let local_status = local_resp.status(); + let local_content = local_resp.text().await?; + log::debug!("response content: {}", local_content); + + if !local_status.is_client_error() && !local_status.is_server_error() { + match serde_json::from_str::< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesResponse, + >(&local_content) + { + Ok(e) => { + return Ok(datadog::ResponseContent { + status: local_status, + content: local_content, + entity: Some(e), + }) + } + Err(e) => return Err(datadog::Error::Serde(e)), + }; + } else { + let local_entity: Option = + serde_json::from_str(&local_content).ok(); + let local_error = datadog::ResponseContent { + status: local_status, + content: local_content, + entity: local_entity, + }; + Err(datadog::Error::ResponseError(local_error)) + } + } + /// Partially update Test Optimization settings for a specific service identified by repository, service name, and environment. /// Only provided fields are updated; null or omitted fields are left unchanged. pub async fn update_test_optimization_service_settings( diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 4a7f746e34..735a7a85c9 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -1936,6 +1936,48 @@ pub mod model_ci_app_pipeline_events_request; pub use self::model_ci_app_pipeline_events_request::CIAppPipelineEventsRequest; pub mod model_ci_app_query_page_options; pub use self::model_ci_app_query_page_options::CIAppQueryPageOptions; +pub mod model_test_optimization_flaky_tests_management_policies_update_request; +pub use self::model_test_optimization_flaky_tests_management_policies_update_request::TestOptimizationFlakyTestsManagementPoliciesUpdateRequest; +pub mod model_test_optimization_flaky_tests_management_policies_update_request_data; +pub use self::model_test_optimization_flaky_tests_management_policies_update_request_data::TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData; +pub mod model_test_optimization_flaky_tests_management_policies_update_request_attributes; +pub use self::model_test_optimization_flaky_tests_management_policies_update_request_attributes::TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes; +pub mod model_test_optimization_flaky_tests_management_policies_attempt_to_fix; +pub use self::model_test_optimization_flaky_tests_management_policies_attempt_to_fix::TestOptimizationFlakyTestsManagementPoliciesAttemptToFix; +pub mod model_test_optimization_flaky_tests_management_policies_disabled; +pub use self::model_test_optimization_flaky_tests_management_policies_disabled::TestOptimizationFlakyTestsManagementPoliciesDisabled; +pub mod model_test_optimization_flaky_tests_management_policies_auto_disable_rule; +pub use self::model_test_optimization_flaky_tests_management_policies_auto_disable_rule::TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule; +pub mod model_test_optimization_flaky_tests_management_policies_disabled_status; +pub use self::model_test_optimization_flaky_tests_management_policies_disabled_status::TestOptimizationFlakyTestsManagementPoliciesDisabledStatus; +pub mod model_test_optimization_flaky_tests_management_policies_branch_rule; +pub use self::model_test_optimization_flaky_tests_management_policies_branch_rule::TestOptimizationFlakyTestsManagementPoliciesBranchRule; +pub mod model_test_optimization_flaky_tests_management_policies_disabled_failure_rate_rule; +pub use self::model_test_optimization_flaky_tests_management_policies_disabled_failure_rate_rule::TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule; +pub mod model_test_optimization_flaky_tests_management_policies_quarantined; +pub use self::model_test_optimization_flaky_tests_management_policies_quarantined::TestOptimizationFlakyTestsManagementPoliciesQuarantined; +pub mod model_test_optimization_flaky_tests_management_policies_auto_quarantine_rule; +pub use self::model_test_optimization_flaky_tests_management_policies_auto_quarantine_rule::TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule; +pub mod model_test_optimization_flaky_tests_management_policies_quarantined_failure_rate_rule; +pub use self::model_test_optimization_flaky_tests_management_policies_quarantined_failure_rate_rule::TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule; +pub mod model_test_optimization_update_flaky_tests_management_policies_request_data_type; +pub use self::model_test_optimization_update_flaky_tests_management_policies_request_data_type::TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType; +pub mod model_test_optimization_flaky_tests_management_policies_response; +pub use self::model_test_optimization_flaky_tests_management_policies_response::TestOptimizationFlakyTestsManagementPoliciesResponse; +pub mod model_test_optimization_flaky_tests_management_policies_data; +pub use self::model_test_optimization_flaky_tests_management_policies_data::TestOptimizationFlakyTestsManagementPoliciesData; +pub mod model_test_optimization_flaky_tests_management_policies_attributes; +pub use self::model_test_optimization_flaky_tests_management_policies_attributes::TestOptimizationFlakyTestsManagementPoliciesAttributes; +pub mod model_test_optimization_flaky_tests_management_policies_type; +pub use self::model_test_optimization_flaky_tests_management_policies_type::TestOptimizationFlakyTestsManagementPoliciesType; +pub mod model_test_optimization_flaky_tests_management_policies_get_request; +pub use self::model_test_optimization_flaky_tests_management_policies_get_request::TestOptimizationFlakyTestsManagementPoliciesGetRequest; +pub mod model_test_optimization_flaky_tests_management_policies_get_request_data; +pub use self::model_test_optimization_flaky_tests_management_policies_get_request_data::TestOptimizationFlakyTestsManagementPoliciesGetRequestData; +pub mod model_test_optimization_flaky_tests_management_policies_get_request_attributes; +pub use self::model_test_optimization_flaky_tests_management_policies_get_request_attributes::TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes; +pub mod model_test_optimization_get_flaky_tests_management_policies_request_data_type; +pub use self::model_test_optimization_get_flaky_tests_management_policies_request_data_type::TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType; pub mod model_test_optimization_delete_service_settings_request; pub use self::model_test_optimization_delete_service_settings_request::TestOptimizationDeleteServiceSettingsRequest; pub mod model_test_optimization_delete_service_settings_request_data; diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_attempt_to_fix.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_attempt_to_fix.rs new file mode 100644 index 0000000000..29bfacad9c --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_attempt_to_fix.rs @@ -0,0 +1,106 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Configuration for the attempt-to-fix Flaky Tests Management policy. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesAttemptToFix { + /// Number of retries when attempting to fix a flaky test. Must be greater than 0. + #[serde(rename = "retries")] + pub retries: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesAttemptToFix { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesAttemptToFix { + TestOptimizationFlakyTestsManagementPoliciesAttemptToFix { + retries: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn retries(mut self, value: i64) -> Self { + self.retries = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesAttemptToFix { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesAttemptToFix { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesAttemptToFixVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesAttemptToFixVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesAttemptToFix; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut retries: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "retries" => { + if v.is_null() { + continue; + } + retries = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = TestOptimizationFlakyTestsManagementPoliciesAttemptToFix { + retries, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(TestOptimizationFlakyTestsManagementPoliciesAttemptToFixVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_attributes.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_attributes.rs new file mode 100644 index 0000000000..c31fc7c3e4 --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_attributes.rs @@ -0,0 +1,173 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Attributes of the Flaky Tests Management policies for a repository. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesAttributes { + /// Configuration for the attempt-to-fix Flaky Tests Management policy. + #[serde(rename = "attempt_to_fix")] + pub attempt_to_fix: + Option, + /// Configuration for the disabled Flaky Tests Management policy. + #[serde(rename = "disabled")] + pub disabled: + Option, + /// Configuration for the quarantined Flaky Tests Management policy. + #[serde(rename = "quarantined")] + pub quarantined: + Option, + /// The repository identifier. + #[serde(rename = "repository_id")] + pub repository_id: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesAttributes { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesAttributes { + TestOptimizationFlakyTestsManagementPoliciesAttributes { + attempt_to_fix: None, + disabled: None, + quarantined: None, + repository_id: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn attempt_to_fix( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesAttemptToFix, + ) -> Self { + self.attempt_to_fix = Some(value); + self + } + + pub fn disabled( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabled, + ) -> Self { + self.disabled = Some(value); + self + } + + pub fn quarantined( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesQuarantined, + ) -> Self { + self.quarantined = Some(value); + self + } + + pub fn repository_id(mut self, value: String) -> Self { + self.repository_id = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesAttributes { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesAttributesVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesAttributesVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesAttributes; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut attempt_to_fix: Option = None; + let mut disabled: Option< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabled, + > = None; + let mut quarantined: Option = None; + let mut repository_id: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "attempt_to_fix" => { + if v.is_null() { + continue; + } + attempt_to_fix = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "disabled" => { + if v.is_null() { + continue; + } + disabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "quarantined" => { + if v.is_null() { + continue; + } + quarantined = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "repository_id" => { + if v.is_null() { + continue; + } + repository_id = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = TestOptimizationFlakyTestsManagementPoliciesAttributes { + attempt_to_fix, + disabled, + quarantined, + repository_id, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(TestOptimizationFlakyTestsManagementPoliciesAttributesVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_auto_disable_rule.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_auto_disable_rule.rs new file mode 100644 index 0000000000..23e1022aee --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_auto_disable_rule.rs @@ -0,0 +1,154 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Automatic disable triggering rule based on a time window and test status. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule { + /// Whether this auto-disable rule is enabled. + #[serde(rename = "enabled")] + pub enabled: Option, + /// Test status that the disable policy applies to. + /// Must be either `active` or `quarantined`. + #[serde(rename = "status")] + pub status: + Option, + /// Time window in seconds over which flakiness is evaluated. Must be greater than 0. + #[serde(rename = "window_seconds")] + pub window_seconds: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule { + TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule { + enabled: None, + status: None, + window_seconds: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn enabled(mut self, value: bool) -> Self { + self.enabled = Some(value); + self + } + + pub fn status( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabledStatus, + ) -> Self { + self.status = Some(value); + self + } + + pub fn window_seconds(mut self, value: i64) -> Self { + self.window_seconds = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesAutoDisableRuleVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesAutoDisableRuleVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut enabled: Option = None; + let mut status: Option = None; + let mut window_seconds: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "enabled" => { + if v.is_null() { + continue; + } + enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "status" => { + if v.is_null() { + continue; + } + status = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _status) = status { + match _status { + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabledStatus::UnparsedObject(_status) => { + _unparsed = true; + }, + _ => {} + } + } + } + "window_seconds" => { + if v.is_null() { + continue; + } + window_seconds = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule { + enabled, + status, + window_seconds, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(TestOptimizationFlakyTestsManagementPoliciesAutoDisableRuleVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_auto_quarantine_rule.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_auto_quarantine_rule.rs new file mode 100644 index 0000000000..13b0c22dd0 --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_auto_quarantine_rule.rs @@ -0,0 +1,124 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Automatic quarantine triggering rule based on a time window. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule { + /// Whether this auto-quarantine rule is enabled. + #[serde(rename = "enabled")] + pub enabled: Option, + /// Time window in seconds over which flakiness is evaluated. Must be greater than 0. + #[serde(rename = "window_seconds")] + pub window_seconds: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule { + TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule { + enabled: None, + window_seconds: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn enabled(mut self, value: bool) -> Self { + self.enabled = Some(value); + self + } + + pub fn window_seconds(mut self, value: i64) -> Self { + self.window_seconds = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRuleVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRuleVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut enabled: Option = None; + let mut window_seconds: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "enabled" => { + if v.is_null() { + continue; + } + enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "window_seconds" => { + if v.is_null() { + continue; + } + window_seconds = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule { + enabled, + window_seconds, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRuleVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_branch_rule.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_branch_rule.rs new file mode 100644 index 0000000000..f1ed0ee9ba --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_branch_rule.rs @@ -0,0 +1,158 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Branch filtering rule for a Flaky Tests Management policy. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesBranchRule { + /// List of branches to which the policy applies. + #[serde(rename = "branches")] + pub branches: Option>, + /// Whether this branch rule is enabled. + #[serde(rename = "enabled")] + pub enabled: Option, + /// List of branches excluded from the policy. + #[serde(rename = "excluded_branches")] + pub excluded_branches: Option>, + /// List of test services excluded from the policy. + #[serde(rename = "excluded_test_services")] + pub excluded_test_services: Option>, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesBranchRule { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesBranchRule { + TestOptimizationFlakyTestsManagementPoliciesBranchRule { + branches: None, + enabled: None, + excluded_branches: None, + excluded_test_services: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn branches(mut self, value: Vec) -> Self { + self.branches = Some(value); + self + } + + pub fn enabled(mut self, value: bool) -> Self { + self.enabled = Some(value); + self + } + + pub fn excluded_branches(mut self, value: Vec) -> Self { + self.excluded_branches = Some(value); + self + } + + pub fn excluded_test_services(mut self, value: Vec) -> Self { + self.excluded_test_services = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesBranchRule { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesBranchRule { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesBranchRuleVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesBranchRuleVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesBranchRule; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut branches: Option> = None; + let mut enabled: Option = None; + let mut excluded_branches: Option> = None; + let mut excluded_test_services: Option> = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "branches" => { + if v.is_null() { + continue; + } + branches = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "enabled" => { + if v.is_null() { + continue; + } + enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "excluded_branches" => { + if v.is_null() { + continue; + } + excluded_branches = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "excluded_test_services" => { + if v.is_null() { + continue; + } + excluded_test_services = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = TestOptimizationFlakyTestsManagementPoliciesBranchRule { + branches, + enabled, + excluded_branches, + excluded_test_services, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(TestOptimizationFlakyTestsManagementPoliciesBranchRuleVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_data.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_data.rs new file mode 100644 index 0000000000..755270703e --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_data.rs @@ -0,0 +1,159 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Data object for Flaky Tests Management policies response. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesData { + /// Attributes of the Flaky Tests Management policies for a repository. + #[serde(rename = "attributes")] + pub attributes: + Option, + /// The repository identifier used as the resource ID. + #[serde(rename = "id")] + pub id: Option, + /// JSON:API type for Flaky Tests Management policies response. + /// The value must always be `test_optimization_flaky_tests_management_policies`. + #[serde(rename = "type")] + pub type_: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesData { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesData { + TestOptimizationFlakyTestsManagementPoliciesData { + attributes: None, + id: None, + type_: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn attributes( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesAttributes, + ) -> Self { + self.attributes = Some(value); + self + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn type_( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesType, + ) -> Self { + self.type_ = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesData { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesDataVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesDataVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesData; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut attributes: Option< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesAttributes, + > = None; + let mut id: Option = None; + let mut type_: Option< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesType, + > = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "attributes" => { + if v.is_null() { + continue; + } + attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "id" => { + if v.is_null() { + continue; + } + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + if v.is_null() { + continue; + } + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = TestOptimizationFlakyTestsManagementPoliciesData { + attributes, + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(TestOptimizationFlakyTestsManagementPoliciesDataVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled.rs new file mode 100644 index 0000000000..57d503e88f --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled.rs @@ -0,0 +1,170 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Configuration for the disabled Flaky Tests Management policy. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesDisabled { + /// Automatic disable triggering rule based on a time window and test status. + #[serde(rename = "auto_disable_rule")] + pub auto_disable_rule: Option, + /// Branch filtering rule for a Flaky Tests Management policy. + #[serde(rename = "branch_rule")] + pub branch_rule: Option, + /// Whether the disabled policy is enabled. + #[serde(rename = "enabled")] + pub enabled: Option, + /// Failure-rate-based rule for the disabled policy. + #[serde(rename = "failure_rate_rule")] + pub failure_rate_rule: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool +} + +impl TestOptimizationFlakyTestsManagementPoliciesDisabled { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesDisabled { + TestOptimizationFlakyTestsManagementPoliciesDisabled { + auto_disable_rule: None, + branch_rule: None, + enabled: None, + failure_rate_rule: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn auto_disable_rule( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule, + ) -> Self { + self.auto_disable_rule = Some(value); + self + } + + pub fn branch_rule( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesBranchRule, + ) -> Self { + self.branch_rule = Some(value); + self + } + + pub fn enabled(mut self, value: bool) -> Self { + self.enabled = Some(value); + self + } + + pub fn failure_rate_rule( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule, + ) -> Self { + self.failure_rate_rule = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesDisabled { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesDisabled { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesDisabledVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesDisabledVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesDisabled; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut auto_disable_rule: Option = None; + let mut branch_rule: Option< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesBranchRule, + > = None; + let mut enabled: Option = None; + let mut failure_rate_rule: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "auto_disable_rule" => { + if v.is_null() { + continue; + } + auto_disable_rule = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "branch_rule" => { + if v.is_null() { + continue; + } + branch_rule = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "enabled" => { + if v.is_null() { + continue; + } + enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "failure_rate_rule" => { + if v.is_null() { + continue; + } + failure_rate_rule = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = TestOptimizationFlakyTestsManagementPoliciesDisabled { + auto_disable_rule, + branch_rule, + enabled, + failure_rate_rule, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(TestOptimizationFlakyTestsManagementPoliciesDisabledVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled_failure_rate_rule.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled_failure_rate_rule.rs new file mode 100644 index 0000000000..bfa980ee42 --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled_failure_rate_rule.rs @@ -0,0 +1,190 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Failure-rate-based rule for the disabled policy. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule { + /// List of branches to which this rule applies. + #[serde(rename = "branches")] + pub branches: Option>, + /// Whether this failure rate rule is enabled. + #[serde(rename = "enabled")] + pub enabled: Option, + /// Minimum number of runs required before the rule is evaluated. Must be greater than or equal to 0. + #[serde(rename = "min_runs")] + pub min_runs: Option, + /// Test status that the disable policy applies to. + /// Must be either `active` or `quarantined`. + #[serde(rename = "status")] + pub status: + Option, + /// Failure rate threshold (0.0–1.0) above which the rule triggers. + #[serde(rename = "threshold")] + pub threshold: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule { + TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule { + branches: None, + enabled: None, + min_runs: None, + status: None, + threshold: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn branches(mut self, value: Vec) -> Self { + self.branches = Some(value); + self + } + + pub fn enabled(mut self, value: bool) -> Self { + self.enabled = Some(value); + self + } + + pub fn min_runs(mut self, value: i64) -> Self { + self.min_runs = Some(value); + self + } + + pub fn status( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabledStatus, + ) -> Self { + self.status = Some(value); + self + } + + pub fn threshold(mut self, value: f64) -> Self { + self.threshold = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRuleVisitor; + impl<'a> Visitor<'a> + for TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRuleVisitor + { + type Value = TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut branches: Option> = None; + let mut enabled: Option = None; + let mut min_runs: Option = None; + let mut status: Option = None; + let mut threshold: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "branches" => { + if v.is_null() { + continue; + } + branches = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "enabled" => { + if v.is_null() { + continue; + } + enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "min_runs" => { + if v.is_null() { + continue; + } + min_runs = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "status" => { + if v.is_null() { + continue; + } + status = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _status) = status { + match _status { + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabledStatus::UnparsedObject(_status) => { + _unparsed = true; + }, + _ => {} + } + } + } + "threshold" => { + if v.is_null() || v.as_str() == Some("") { + continue; + } + threshold = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule { + branches, + enabled, + min_runs, + status, + threshold, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any( + TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRuleVisitor, + ) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled_status.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled_status.rs new file mode 100644 index 0000000000..4d2d044ca9 --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_disabled_status.rs @@ -0,0 +1,51 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum TestOptimizationFlakyTestsManagementPoliciesDisabledStatus { + ACTIVE, + QUARANTINED, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for TestOptimizationFlakyTestsManagementPoliciesDisabledStatus { + fn to_string(&self) -> String { + match self { + Self::ACTIVE => String::from("active"), + Self::QUARANTINED => String::from("quarantined"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for TestOptimizationFlakyTestsManagementPoliciesDisabledStatus { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesDisabledStatus { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "active" => Self::ACTIVE, + "quarantined" => Self::QUARANTINED, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request.rs new file mode 100644 index 0000000000..555aac3a6e --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request.rs @@ -0,0 +1,94 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Request object for getting Flaky Tests Management policies. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesGetRequest { + /// Data object for get Flaky Tests Management policies request. + #[serde(rename = "data")] + pub data: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesGetRequestData, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesGetRequest { + pub fn new( + data: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesGetRequestData, + ) -> TestOptimizationFlakyTestsManagementPoliciesGetRequest { + TestOptimizationFlakyTestsManagementPoliciesGetRequest { + data, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesGetRequest { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesGetRequestVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesGetRequestVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesGetRequest; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut data: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "data" => { + data = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let data = data.ok_or_else(|| M::Error::missing_field("data"))?; + + let content = TestOptimizationFlakyTestsManagementPoliciesGetRequest { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(TestOptimizationFlakyTestsManagementPoliciesGetRequestVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request_attributes.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request_attributes.rs new file mode 100644 index 0000000000..c85531b21e --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request_attributes.rs @@ -0,0 +1,98 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Attributes for requesting Flaky Tests Management policies. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes { + /// The repository identifier. + #[serde(rename = "repository_id")] + pub repository_id: String, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes { + pub fn new( + repository_id: String, + ) -> TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes { + TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes { + repository_id, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributesVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributesVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut repository_id: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "repository_id" => { + repository_id = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let repository_id = + repository_id.ok_or_else(|| M::Error::missing_field("repository_id"))?; + + let content = TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes { + repository_id, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any( + TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributesVisitor, + ) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request_data.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request_data.rs new file mode 100644 index 0000000000..da60db87d4 --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_get_request_data.rs @@ -0,0 +1,117 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Data object for get Flaky Tests Management policies request. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesGetRequestData { + /// Attributes for requesting Flaky Tests Management policies. + #[serde(rename = "attributes")] + pub attributes: + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes, + /// JSON:API type for get Flaky Tests Management policies request. + /// The value must always be `test_optimization_get_flaky_tests_management_policies_request`. + #[serde(rename = "type")] + pub type_: + crate::datadogV2::model::TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesGetRequestData { + pub fn new( + attributes: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes, + type_: crate::datadogV2::model::TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType, + ) -> TestOptimizationFlakyTestsManagementPoliciesGetRequestData { + TestOptimizationFlakyTestsManagementPoliciesGetRequestData { + attributes, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesGetRequestData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesGetRequestDataVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesGetRequestDataVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesGetRequestData; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut attributes: Option = None; + let mut type_: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "attributes" => { + attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let attributes = attributes.ok_or_else(|| M::Error::missing_field("attributes"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = TestOptimizationFlakyTestsManagementPoliciesGetRequestData { + attributes, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(TestOptimizationFlakyTestsManagementPoliciesGetRequestDataVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_quarantined.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_quarantined.rs new file mode 100644 index 0000000000..670392f6b8 --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_quarantined.rs @@ -0,0 +1,170 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Configuration for the quarantined Flaky Tests Management policy. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesQuarantined { + /// Automatic quarantine triggering rule based on a time window. + #[serde(rename = "auto_quarantine_rule")] + pub auto_quarantine_rule: Option, + /// Branch filtering rule for a Flaky Tests Management policy. + #[serde(rename = "branch_rule")] + pub branch_rule: Option, + /// Whether the quarantined policy is enabled. + #[serde(rename = "enabled")] + pub enabled: Option, + /// Failure-rate-based rule for the quarantined policy. + #[serde(rename = "failure_rate_rule")] + pub failure_rate_rule: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool +} + +impl TestOptimizationFlakyTestsManagementPoliciesQuarantined { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesQuarantined { + TestOptimizationFlakyTestsManagementPoliciesQuarantined { + auto_quarantine_rule: None, + branch_rule: None, + enabled: None, + failure_rate_rule: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn auto_quarantine_rule( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule, + ) -> Self { + self.auto_quarantine_rule = Some(value); + self + } + + pub fn branch_rule( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesBranchRule, + ) -> Self { + self.branch_rule = Some(value); + self + } + + pub fn enabled(mut self, value: bool) -> Self { + self.enabled = Some(value); + self + } + + pub fn failure_rate_rule( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule, + ) -> Self { + self.failure_rate_rule = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesQuarantined { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesQuarantined { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesQuarantinedVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesQuarantinedVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesQuarantined; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut auto_quarantine_rule: Option = None; + let mut branch_rule: Option< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesBranchRule, + > = None; + let mut enabled: Option = None; + let mut failure_rate_rule: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "auto_quarantine_rule" => { + if v.is_null() { + continue; + } + auto_quarantine_rule = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "branch_rule" => { + if v.is_null() { + continue; + } + branch_rule = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "enabled" => { + if v.is_null() { + continue; + } + enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "failure_rate_rule" => { + if v.is_null() { + continue; + } + failure_rate_rule = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = TestOptimizationFlakyTestsManagementPoliciesQuarantined { + auto_quarantine_rule, + branch_rule, + enabled, + failure_rate_rule, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(TestOptimizationFlakyTestsManagementPoliciesQuarantinedVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_quarantined_failure_rate_rule.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_quarantined_failure_rate_rule.rs new file mode 100644 index 0000000000..72859e4168 --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_quarantined_failure_rate_rule.rs @@ -0,0 +1,163 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Failure-rate-based rule for the quarantined policy. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule { + /// List of branches to which this rule applies. + #[serde(rename = "branches")] + pub branches: Option>, + /// Whether this failure rate rule is enabled. + #[serde(rename = "enabled")] + pub enabled: Option, + /// Minimum number of runs required before the rule is evaluated. Must be greater than or equal to 0. + #[serde(rename = "min_runs")] + pub min_runs: Option, + /// Failure rate threshold (0.0–1.0) above which the rule triggers. + #[serde(rename = "threshold")] + pub threshold: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule { + TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule { + branches: None, + enabled: None, + min_runs: None, + threshold: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn branches(mut self, value: Vec) -> Self { + self.branches = Some(value); + self + } + + pub fn enabled(mut self, value: bool) -> Self { + self.enabled = Some(value); + self + } + + pub fn min_runs(mut self, value: i64) -> Self { + self.min_runs = Some(value); + self + } + + pub fn threshold(mut self, value: f64) -> Self { + self.threshold = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> + for TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRuleVisitor; + impl<'a> Visitor<'a> + for TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRuleVisitor + { + type Value = TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut branches: Option> = None; + let mut enabled: Option = None; + let mut min_runs: Option = None; + let mut threshold: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "branches" => { + if v.is_null() { + continue; + } + branches = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "enabled" => { + if v.is_null() { + continue; + } + enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "min_runs" => { + if v.is_null() { + continue; + } + min_runs = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "threshold" => { + if v.is_null() || v.as_str() == Some("") { + continue; + } + threshold = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = + TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule { + branches, + enabled, + min_runs, + threshold, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any( + TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRuleVisitor, + ) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_response.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_response.rs new file mode 100644 index 0000000000..1841bf4b1a --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_response.rs @@ -0,0 +1,110 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Response object containing Flaky Tests Management policies for a repository. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesResponse { + /// Data object for Flaky Tests Management policies response. + #[serde(rename = "data")] + pub data: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesResponse { + pub fn new() -> TestOptimizationFlakyTestsManagementPoliciesResponse { + TestOptimizationFlakyTestsManagementPoliciesResponse { + data: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn data( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesData, + ) -> Self { + self.data = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for TestOptimizationFlakyTestsManagementPoliciesResponse { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesResponse { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesResponseVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesResponseVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesResponse; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut data: Option< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesData, + > = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "data" => { + if v.is_null() { + continue; + } + data = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = TestOptimizationFlakyTestsManagementPoliciesResponse { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(TestOptimizationFlakyTestsManagementPoliciesResponseVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_type.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_type.rs new file mode 100644 index 0000000000..4f819d1d64 --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_type.rs @@ -0,0 +1,52 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum TestOptimizationFlakyTestsManagementPoliciesType { + TEST_OPTIMIZATION_FLAKY_TESTS_MANAGEMENT_POLICIES, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for TestOptimizationFlakyTestsManagementPoliciesType { + fn to_string(&self) -> String { + match self { + Self::TEST_OPTIMIZATION_FLAKY_TESTS_MANAGEMENT_POLICIES => { + String::from("test_optimization_flaky_tests_management_policies") + } + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for TestOptimizationFlakyTestsManagementPoliciesType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "test_optimization_flaky_tests_management_policies" => { + Self::TEST_OPTIMIZATION_FLAKY_TESTS_MANAGEMENT_POLICIES + } + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request.rs new file mode 100644 index 0000000000..b45b619585 --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request.rs @@ -0,0 +1,96 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Request object for updating Flaky Tests Management policies. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesUpdateRequest { + /// Data object for update Flaky Tests Management policies request. + #[serde(rename = "data")] + pub data: + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesUpdateRequest { + pub fn new( + data: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData, + ) -> TestOptimizationFlakyTestsManagementPoliciesUpdateRequest { + TestOptimizationFlakyTestsManagementPoliciesUpdateRequest { + data, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesUpdateRequest { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesUpdateRequestVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesUpdateRequestVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesUpdateRequest; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut data: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "data" => { + data = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let data = data.ok_or_else(|| M::Error::missing_field("data"))?; + + let content = TestOptimizationFlakyTestsManagementPoliciesUpdateRequest { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(TestOptimizationFlakyTestsManagementPoliciesUpdateRequestVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request_attributes.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request_attributes.rs new file mode 100644 index 0000000000..a152174e0a --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request_attributes.rs @@ -0,0 +1,168 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Attributes for updating Flaky Tests Management policies. +/// Only provided policy blocks are updated; omitted blocks are left unchanged. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes { + /// Configuration for the attempt-to-fix Flaky Tests Management policy. + #[serde(rename = "attempt_to_fix")] + pub attempt_to_fix: + Option, + /// Configuration for the disabled Flaky Tests Management policy. + #[serde(rename = "disabled")] + pub disabled: + Option, + /// Configuration for the quarantined Flaky Tests Management policy. + #[serde(rename = "quarantined")] + pub quarantined: + Option, + /// The repository identifier. + #[serde(rename = "repository_id")] + pub repository_id: String, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes { + pub fn new( + repository_id: String, + ) -> TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes { + TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes { + attempt_to_fix: None, + disabled: None, + quarantined: None, + repository_id, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn attempt_to_fix( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesAttemptToFix, + ) -> Self { + self.attempt_to_fix = Some(value); + self + } + + pub fn disabled( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabled, + ) -> Self { + self.disabled = Some(value); + self + } + + pub fn quarantined( + mut self, + value: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesQuarantined, + ) -> Self { + self.quarantined = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributesVisitor; + impl<'a> Visitor<'a> + for TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributesVisitor + { + type Value = TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut attempt_to_fix: Option = None; + let mut disabled: Option< + crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesDisabled, + > = None; + let mut quarantined: Option = None; + let mut repository_id: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "attempt_to_fix" => { + if v.is_null() { + continue; + } + attempt_to_fix = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "disabled" => { + if v.is_null() { + continue; + } + disabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "quarantined" => { + if v.is_null() { + continue; + } + quarantined = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "repository_id" => { + repository_id = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let repository_id = + repository_id.ok_or_else(|| M::Error::missing_field("repository_id"))?; + + let content = TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes { + attempt_to_fix, + disabled, + quarantined, + repository_id, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any( + TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributesVisitor, + ) + } +} diff --git a/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request_data.rs b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request_data.rs new file mode 100644 index 0000000000..c38b353a7d --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_flaky_tests_management_policies_update_request_data.rs @@ -0,0 +1,116 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Data object for update Flaky Tests Management policies request. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData { + /// Attributes for updating Flaky Tests Management policies. +/// Only provided policy blocks are updated; omitted blocks are left unchanged. + #[serde(rename = "attributes")] + pub attributes: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes, + /// JSON:API type for update Flaky Tests Management policies request. +/// The value must always be `test_optimization_update_flaky_tests_management_policies_request`. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool +} + +impl TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData { + pub fn new( + attributes: crate::datadogV2::model::TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes, + type_: crate::datadogV2::model::TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType, + ) -> TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData { + TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData { + attributes, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct TestOptimizationFlakyTestsManagementPoliciesUpdateRequestDataVisitor; + impl<'a> Visitor<'a> for TestOptimizationFlakyTestsManagementPoliciesUpdateRequestDataVisitor { + type Value = TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut attributes: Option = None; + let mut type_: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "attributes" => { + attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let attributes = attributes.ok_or_else(|| M::Error::missing_field("attributes"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData { + attributes, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(TestOptimizationFlakyTestsManagementPoliciesUpdateRequestDataVisitor) + } +} diff --git a/src/datadogV2/model/model_test_optimization_get_flaky_tests_management_policies_request_data_type.rs b/src/datadogV2/model/model_test_optimization_get_flaky_tests_management_policies_request_data_type.rs new file mode 100644 index 0000000000..9f286d79ca --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_get_flaky_tests_management_policies_request_data_type.rs @@ -0,0 +1,52 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType { + TEST_OPTIMIZATION_GET_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType { + fn to_string(&self) -> String { + match self { + Self::TEST_OPTIMIZATION_GET_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST => { + String::from("test_optimization_get_flaky_tests_management_policies_request") + } + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "test_optimization_get_flaky_tests_management_policies_request" => { + Self::TEST_OPTIMIZATION_GET_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST + } + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_test_optimization_update_flaky_tests_management_policies_request_data_type.rs b/src/datadogV2/model/model_test_optimization_update_flaky_tests_management_policies_request_data_type.rs new file mode 100644 index 0000000000..0d473d1ce1 --- /dev/null +++ b/src/datadogV2/model/model_test_optimization_update_flaky_tests_management_policies_request_data_type.rs @@ -0,0 +1,52 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType { + TEST_OPTIMIZATION_UPDATE_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType { + fn to_string(&self) -> String { + match self { + Self::TEST_OPTIMIZATION_UPDATE_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST => { + String::from("test_optimization_update_flaky_tests_management_policies_request") + } + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "test_optimization_update_flaky_tests_management_policies_request" => { + Self::TEST_OPTIMIZATION_UPDATE_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST + } + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/tests/scenarios/features/v2/test_optimization.feature b/tests/scenarios/features/v2/test_optimization.feature index 427db05baf..eeeec1dd34 100644 --- a/tests/scenarios/features/v2/test_optimization.feature +++ b/tests/scenarios/features/v2/test_optimization.feature @@ -33,6 +33,38 @@ Feature: Test Optimization When the request is sent Then the response status is 404 Not Found + @generated @skip @team:DataDog/ci-app-backend + Scenario: Get Flaky Tests Management policies returns "Bad Request" response + Given operation "GetFlakyTestsManagementPolicies" enabled + And new "GetFlakyTestsManagementPolicies" request + And body with value {"data": {"attributes": {"repository_id": "github.com/datadog/shopist"}, "type": "test_optimization_get_flaky_tests_management_policies_request"}} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/ci-app-backend + Scenario: Get Flaky Tests Management policies returns "Not Found" response + Given operation "GetFlakyTestsManagementPolicies" enabled + And new "GetFlakyTestsManagementPolicies" request + And body with value {"data": {"attributes": {"repository_id": "github.com/datadog/shopist"}, "type": "test_optimization_get_flaky_tests_management_policies_request"}} + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/ci-app-backend + Scenario: Get Flaky Tests Management policies returns "OK" response + Given operation "GetFlakyTestsManagementPolicies" enabled + And new "GetFlakyTestsManagementPolicies" request + And body with value {"data": {"attributes": {"repository_id": "github.com/datadog/shopist"}, "type": "test_optimization_get_flaky_tests_management_policies_request"}} + When the request is sent + Then the response status is 200 OK + + @skip @team:DataDog/ci-app-backend + Scenario: Get Flaky Tests Management policies with empty repository_id returns bad request + Given operation "GetFlakyTestsManagementPolicies" enabled + And new "GetFlakyTestsManagementPolicies" request + And body with value {"data": {"attributes": {"repository_id": ""}, "type": "test_optimization_get_flaky_tests_management_policies_request"}} + When the request is sent + Then the response status is 400 Bad Request + @generated @skip @team:DataDog/ci-app-backend Scenario: Get Test Optimization service settings returns "Bad Request" response Given operation "GetTestOptimizationServiceSettings" enabled @@ -133,6 +165,38 @@ Feature: Test Optimization When the request with pagination is sent Then the response status is 200 OK + @generated @skip @team:DataDog/ci-app-backend + Scenario: Update Flaky Tests Management policies returns "Bad Request" response + Given operation "UpdateFlakyTestsManagementPolicies" enabled + And new "UpdateFlakyTestsManagementPolicies" request + And body with value {"data": {"attributes": {"attempt_to_fix": {"retries": 3}, "disabled": {"auto_disable_rule": {"enabled": false, "status": "active", "window_seconds": 3600}, "branch_rule": {"branches": ["main"], "enabled": true, "excluded_branches": [], "excluded_test_services": []}, "enabled": false, "failure_rate_rule": {"branches": [], "enabled": false, "min_runs": 10, "status": "active", "threshold": 0.5}}, "quarantined": {"auto_quarantine_rule": {"enabled": true, "window_seconds": 3600}, "branch_rule": {"branches": ["main"], "enabled": true, "excluded_branches": [], "excluded_test_services": []}, "enabled": true, "failure_rate_rule": {"branches": ["main"], "enabled": true, "min_runs": 10, "threshold": 0.5}}, "repository_id": "github.com/datadog/shopist"}, "type": "test_optimization_update_flaky_tests_management_policies_request"}} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/ci-app-backend + Scenario: Update Flaky Tests Management policies returns "Not Found" response + Given operation "UpdateFlakyTestsManagementPolicies" enabled + And new "UpdateFlakyTestsManagementPolicies" request + And body with value {"data": {"attributes": {"attempt_to_fix": {"retries": 3}, "disabled": {"auto_disable_rule": {"enabled": false, "status": "active", "window_seconds": 3600}, "branch_rule": {"branches": ["main"], "enabled": true, "excluded_branches": [], "excluded_test_services": []}, "enabled": false, "failure_rate_rule": {"branches": [], "enabled": false, "min_runs": 10, "status": "active", "threshold": 0.5}}, "quarantined": {"auto_quarantine_rule": {"enabled": true, "window_seconds": 3600}, "branch_rule": {"branches": ["main"], "enabled": true, "excluded_branches": [], "excluded_test_services": []}, "enabled": true, "failure_rate_rule": {"branches": ["main"], "enabled": true, "min_runs": 10, "threshold": 0.5}}, "repository_id": "github.com/datadog/shopist"}, "type": "test_optimization_update_flaky_tests_management_policies_request"}} + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/ci-app-backend + Scenario: Update Flaky Tests Management policies returns "OK" response + Given operation "UpdateFlakyTestsManagementPolicies" enabled + And new "UpdateFlakyTestsManagementPolicies" request + And body with value {"data": {"attributes": {"attempt_to_fix": {"retries": 3}, "disabled": {"auto_disable_rule": {"enabled": false, "status": "active", "window_seconds": 3600}, "branch_rule": {"branches": ["main"], "enabled": true, "excluded_branches": [], "excluded_test_services": []}, "enabled": false, "failure_rate_rule": {"branches": [], "enabled": false, "min_runs": 10, "status": "active", "threshold": 0.5}}, "quarantined": {"auto_quarantine_rule": {"enabled": true, "window_seconds": 3600}, "branch_rule": {"branches": ["main"], "enabled": true, "excluded_branches": [], "excluded_test_services": []}, "enabled": true, "failure_rate_rule": {"branches": ["main"], "enabled": true, "min_runs": 10, "threshold": 0.5}}, "repository_id": "github.com/datadog/shopist"}, "type": "test_optimization_update_flaky_tests_management_policies_request"}} + When the request is sent + Then the response status is 200 OK + + @skip @team:DataDog/ci-app-backend + Scenario: Update Flaky Tests Management policies with empty repository_id returns bad request + Given operation "UpdateFlakyTestsManagementPolicies" enabled + And new "UpdateFlakyTestsManagementPolicies" request + And body with value {"data": {"attributes": {"repository_id": ""}, "type": "test_optimization_update_flaky_tests_management_policies_request"}} + When the request is sent + Then the response status is 400 Bad Request + @generated @skip @team:DataDog/ci-app-backend Scenario: Update Test Optimization service settings returns "Bad Request" response Given operation "UpdateTestOptimizationServiceSettings" enabled diff --git a/tests/scenarios/features/v2/undo.json b/tests/scenarios/features/v2/undo.json index 02afc91a4b..7642562ac7 100644 --- a/tests/scenarios/features/v2/undo.json +++ b/tests/scenarios/features/v2/undo.json @@ -1036,6 +1036,18 @@ "type": "safe" } }, + "UpdateFlakyTestsManagementPolicies": { + "tag": "Test Optimization", + "undo": { + "type": "unsafe" + } + }, + "GetFlakyTestsManagementPolicies": { + "tag": "Test Optimization", + "undo": { + "type": "safe" + } + }, "DeleteTestOptimizationServiceSettings": { "tag": "Test Optimization", "undo": { diff --git a/tests/scenarios/function_mappings.rs b/tests/scenarios/function_mappings.rs index a538507143..b586dcb0eb 100644 --- a/tests/scenarios/function_mappings.rs +++ b/tests/scenarios/function_mappings.rs @@ -2586,6 +2586,14 @@ pub fn collect_function_calls(world: &mut DatadogWorld) { "v2.SearchCIAppPipelineEventsWithPagination".into(), test_v2_search_ci_app_pipeline_events_with_pagination, ); + world.function_mappings.insert( + "v2.UpdateFlakyTestsManagementPolicies".into(), + test_v2_update_flaky_tests_management_policies, + ); + world.function_mappings.insert( + "v2.GetFlakyTestsManagementPolicies".into(), + test_v2_get_flaky_tests_management_policies, + ); world.function_mappings.insert( "v2.DeleteTestOptimizationServiceSettings".into(), test_v2_delete_test_optimization_service_settings, @@ -17925,6 +17933,62 @@ fn test_v2_search_ci_app_pipeline_events_with_pagination( world.response.code = 200; } +fn test_v2_update_flaky_tests_management_policies( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_test_optimization + .as_ref() + .expect("api instance not found"); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_flaky_tests_management_policies_with_http_info(body)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_get_flaky_tests_management_policies( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_test_optimization + .as_ref() + .expect("api instance not found"); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.get_flaky_tests_management_policies_with_http_info(body)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + fn test_v2_delete_test_optimization_service_settings( world: &mut DatadogWorld, _parameters: &HashMap,