Test Optimization

Search and manage flaky tests through Test Optimization. See the Test Optimization page for more information.

Search flaky tests

v2 (latest)

POST https://api.ap1.datadoghq.com/api/v2/test/flaky-test-management/testshttps://api.ap2.datadoghq.com/api/v2/test/flaky-test-management/testshttps://api.datadoghq.eu/api/v2/test/flaky-test-management/testshttps://api.ddog-gov.com/api/v2/test/flaky-test-management/testshttps://api.us2.ddog-gov.com/api/v2/test/flaky-test-management/testshttps://api.datadoghq.com/api/v2/test/flaky-test-management/testshttps://api.us3.datadoghq.com/api/v2/test/flaky-test-management/testshttps://api.us5.datadoghq.com/api/v2/test/flaky-test-management/tests

개요

List endpoint returning flaky tests from Flaky Test Management. Results are paginated.

The response includes comprehensive test information including:

Test identification and metadata (module, suite, name)
Flaky state and categorization
First and last flake occurrences (timestamp, branch, commit SHA)
Test execution statistics from the last 7 days (failure rate)
Pipeline impact metrics (failed pipelines count, total lost time)
Complete status change history (optional, ordered from most recent to oldest)

Set include_history to true in the request to receive the status change history for each test. History is disabled by default for better performance.

Results support filtering by various facets including service, environment, repository, branch, and test state.

This endpoint requires the test_optimization_read permission.

OAuth apps require the test_optimization_read authorization scope to access this endpoint.

요청

Body Data

Expand All

항목

유형

설명

data

object

The JSON:API data for flaky tests search request.

{
  "data": {
    "attributes": {
      "filter": {
        "include_history": true,
        "query": "flaky_test_state:active @git.repository.id_v2:\"github.com/datadog/shopist\""
      },
      "page": {
        "cursor": "eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==",
        "limit": 25
      },
      "sort": "failure_rate"
    },
    "type": "string"
  }
}

응답

Response object with flaky tests matching the search request.

Expand All

항목

유형

설명

data

[object]

Array of flaky tests matching the request.

attributes

object

Attributes of a flaky test.

코드 사례

                  ## default
# 

# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/test/flaky-test-management/tests" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "filter": {
        "query": "flaky_test_state:active @git.repository.id_v2:\"github.com/datadog/test-service\""
      },
      "page": {
        "cursor": "eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==",
        "limit": 25
      },
      "sort": "failure_rate"
    },
    "type": "search_flaky_tests_request"
  }
}
EOF

                

"""
Search flaky tests returns "OK" response
"""

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.test_optimization_api import TestOptimizationApi
from datadog_api_client.v2.model.flaky_tests_search_filter import FlakyTestsSearchFilter
from datadog_api_client.v2.model.flaky_tests_search_page_options import FlakyTestsSearchPageOptions
from datadog_api_client.v2.model.flaky_tests_search_request import FlakyTestsSearchRequest
from datadog_api_client.v2.model.flaky_tests_search_request_attributes import FlakyTestsSearchRequestAttributes
from datadog_api_client.v2.model.flaky_tests_search_request_data import FlakyTestsSearchRequestData
from datadog_api_client.v2.model.flaky_tests_search_request_data_type import FlakyTestsSearchRequestDataType
from datadog_api_client.v2.model.flaky_tests_search_sort import FlakyTestsSearchSort

body = FlakyTestsSearchRequest(
    data=FlakyTestsSearchRequestData(
        attributes=FlakyTestsSearchRequestAttributes(
            filter=FlakyTestsSearchFilter(
                include_history=True,
                query='flaky_test_state:active @git.repository.id_v2:"github.com/datadog/shopist"',
            ),
            page=FlakyTestsSearchPageOptions(
                cursor="eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==",
                limit=25,
            ),
            sort=FlakyTestsSearchSort.FAILURE_RATE_ASCENDING,
        ),
        type=FlakyTestsSearchRequestDataType.SEARCH_FLAKY_TESTS_REQUEST,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = TestOptimizationApi(api_client)
    response = api_instance.search_flaky_tests(body=body)

    print(response)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" python3 "example.py"

# Search flaky tests returns "OK" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::TestOptimizationAPI.new

body = DatadogAPIClient::V2::FlakyTestsSearchRequest.new({
  data: DatadogAPIClient::V2::FlakyTestsSearchRequestData.new({
    attributes: DatadogAPIClient::V2::FlakyTestsSearchRequestAttributes.new({
      filter: DatadogAPIClient::V2::FlakyTestsSearchFilter.new({
        include_history: true,
        query: 'flaky_test_state:active @git.repository.id_v2:"github.com/datadog/shopist"',
      }),
      page: DatadogAPIClient::V2::FlakyTestsSearchPageOptions.new({
        cursor: "eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==",
        limit: 25,
      }),
      sort: DatadogAPIClient::V2::FlakyTestsSearchSort::FAILURE_RATE_ASCENDING,
    }),
    type: DatadogAPIClient::V2::FlakyTestsSearchRequestDataType::SEARCH_FLAKY_TESTS_REQUEST,
  }),
})
opts = {
  body: body,
}
p api_instance.search_flaky_tests(opts)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" rb "example.rb"

// Search flaky tests returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	body := datadogV2.FlakyTestsSearchRequest{
		Data: &datadogV2.FlakyTestsSearchRequestData{
			Attributes: &datadogV2.FlakyTestsSearchRequestAttributes{
				Filter: &datadogV2.FlakyTestsSearchFilter{
					IncludeHistory: datadog.PtrBool(true),
					Query:          datadog.PtrString(`flaky_test_state:active @git.repository.id_v2:"github.com/datadog/shopist"`),
				},
				Page: &datadogV2.FlakyTestsSearchPageOptions{
					Cursor: datadog.PtrString("eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ=="),
					Limit:  datadog.PtrInt64(25),
				},
				Sort: datadogV2.FLAKYTESTSSEARCHSORT_FAILURE_RATE_ASCENDING.Ptr(),
			},
			Type: datadogV2.FLAKYTESTSSEARCHREQUESTDATATYPE_SEARCH_FLAKY_TESTS_REQUEST.Ptr(),
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewTestOptimizationApi(apiClient)
	resp, r, err := api.SearchFlakyTests(ctx, *datadogV2.NewSearchFlakyTestsOptionalParameters().WithBody(body))

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `TestOptimizationApi.SearchFlakyTests`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `TestOptimizationApi.SearchFlakyTests`:\n%s\n", responseContent)
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" go run "main.go"

// Search flaky tests returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.TestOptimizationApi;
import com.datadog.api.client.v2.api.TestOptimizationApi.SearchFlakyTestsOptionalParameters;
import com.datadog.api.client.v2.model.FlakyTestsSearchFilter;
import com.datadog.api.client.v2.model.FlakyTestsSearchPageOptions;
import com.datadog.api.client.v2.model.FlakyTestsSearchRequest;
import com.datadog.api.client.v2.model.FlakyTestsSearchRequestAttributes;
import com.datadog.api.client.v2.model.FlakyTestsSearchRequestData;
import com.datadog.api.client.v2.model.FlakyTestsSearchRequestDataType;
import com.datadog.api.client.v2.model.FlakyTestsSearchResponse;
import com.datadog.api.client.v2.model.FlakyTestsSearchSort;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    TestOptimizationApi apiInstance = new TestOptimizationApi(defaultClient);

    FlakyTestsSearchRequest body =
        new FlakyTestsSearchRequest()
            .data(
                new FlakyTestsSearchRequestData()
                    .attributes(
                        new FlakyTestsSearchRequestAttributes()
                            .filter(
                                new FlakyTestsSearchFilter()
                                    .includeHistory(true)
                                    .query(
                                        """
flaky_test_state:active @git.repository.id_v2:"github.com/datadog/shopist"
"""))
                            .page(
                                new FlakyTestsSearchPageOptions()
                                    .cursor(
                                        "eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==")
                                    .limit(25L))
                            .sort(FlakyTestsSearchSort.FAILURE_RATE_ASCENDING))
                    .type(FlakyTestsSearchRequestDataType.SEARCH_FLAKY_TESTS_REQUEST));

    try {
      FlakyTestsSearchResponse result =
          apiInstance.searchFlakyTests(new SearchFlakyTestsOptionalParameters().body(body));
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling TestOptimizationApi#searchFlakyTests");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

Instructions

First install the library and its dependencies and then save the example to Example.java and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" java "Example.java"

// Search flaky tests returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_test_optimization::SearchFlakyTestsOptionalParams;
use datadog_api_client::datadogV2::api_test_optimization::TestOptimizationAPI;
use datadog_api_client::datadogV2::model::FlakyTestsSearchFilter;
use datadog_api_client::datadogV2::model::FlakyTestsSearchPageOptions;
use datadog_api_client::datadogV2::model::FlakyTestsSearchRequest;
use datadog_api_client::datadogV2::model::FlakyTestsSearchRequestAttributes;
use datadog_api_client::datadogV2::model::FlakyTestsSearchRequestData;
use datadog_api_client::datadogV2::model::FlakyTestsSearchRequestDataType;
use datadog_api_client::datadogV2::model::FlakyTestsSearchSort;

#[tokio::main]
async fn main() {
    let body =
        FlakyTestsSearchRequest
        ::new().data(
            FlakyTestsSearchRequestData::new()
                .attributes(
                    FlakyTestsSearchRequestAttributes::new()
                        .filter(
                            FlakyTestsSearchFilter::new()
                                .include_history(true)
                                .query(
                                    r#"flaky_test_state:active @git.repository.id_v2:"github.com/datadog/shopist""#.to_string(),
                                ),
                        )
                        .page(
                            FlakyTestsSearchPageOptions::new()
                                .cursor(
                                    "eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==".to_string(),
                                )
                                .limit(25),
                        )
                        .sort(FlakyTestsSearchSort::FAILURE_RATE_ASCENDING),
                )
                .type_(FlakyTestsSearchRequestDataType::SEARCH_FLAKY_TESTS_REQUEST),
        );
    let configuration = datadog::Configuration::new();
    let api = TestOptimizationAPI::with_config(configuration);
    let resp = api
        .search_flaky_tests(SearchFlakyTestsOptionalParams::default().body(body))
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

/**
 * Search flaky tests returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.TestOptimizationApi(configuration);

const params: v2.TestOptimizationApiSearchFlakyTestsRequest = {
  body: {
    data: {
      attributes: {
        filter: {
          includeHistory: true,
          query: `flaky_test_state:active @git.repository.id_v2:"github.com/datadog/shopist"`,
        },
        page: {
          cursor:
            "eyJzdGFydEF0IjoiQVFBQUFYS2tMS3pPbm40NGV3QUFBQUJCV0V0clRFdDZVbG8zY3pCRmNsbHJiVmxDWlEifQ==",
          limit: 25,
        },
        sort: "failure_rate",
      },
      type: "search_flaky_tests_request",
    },
  },
};

apiInstance
  .searchFlakyTests(params)
  .then((data: v2.FlakyTestsSearchResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" tsc "example.ts"

Update flaky test states

v2 (latest)

PATCH https://api.ap1.datadoghq.com/api/v2/test/flaky-test-management/testshttps://api.ap2.datadoghq.com/api/v2/test/flaky-test-management/testshttps://api.datadoghq.eu/api/v2/test/flaky-test-management/testshttps://api.ddog-gov.com/api/v2/test/flaky-test-management/testshttps://api.us2.ddog-gov.com/api/v2/test/flaky-test-management/testshttps://api.datadoghq.com/api/v2/test/flaky-test-management/testshttps://api.us3.datadoghq.com/api/v2/test/flaky-test-management/testshttps://api.us5.datadoghq.com/api/v2/test/flaky-test-management/tests

개요

Update the state of multiple flaky tests in Flaky Test Management. This endpoint requires the test_optimization_write permission.

OAuth apps require the test_optimization_write authorization scope to access this endpoint.

요청

Body Data (required)

Expand All

항목

유형

설명

data [required]

object

The JSON:API data for updating flaky test states.

{
  "data": {
    "attributes": {
      "tests": [
        {
          "id": "4eb1887a8adb1847",
          "new_state": "active"
        }
      ]
    },
    "type": "update_flaky_test_state_request"
  }
}

응답

Response object for updating flaky test states.

Expand All

항목

유형

설명

data

object

Summary of the update operations. Tells whether a test succeeded or failed to be updated.

{
  "data": {
    "attributes": {
      "has_errors": true,
      "results": [
        {
          "error": "string",
          "id": "4eb1887a8adb1847",
          "success": false
        }
      ]
    },
    "id": "string",
    "type": "string"
  }
}

Bad Request

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Authorized

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Too many requests

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

코드 사례

                  ## default
# 

# Curl command
curl -X PATCH "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/test/flaky-test-management/tests" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "tests": [
        {
          "id": "4eb1887a8adb1847",
          "new_state": "active"
        }
      ]
    },
    "type": "update_flaky_test_state_request"
  }
}
EOF

                

"""
Update flaky test states returns "OK" response
"""

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.test_optimization_api import TestOptimizationApi
from datadog_api_client.v2.model.update_flaky_tests_request import UpdateFlakyTestsRequest
from datadog_api_client.v2.model.update_flaky_tests_request_attributes import UpdateFlakyTestsRequestAttributes
from datadog_api_client.v2.model.update_flaky_tests_request_data import UpdateFlakyTestsRequestData
from datadog_api_client.v2.model.update_flaky_tests_request_data_type import UpdateFlakyTestsRequestDataType
from datadog_api_client.v2.model.update_flaky_tests_request_test import UpdateFlakyTestsRequestTest
from datadog_api_client.v2.model.update_flaky_tests_request_test_new_state import UpdateFlakyTestsRequestTestNewState

body = UpdateFlakyTestsRequest(
    data=UpdateFlakyTestsRequestData(
        attributes=UpdateFlakyTestsRequestAttributes(
            tests=[
                UpdateFlakyTestsRequestTest(
                    id="4eb1887a8adb1847",
                    new_state=UpdateFlakyTestsRequestTestNewState.ACTIVE,
                ),
            ],
        ),
        type=UpdateFlakyTestsRequestDataType.UPDATE_FLAKY_TEST_STATE_REQUEST,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = TestOptimizationApi(api_client)
    response = api_instance.update_flaky_tests(body=body)

    print(response)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" python3 "example.py"

# Update flaky test states returns "OK" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::TestOptimizationAPI.new

body = DatadogAPIClient::V2::UpdateFlakyTestsRequest.new({
  data: DatadogAPIClient::V2::UpdateFlakyTestsRequestData.new({
    attributes: DatadogAPIClient::V2::UpdateFlakyTestsRequestAttributes.new({
      tests: [
        DatadogAPIClient::V2::UpdateFlakyTestsRequestTest.new({
          id: "4eb1887a8adb1847",
          new_state: DatadogAPIClient::V2::UpdateFlakyTestsRequestTestNewState::ACTIVE,
        }),
      ],
    }),
    type: DatadogAPIClient::V2::UpdateFlakyTestsRequestDataType::UPDATE_FLAKY_TEST_STATE_REQUEST,
  }),
})
p api_instance.update_flaky_tests(body)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" rb "example.rb"

// Update flaky test states returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	body := datadogV2.UpdateFlakyTestsRequest{
		Data: datadogV2.UpdateFlakyTestsRequestData{
			Attributes: datadogV2.UpdateFlakyTestsRequestAttributes{
				Tests: []datadogV2.UpdateFlakyTestsRequestTest{
					{
						Id:       "4eb1887a8adb1847",
						NewState: datadogV2.UPDATEFLAKYTESTSREQUESTTESTNEWSTATE_ACTIVE,
					},
				},
			},
			Type: datadogV2.UPDATEFLAKYTESTSREQUESTDATATYPE_UPDATE_FLAKY_TEST_STATE_REQUEST,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewTestOptimizationApi(apiClient)
	resp, r, err := api.UpdateFlakyTests(ctx, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `TestOptimizationApi.UpdateFlakyTests`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `TestOptimizationApi.UpdateFlakyTests`:\n%s\n", responseContent)
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" go run "main.go"

// Update flaky test states returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.TestOptimizationApi;
import com.datadog.api.client.v2.model.UpdateFlakyTestsRequest;
import com.datadog.api.client.v2.model.UpdateFlakyTestsRequestAttributes;
import com.datadog.api.client.v2.model.UpdateFlakyTestsRequestData;
import com.datadog.api.client.v2.model.UpdateFlakyTestsRequestDataType;
import com.datadog.api.client.v2.model.UpdateFlakyTestsRequestTest;
import com.datadog.api.client.v2.model.UpdateFlakyTestsRequestTestNewState;
import com.datadog.api.client.v2.model.UpdateFlakyTestsResponse;
import java.util.Collections;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    TestOptimizationApi apiInstance = new TestOptimizationApi(defaultClient);

    UpdateFlakyTestsRequest body =
        new UpdateFlakyTestsRequest()
            .data(
                new UpdateFlakyTestsRequestData()
                    .attributes(
                        new UpdateFlakyTestsRequestAttributes()
                            .tests(
                                Collections.singletonList(
                                    new UpdateFlakyTestsRequestTest()
                                        .id("4eb1887a8adb1847")
                                        .newState(UpdateFlakyTestsRequestTestNewState.ACTIVE))))
                    .type(UpdateFlakyTestsRequestDataType.UPDATE_FLAKY_TEST_STATE_REQUEST));

    try {
      UpdateFlakyTestsResponse result = apiInstance.updateFlakyTests(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling TestOptimizationApi#updateFlakyTests");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

Instructions

First install the library and its dependencies and then save the example to Example.java and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" java "Example.java"

// Update flaky test states returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_test_optimization::TestOptimizationAPI;
use datadog_api_client::datadogV2::model::UpdateFlakyTestsRequest;
use datadog_api_client::datadogV2::model::UpdateFlakyTestsRequestAttributes;
use datadog_api_client::datadogV2::model::UpdateFlakyTestsRequestData;
use datadog_api_client::datadogV2::model::UpdateFlakyTestsRequestDataType;
use datadog_api_client::datadogV2::model::UpdateFlakyTestsRequestTest;
use datadog_api_client::datadogV2::model::UpdateFlakyTestsRequestTestNewState;

#[tokio::main]
async fn main() {
    let body = UpdateFlakyTestsRequest::new(UpdateFlakyTestsRequestData::new(
        UpdateFlakyTestsRequestAttributes::new(vec![UpdateFlakyTestsRequestTest::new(
            "4eb1887a8adb1847".to_string(),
            UpdateFlakyTestsRequestTestNewState::ACTIVE,
        )]),
        UpdateFlakyTestsRequestDataType::UPDATE_FLAKY_TEST_STATE_REQUEST,
    ));
    let configuration = datadog::Configuration::new();
    let api = TestOptimizationAPI::with_config(configuration);
    let resp = api.update_flaky_tests(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

/**
 * Update flaky test states returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.TestOptimizationApi(configuration);

const params: v2.TestOptimizationApiUpdateFlakyTestsRequest = {
  body: {
    data: {
      attributes: {
        tests: [
          {
            id: "4eb1887a8adb1847",
            newState: "active",
          },
        ],
      },
      type: "update_flaky_test_state_request",
    },
  },
};

apiInstance
  .updateFlakyTests(params)
  .then((data: v2.UpdateFlakyTestsResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" tsc "example.ts"

Get Test Optimization service settings

v2 (latest)

POST https://api.ap1.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.ap2.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.datadoghq.eu/api/v2/ci/test-optimization/settings/servicehttps://api.ddog-gov.com/api/v2/ci/test-optimization/settings/servicehttps://api.us2.ddog-gov.com/api/v2/ci/test-optimization/settings/servicehttps://api.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.us3.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.us5.datadoghq.com/api/v2/ci/test-optimization/settings/service

개요

Retrieve Test Optimization settings for a specific service identified by repository, service name, and environment. This endpoint requires the test_optimization_read permission.

OAuth apps require the test_optimization_read authorization scope to access this endpoint.

요청

Body Data (required)

Expand All

항목

유형

설명

data [required]

object

Data object for get service settings request.

{
  "data": {
    "attributes": {
      "env": "prod",
      "repository_id": "github.com/datadog/shopist",
      "service_name": "shopist"
    },
    "type": "test_optimization_get_service_settings_request"
  }
}

응답

Response object containing Test Optimization service settings.

Expand All

항목

유형

설명

data

object

Data object for Test Optimization service settings response.

{
  "data": {
    "attributes": {
      "auto_test_retries_enabled": false,
      "code_coverage_enabled": false,
      "early_flake_detection_enabled": false,
      "env": "prod",
      "failed_test_replay_enabled": false,
      "pr_comments_enabled": true,
      "repository_id": "github.com/datadog/shopist",
      "service_name": "shopist",
      "test_impact_analysis_enabled": false
    },
    "id": "github.com/datadog/shopist::shopist::prod",
    "type": "test_optimization_service_settings"
  }
}

Bad Request

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Authorized

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Found

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Too many requests

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

코드 사례

                  ## default
# 

# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/ci/test-optimization/settings/service" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "env": "prod",
      "repository_id": "github.com/datadog/test-service",
      "service_name": "test-service"
    },
    "type": "test_optimization_get_service_settings_request"
  }
}
EOF

                

"""
Get Test Optimization service settings returns "OK" response
"""

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.test_optimization_api import TestOptimizationApi
from datadog_api_client.v2.model.test_optimization_get_service_settings_request import (
    TestOptimizationGetServiceSettingsRequest,
)
from datadog_api_client.v2.model.test_optimization_get_service_settings_request_attributes import (
    TestOptimizationGetServiceSettingsRequestAttributes,
)
from datadog_api_client.v2.model.test_optimization_get_service_settings_request_data import (
    TestOptimizationGetServiceSettingsRequestData,
)
from datadog_api_client.v2.model.test_optimization_get_service_settings_request_data_type import (
    TestOptimizationGetServiceSettingsRequestDataType,
)

body = TestOptimizationGetServiceSettingsRequest(
    data=TestOptimizationGetServiceSettingsRequestData(
        attributes=TestOptimizationGetServiceSettingsRequestAttributes(
            env="prod",
            repository_id="github.com/datadog/shopist",
            service_name="shopist",
        ),
        type=TestOptimizationGetServiceSettingsRequestDataType.TEST_OPTIMIZATION_GET_SERVICE_SETTINGS_REQUEST,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = TestOptimizationApi(api_client)
    response = api_instance.get_test_optimization_service_settings(body=body)

    print(response)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" python3 "example.py"

# Get Test Optimization service settings returns "OK" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::TestOptimizationAPI.new

body = DatadogAPIClient::V2::TestOptimizationGetServiceSettingsRequest.new({
  data: DatadogAPIClient::V2::TestOptimizationGetServiceSettingsRequestData.new({
    attributes: DatadogAPIClient::V2::TestOptimizationGetServiceSettingsRequestAttributes.new({
      env: "prod",
      repository_id: "github.com/datadog/shopist",
      service_name: "shopist",
    }),
    type: DatadogAPIClient::V2::TestOptimizationGetServiceSettingsRequestDataType::TEST_OPTIMIZATION_GET_SERVICE_SETTINGS_REQUEST,
  }),
})
p api_instance.get_test_optimization_service_settings(body)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" rb "example.rb"

// Get Test Optimization service settings returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	body := datadogV2.TestOptimizationGetServiceSettingsRequest{
		Data: datadogV2.TestOptimizationGetServiceSettingsRequestData{
			Attributes: datadogV2.TestOptimizationGetServiceSettingsRequestAttributes{
				Env:          datadog.PtrString("prod"),
				RepositoryId: "github.com/datadog/shopist",
				ServiceName:  "shopist",
			},
			Type: datadogV2.TESTOPTIMIZATIONGETSERVICESETTINGSREQUESTDATATYPE_TEST_OPTIMIZATION_GET_SERVICE_SETTINGS_REQUEST,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewTestOptimizationApi(apiClient)
	resp, r, err := api.GetTestOptimizationServiceSettings(ctx, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `TestOptimizationApi.GetTestOptimizationServiceSettings`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `TestOptimizationApi.GetTestOptimizationServiceSettings`:\n%s\n", responseContent)
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" go run "main.go"

// Get Test Optimization service settings returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.TestOptimizationApi;
import com.datadog.api.client.v2.model.TestOptimizationGetServiceSettingsRequest;
import com.datadog.api.client.v2.model.TestOptimizationGetServiceSettingsRequestAttributes;
import com.datadog.api.client.v2.model.TestOptimizationGetServiceSettingsRequestData;
import com.datadog.api.client.v2.model.TestOptimizationGetServiceSettingsRequestDataType;
import com.datadog.api.client.v2.model.TestOptimizationServiceSettingsResponse;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    TestOptimizationApi apiInstance = new TestOptimizationApi(defaultClient);

    TestOptimizationGetServiceSettingsRequest body =
        new TestOptimizationGetServiceSettingsRequest()
            .data(
                new TestOptimizationGetServiceSettingsRequestData()
                    .attributes(
                        new TestOptimizationGetServiceSettingsRequestAttributes()
                            .env("prod")
                            .repositoryId("github.com/datadog/shopist")
                            .serviceName("shopist"))
                    .type(
                        TestOptimizationGetServiceSettingsRequestDataType
                            .TEST_OPTIMIZATION_GET_SERVICE_SETTINGS_REQUEST));

    try {
      TestOptimizationServiceSettingsResponse result =
          apiInstance.getTestOptimizationServiceSettings(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println(
          "Exception when calling TestOptimizationApi#getTestOptimizationServiceSettings");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

Instructions

First install the library and its dependencies and then save the example to Example.java and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" java "Example.java"

// Get Test Optimization service settings returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_test_optimization::TestOptimizationAPI;
use datadog_api_client::datadogV2::model::TestOptimizationGetServiceSettingsRequest;
use datadog_api_client::datadogV2::model::TestOptimizationGetServiceSettingsRequestAttributes;
use datadog_api_client::datadogV2::model::TestOptimizationGetServiceSettingsRequestData;
use datadog_api_client::datadogV2::model::TestOptimizationGetServiceSettingsRequestDataType;

#[tokio::main]
async fn main() {
    let body =
        TestOptimizationGetServiceSettingsRequest::new(
            TestOptimizationGetServiceSettingsRequestData::new(
                TestOptimizationGetServiceSettingsRequestAttributes::new(
                    "github.com/datadog/shopist".to_string(),
                    "shopist".to_string(),
                ).env("prod".to_string()),
                TestOptimizationGetServiceSettingsRequestDataType::TEST_OPTIMIZATION_GET_SERVICE_SETTINGS_REQUEST,
            ),
        );
    let configuration = datadog::Configuration::new();
    let api = TestOptimizationAPI::with_config(configuration);
    let resp = api.get_test_optimization_service_settings(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

/**
 * Get Test Optimization service settings returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.TestOptimizationApi(configuration);

const params: v2.TestOptimizationApiGetTestOptimizationServiceSettingsRequest =
  {
    body: {
      data: {
        attributes: {
          env: "prod",
          repositoryId: "github.com/datadog/shopist",
          serviceName: "shopist",
        },
        type: "test_optimization_get_service_settings_request",
      },
    },
  };

apiInstance
  .getTestOptimizationServiceSettings(params)
  .then((data: v2.TestOptimizationServiceSettingsResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" tsc "example.ts"

Update Test Optimization service settings

v2 (latest)

PATCH https://api.ap1.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.ap2.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.datadoghq.eu/api/v2/ci/test-optimization/settings/servicehttps://api.ddog-gov.com/api/v2/ci/test-optimization/settings/servicehttps://api.us2.ddog-gov.com/api/v2/ci/test-optimization/settings/servicehttps://api.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.us3.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.us5.datadoghq.com/api/v2/ci/test-optimization/settings/service

개요

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. This endpoint requires the test_optimization_settings_write permission.

OAuth apps require the test_optimization_settings_write authorization scope to access this endpoint.

요청

Body Data (required)

Expand All

항목

유형

설명

data [required]

object

Data object for update service settings request.

{
  "data": {
    "attributes": {
      "auto_test_retries_enabled": false,
      "code_coverage_enabled": false,
      "early_flake_detection_enabled": false,
      "env": "prod",
      "failed_test_replay_enabled": false,
      "pr_comments_enabled": true,
      "repository_id": "github.com/datadog/shopist",
      "service_name": "shopist",
      "test_impact_analysis_enabled": false
    },
    "type": "test_optimization_update_service_settings_request"
  }
}

응답

Response object containing Test Optimization service settings.

Expand All

항목

유형

설명

data

object

Data object for Test Optimization service settings response.

{
  "data": {
    "attributes": {
      "auto_test_retries_enabled": false,
      "code_coverage_enabled": false,
      "early_flake_detection_enabled": false,
      "env": "prod",
      "failed_test_replay_enabled": false,
      "pr_comments_enabled": true,
      "repository_id": "github.com/datadog/shopist",
      "service_name": "shopist",
      "test_impact_analysis_enabled": false
    },
    "id": "github.com/datadog/shopist::shopist::prod",
    "type": "test_optimization_service_settings"
  }
}

Bad Request

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Authorized

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Found

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Too many requests

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

코드 사례

                  ## default
# 

# Curl command
curl -X PATCH "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/ci/test-optimization/settings/service" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "auto_test_retries_enabled": false,
      "code_coverage_enabled": false,
      "early_flake_detection_enabled": false,
      "env": "prod",
      "failed_test_replay_enabled": false,
      "pr_comments_enabled": true,
      "repository_id": "github.com/datadog/test-service",
      "service_name": "test-service",
      "test_impact_analysis_enabled": false
    },
    "type": "test_optimization_update_service_settings_request"
  }
}
EOF

                

"""
Update Test Optimization service settings returns "OK" response
"""

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.test_optimization_api import TestOptimizationApi
from datadog_api_client.v2.model.test_optimization_update_service_settings_request import (
    TestOptimizationUpdateServiceSettingsRequest,
)
from datadog_api_client.v2.model.test_optimization_update_service_settings_request_attributes import (
    TestOptimizationUpdateServiceSettingsRequestAttributes,
)
from datadog_api_client.v2.model.test_optimization_update_service_settings_request_data import (
    TestOptimizationUpdateServiceSettingsRequestData,
)
from datadog_api_client.v2.model.test_optimization_update_service_settings_request_data_type import (
    TestOptimizationUpdateServiceSettingsRequestDataType,
)

body = TestOptimizationUpdateServiceSettingsRequest(
    data=TestOptimizationUpdateServiceSettingsRequestData(
        attributes=TestOptimizationUpdateServiceSettingsRequestAttributes(
            auto_test_retries_enabled=False,
            code_coverage_enabled=False,
            early_flake_detection_enabled=False,
            env="prod",
            failed_test_replay_enabled=False,
            pr_comments_enabled=True,
            repository_id="github.com/datadog/shopist",
            service_name="shopist",
            test_impact_analysis_enabled=False,
        ),
        type=TestOptimizationUpdateServiceSettingsRequestDataType.TEST_OPTIMIZATION_UPDATE_SERVICE_SETTINGS_REQUEST,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = TestOptimizationApi(api_client)
    response = api_instance.update_test_optimization_service_settings(body=body)

    print(response)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" python3 "example.py"

# Update Test Optimization service settings returns "OK" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::TestOptimizationAPI.new

body = DatadogAPIClient::V2::TestOptimizationUpdateServiceSettingsRequest.new({
  data: DatadogAPIClient::V2::TestOptimizationUpdateServiceSettingsRequestData.new({
    attributes: DatadogAPIClient::V2::TestOptimizationUpdateServiceSettingsRequestAttributes.new({
      auto_test_retries_enabled: false,
      code_coverage_enabled: false,
      early_flake_detection_enabled: false,
      env: "prod",
      failed_test_replay_enabled: false,
      pr_comments_enabled: true,
      repository_id: "github.com/datadog/shopist",
      service_name: "shopist",
      test_impact_analysis_enabled: false,
    }),
    type: DatadogAPIClient::V2::TestOptimizationUpdateServiceSettingsRequestDataType::TEST_OPTIMIZATION_UPDATE_SERVICE_SETTINGS_REQUEST,
  }),
})
p api_instance.update_test_optimization_service_settings(body)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" rb "example.rb"

// Update Test Optimization service settings returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	body := datadogV2.TestOptimizationUpdateServiceSettingsRequest{
		Data: datadogV2.TestOptimizationUpdateServiceSettingsRequestData{
			Attributes: datadogV2.TestOptimizationUpdateServiceSettingsRequestAttributes{
				AutoTestRetriesEnabled:     datadog.PtrBool(false),
				CodeCoverageEnabled:        datadog.PtrBool(false),
				EarlyFlakeDetectionEnabled: datadog.PtrBool(false),
				Env:                        datadog.PtrString("prod"),
				FailedTestReplayEnabled:    datadog.PtrBool(false),
				PrCommentsEnabled:          datadog.PtrBool(true),
				RepositoryId:               "github.com/datadog/shopist",
				ServiceName:                "shopist",
				TestImpactAnalysisEnabled:  datadog.PtrBool(false),
			},
			Type: datadogV2.TESTOPTIMIZATIONUPDATESERVICESETTINGSREQUESTDATATYPE_TEST_OPTIMIZATION_UPDATE_SERVICE_SETTINGS_REQUEST,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewTestOptimizationApi(apiClient)
	resp, r, err := api.UpdateTestOptimizationServiceSettings(ctx, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `TestOptimizationApi.UpdateTestOptimizationServiceSettings`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `TestOptimizationApi.UpdateTestOptimizationServiceSettings`:\n%s\n", responseContent)
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" go run "main.go"

// Update Test Optimization service settings returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.TestOptimizationApi;
import com.datadog.api.client.v2.model.TestOptimizationServiceSettingsResponse;
import com.datadog.api.client.v2.model.TestOptimizationUpdateServiceSettingsRequest;
import com.datadog.api.client.v2.model.TestOptimizationUpdateServiceSettingsRequestAttributes;
import com.datadog.api.client.v2.model.TestOptimizationUpdateServiceSettingsRequestData;
import com.datadog.api.client.v2.model.TestOptimizationUpdateServiceSettingsRequestDataType;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    TestOptimizationApi apiInstance = new TestOptimizationApi(defaultClient);

    TestOptimizationUpdateServiceSettingsRequest body =
        new TestOptimizationUpdateServiceSettingsRequest()
            .data(
                new TestOptimizationUpdateServiceSettingsRequestData()
                    .attributes(
                        new TestOptimizationUpdateServiceSettingsRequestAttributes()
                            .autoTestRetriesEnabled(false)
                            .codeCoverageEnabled(false)
                            .earlyFlakeDetectionEnabled(false)
                            .env("prod")
                            .failedTestReplayEnabled(false)
                            .prCommentsEnabled(true)
                            .repositoryId("github.com/datadog/shopist")
                            .serviceName("shopist")
                            .testImpactAnalysisEnabled(false))
                    .type(
                        TestOptimizationUpdateServiceSettingsRequestDataType
                            .TEST_OPTIMIZATION_UPDATE_SERVICE_SETTINGS_REQUEST));

    try {
      TestOptimizationServiceSettingsResponse result =
          apiInstance.updateTestOptimizationServiceSettings(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println(
          "Exception when calling TestOptimizationApi#updateTestOptimizationServiceSettings");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

Instructions

First install the library and its dependencies and then save the example to Example.java and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" java "Example.java"

// Update Test Optimization service settings returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_test_optimization::TestOptimizationAPI;
use datadog_api_client::datadogV2::model::TestOptimizationUpdateServiceSettingsRequest;
use datadog_api_client::datadogV2::model::TestOptimizationUpdateServiceSettingsRequestAttributes;
use datadog_api_client::datadogV2::model::TestOptimizationUpdateServiceSettingsRequestData;
use datadog_api_client::datadogV2::model::TestOptimizationUpdateServiceSettingsRequestDataType;

#[tokio::main]
async fn main() {
    let body =
        TestOptimizationUpdateServiceSettingsRequest::new(
            TestOptimizationUpdateServiceSettingsRequestData::new(
                TestOptimizationUpdateServiceSettingsRequestAttributes::new(
                    "github.com/datadog/shopist".to_string(),
                    "shopist".to_string(),
                )
                    .auto_test_retries_enabled(false)
                    .code_coverage_enabled(false)
                    .early_flake_detection_enabled(false)
                    .env("prod".to_string())
                    .failed_test_replay_enabled(false)
                    .pr_comments_enabled(true)
                    .test_impact_analysis_enabled(false),
                TestOptimizationUpdateServiceSettingsRequestDataType
                ::TEST_OPTIMIZATION_UPDATE_SERVICE_SETTINGS_REQUEST,
            ),
        );
    let configuration = datadog::Configuration::new();
    let api = TestOptimizationAPI::with_config(configuration);
    let resp = api.update_test_optimization_service_settings(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

/**
 * Update Test Optimization service settings returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.TestOptimizationApi(configuration);

const params: v2.TestOptimizationApiUpdateTestOptimizationServiceSettingsRequest =
  {
    body: {
      data: {
        attributes: {
          autoTestRetriesEnabled: false,
          codeCoverageEnabled: false,
          earlyFlakeDetectionEnabled: false,
          env: "prod",
          failedTestReplayEnabled: false,
          prCommentsEnabled: true,
          repositoryId: "github.com/datadog/shopist",
          serviceName: "shopist",
          testImpactAnalysisEnabled: false,
        },
        type: "test_optimization_update_service_settings_request",
      },
    },
  };

apiInstance
  .updateTestOptimizationServiceSettings(params)
  .then((data: v2.TestOptimizationServiceSettingsResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" tsc "example.ts"

Delete Test Optimization service settings

v2 (latest)

DELETE https://api.ap1.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.ap2.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.datadoghq.eu/api/v2/ci/test-optimization/settings/servicehttps://api.ddog-gov.com/api/v2/ci/test-optimization/settings/servicehttps://api.us2.ddog-gov.com/api/v2/ci/test-optimization/settings/servicehttps://api.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.us3.datadoghq.com/api/v2/ci/test-optimization/settings/servicehttps://api.us5.datadoghq.com/api/v2/ci/test-optimization/settings/service

개요

Delete Test Optimization settings for a specific service identified by repository, service name, and environment. This endpoint requires the test_optimization_settings_write permission.

OAuth apps require the test_optimization_settings_write authorization scope to access this endpoint.

요청

Body Data (required)

Expand All

항목

유형

설명

data [required]

object

Data object for delete service settings request.

{
  "data": {
    "attributes": {
      "env": "prod",
      "repository_id": "github.com/datadog/shopist",
      "service_name": "shopist"
    },
    "type": "test_optimization_delete_service_settings_request"
  }
}

응답

No Content

Bad Request

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Authorized

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Found

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Too many requests

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

코드 사례

                  ## default
# 

# Curl command
curl -X DELETE "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/ci/test-optimization/settings/service" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "env": "prod",
      "repository_id": "github.com/datadog/test-service",
      "service_name": "test-service"
    },
    "type": "test_optimization_delete_service_settings_request"
  }
}
EOF

                

"""
Delete Test Optimization service settings returns "No Content" response
"""

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.test_optimization_api import TestOptimizationApi
from datadog_api_client.v2.model.test_optimization_delete_service_settings_request import (
    TestOptimizationDeleteServiceSettingsRequest,
)
from datadog_api_client.v2.model.test_optimization_delete_service_settings_request_attributes import (
    TestOptimizationDeleteServiceSettingsRequestAttributes,
)
from datadog_api_client.v2.model.test_optimization_delete_service_settings_request_data import (
    TestOptimizationDeleteServiceSettingsRequestData,
)
from datadog_api_client.v2.model.test_optimization_delete_service_settings_request_data_type import (
    TestOptimizationDeleteServiceSettingsRequestDataType,
)

body = TestOptimizationDeleteServiceSettingsRequest(
    data=TestOptimizationDeleteServiceSettingsRequestData(
        attributes=TestOptimizationDeleteServiceSettingsRequestAttributes(
            env="prod",
            repository_id="github.com/datadog/shopist",
            service_name="shopist",
        ),
        type=TestOptimizationDeleteServiceSettingsRequestDataType.TEST_OPTIMIZATION_DELETE_SERVICE_SETTINGS_REQUEST,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = TestOptimizationApi(api_client)
    api_instance.delete_test_optimization_service_settings(body=body)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" python3 "example.py"

# Delete Test Optimization service settings returns "No Content" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::TestOptimizationAPI.new

body = DatadogAPIClient::V2::TestOptimizationDeleteServiceSettingsRequest.new({
  data: DatadogAPIClient::V2::TestOptimizationDeleteServiceSettingsRequestData.new({
    attributes: DatadogAPIClient::V2::TestOptimizationDeleteServiceSettingsRequestAttributes.new({
      env: "prod",
      repository_id: "github.com/datadog/shopist",
      service_name: "shopist",
    }),
    type: DatadogAPIClient::V2::TestOptimizationDeleteServiceSettingsRequestDataType::TEST_OPTIMIZATION_DELETE_SERVICE_SETTINGS_REQUEST,
  }),
})
api_instance.delete_test_optimization_service_settings(body)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" rb "example.rb"

// Delete Test Optimization service settings returns "No Content" response

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	body := datadogV2.TestOptimizationDeleteServiceSettingsRequest{
		Data: datadogV2.TestOptimizationDeleteServiceSettingsRequestData{
			Attributes: datadogV2.TestOptimizationDeleteServiceSettingsRequestAttributes{
				Env:          datadog.PtrString("prod"),
				RepositoryId: "github.com/datadog/shopist",
				ServiceName:  "shopist",
			},
			Type: datadogV2.TESTOPTIMIZATIONDELETESERVICESETTINGSREQUESTDATATYPE_TEST_OPTIMIZATION_DELETE_SERVICE_SETTINGS_REQUEST,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewTestOptimizationApi(apiClient)
	r, err := api.DeleteTestOptimizationServiceSettings(ctx, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `TestOptimizationApi.DeleteTestOptimizationServiceSettings`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" go run "main.go"

// Delete Test Optimization service settings returns "No Content" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.TestOptimizationApi;
import com.datadog.api.client.v2.model.TestOptimizationDeleteServiceSettingsRequest;
import com.datadog.api.client.v2.model.TestOptimizationDeleteServiceSettingsRequestAttributes;
import com.datadog.api.client.v2.model.TestOptimizationDeleteServiceSettingsRequestData;
import com.datadog.api.client.v2.model.TestOptimizationDeleteServiceSettingsRequestDataType;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    TestOptimizationApi apiInstance = new TestOptimizationApi(defaultClient);

    TestOptimizationDeleteServiceSettingsRequest body =
        new TestOptimizationDeleteServiceSettingsRequest()
            .data(
                new TestOptimizationDeleteServiceSettingsRequestData()
                    .attributes(
                        new TestOptimizationDeleteServiceSettingsRequestAttributes()
                            .env("prod")
                            .repositoryId("github.com/datadog/shopist")
                            .serviceName("shopist"))
                    .type(
                        TestOptimizationDeleteServiceSettingsRequestDataType
                            .TEST_OPTIMIZATION_DELETE_SERVICE_SETTINGS_REQUEST));

    try {
      apiInstance.deleteTestOptimizationServiceSettings(body);
    } catch (ApiException e) {
      System.err.println(
          "Exception when calling TestOptimizationApi#deleteTestOptimizationServiceSettings");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

Instructions

First install the library and its dependencies and then save the example to Example.java and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" java "Example.java"

// Delete Test Optimization service settings returns "No Content" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_test_optimization::TestOptimizationAPI;
use datadog_api_client::datadogV2::model::TestOptimizationDeleteServiceSettingsRequest;
use datadog_api_client::datadogV2::model::TestOptimizationDeleteServiceSettingsRequestAttributes;
use datadog_api_client::datadogV2::model::TestOptimizationDeleteServiceSettingsRequestData;
use datadog_api_client::datadogV2::model::TestOptimizationDeleteServiceSettingsRequestDataType;

#[tokio::main]
async fn main() {
    let body =
        TestOptimizationDeleteServiceSettingsRequest::new(
            TestOptimizationDeleteServiceSettingsRequestData::new(
                TestOptimizationDeleteServiceSettingsRequestAttributes::new(
                    "github.com/datadog/shopist".to_string(),
                    "shopist".to_string(),
                ).env("prod".to_string()),
                TestOptimizationDeleteServiceSettingsRequestDataType
                ::TEST_OPTIMIZATION_DELETE_SERVICE_SETTINGS_REQUEST,
            ),
        );
    let configuration = datadog::Configuration::new();
    let api = TestOptimizationAPI::with_config(configuration);
    let resp = api.delete_test_optimization_service_settings(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

/**
 * Delete Test Optimization service settings returns "No Content" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.TestOptimizationApi(configuration);

const params: v2.TestOptimizationApiDeleteTestOptimizationServiceSettingsRequest =
  {
    body: {
      data: {
        attributes: {
          env: "prod",
          repositoryId: "github.com/datadog/shopist",
          serviceName: "shopist",
        },
        type: "test_optimization_delete_service_settings_request",
      },
    },
  };

apiInstance
  .deleteTestOptimizationServiceSettings(params)
  .then((data: any) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" tsc "example.ts"

Get Flaky Tests Management policies

v2 (latest)

POST https://api.ap1.datadoghq.com/api/v2/ci/test-optimization/settings/policieshttps://api.ap2.datadoghq.com/api/v2/ci/test-optimization/settings/policieshttps://api.datadoghq.eu/api/v2/ci/test-optimization/settings/policieshttps://api.ddog-gov.com/api/v2/ci/test-optimization/settings/policieshttps://api.us2.ddog-gov.com/api/v2/ci/test-optimization/settings/policieshttps://api.datadoghq.com/api/v2/ci/test-optimization/settings/policieshttps://api.us3.datadoghq.com/api/v2/ci/test-optimization/settings/policieshttps://api.us5.datadoghq.com/api/v2/ci/test-optimization/settings/policies

개요

Retrieve Flaky Tests Management repository-level policies for the given repository. This endpoint requires the test_optimization_read permission.

OAuth apps require the test_optimization_read authorization scope to access this endpoint.

요청

Body Data (required)

Expand All

항목

유형

설명

data [required]

object

Data object for get Flaky Tests Management policies request.

{
  "data": {
    "attributes": {
      "repository_id": "github.com/datadog/shopist"
    },
    "type": "test_optimization_get_flaky_tests_management_policies_request"
  }
}

응답

Response object containing Flaky Tests Management policies for a repository.

Expand All

항목

유형

설명

data

object

Data object for Flaky Tests Management policies response.

attributes

object

Attributes of the Flaky Tests Management policies for a repository.

{
  "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"
    },
    "id": "github.com/datadog/shopist",
    "type": "test_optimization_flaky_tests_management_policies"
  }
}

Bad Request

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Authorized

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Found

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Too many requests

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

코드 사례

                  ## default
# 

# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/ci/test-optimization/settings/policies" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "repository_id": "github.com/example-org/example-repo"
    },
    "type": "test_optimization_get_flaky_tests_management_policies_request"
  }
}
EOF

                

"""
Get Flaky Tests Management policies returns "OK" response
"""

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.test_optimization_api import TestOptimizationApi
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_get_request import (
    TestOptimizationFlakyTestsManagementPoliciesGetRequest,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_get_request_attributes import (
    TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_get_request_data import (
    TestOptimizationFlakyTestsManagementPoliciesGetRequestData,
)
from datadog_api_client.v2.model.test_optimization_get_flaky_tests_management_policies_request_data_type import (
    TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType,
)

body = TestOptimizationFlakyTestsManagementPoliciesGetRequest(
    data=TestOptimizationFlakyTestsManagementPoliciesGetRequestData(
        attributes=TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes(
            repository_id="github.com/datadog/shopist",
        ),
        type=TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType.TEST_OPTIMIZATION_GET_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = TestOptimizationApi(api_client)
    response = api_instance.get_flaky_tests_management_policies(body=body)

    print(response)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" python3 "example.py"

# Get Flaky Tests Management policies returns "OK" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::TestOptimizationAPI.new

body = DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesGetRequest.new({
  data: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesGetRequestData.new({
    attributes: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes.new({
      repository_id: "github.com/datadog/shopist",
    }),
    type: DatadogAPIClient::V2::TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType::TEST_OPTIMIZATION_GET_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST,
  }),
})
p api_instance.get_flaky_tests_management_policies(body)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" rb "example.rb"

// Get Flaky Tests Management policies returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	body := datadogV2.TestOptimizationFlakyTestsManagementPoliciesGetRequest{
		Data: datadogV2.TestOptimizationFlakyTestsManagementPoliciesGetRequestData{
			Attributes: datadogV2.TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes{
				RepositoryId: "github.com/datadog/shopist",
			},
			Type: datadogV2.TESTOPTIMIZATIONGETFLAKYTESTSMANAGEMENTPOLICIESREQUESTDATATYPE_TEST_OPTIMIZATION_GET_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewTestOptimizationApi(apiClient)
	resp, r, err := api.GetFlakyTestsManagementPolicies(ctx, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `TestOptimizationApi.GetFlakyTestsManagementPolicies`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `TestOptimizationApi.GetFlakyTestsManagementPolicies`:\n%s\n", responseContent)
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" go run "main.go"

// Get Flaky Tests Management policies returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.TestOptimizationApi;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesGetRequest;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesGetRequestData;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesResponse;
import com.datadog.api.client.v2.model.TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    TestOptimizationApi apiInstance = new TestOptimizationApi(defaultClient);

    TestOptimizationFlakyTestsManagementPoliciesGetRequest body =
        new TestOptimizationFlakyTestsManagementPoliciesGetRequest()
            .data(
                new TestOptimizationFlakyTestsManagementPoliciesGetRequestData()
                    .attributes(
                        new TestOptimizationFlakyTestsManagementPoliciesGetRequestAttributes()
                            .repositoryId("github.com/datadog/shopist"))
                    .type(
                        TestOptimizationGetFlakyTestsManagementPoliciesRequestDataType
                            .TEST_OPTIMIZATION_GET_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST));

    try {
      TestOptimizationFlakyTestsManagementPoliciesResponse result =
          apiInstance.getFlakyTestsManagementPolicies(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println(
          "Exception when calling TestOptimizationApi#getFlakyTestsManagementPolicies");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

Instructions

First install the library and its dependencies and then save the example to Example.java and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" java "Example.java"

// 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 configuration = datadog::Configuration::new();
    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());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

/**
 * Get Flaky Tests Management policies returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.TestOptimizationApi(configuration);

const params: v2.TestOptimizationApiGetFlakyTestsManagementPoliciesRequest = {
  body: {
    data: {
      attributes: {
        repositoryId: "github.com/datadog/shopist",
      },
      type: "test_optimization_get_flaky_tests_management_policies_request",
    },
  },
};

apiInstance
  .getFlakyTestsManagementPolicies(params)
  .then((data: v2.TestOptimizationFlakyTestsManagementPoliciesResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" tsc "example.ts"

Update Flaky Tests Management policies

v2 (latest)

PATCH https://api.ap1.datadoghq.com/api/v2/ci/test-optimization/settings/policieshttps://api.ap2.datadoghq.com/api/v2/ci/test-optimization/settings/policieshttps://api.datadoghq.eu/api/v2/ci/test-optimization/settings/policieshttps://api.ddog-gov.com/api/v2/ci/test-optimization/settings/policieshttps://api.us2.ddog-gov.com/api/v2/ci/test-optimization/settings/policieshttps://api.datadoghq.com/api/v2/ci/test-optimization/settings/policieshttps://api.us3.datadoghq.com/api/v2/ci/test-optimization/settings/policieshttps://api.us5.datadoghq.com/api/v2/ci/test-optimization/settings/policies

개요

Partially update Flaky Tests Management repository-level policies for the given repository. Only provided policy blocks are updated; omitted blocks are left unchanged. This endpoint requires the test_optimization_settings_write permission.

OAuth apps require the test_optimization_settings_write authorization scope to access this endpoint.

요청

Body Data (required)

Expand All

항목

유형

설명

data [required]

object

Data object for update Flaky Tests Management policies request.

attributes [required]

object

Attributes for updating Flaky Tests Management policies. Only provided policy blocks are updated; omitted blocks are left unchanged.

{
  "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"
  }
}

응답

Response object containing Flaky Tests Management policies for a repository.

Expand All

항목

유형

설명

data

object

Data object for Flaky Tests Management policies response.

attributes

object

Attributes of the Flaky Tests Management policies for a repository.

{
  "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"
    },
    "id": "github.com/datadog/shopist",
    "type": "test_optimization_flaky_tests_management_policies"
  }
}

Bad Request

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Authorized

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Found

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Too many requests

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

코드 사례

                  ## default
# 

# Curl command
curl -X PATCH "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/ci/test-optimization/settings/policies" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "attempt_to_fix": {
        "retries": 3
      },
      "disabled": {
        "enabled": false
      },
      "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/example-org/example-repo"
    },
    "type": "test_optimization_update_flaky_tests_management_policies_request"
  }
}
EOF

                

"""
Update Flaky Tests Management policies returns "OK" response
"""

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.test_optimization_api import TestOptimizationApi
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_attempt_to_fix import (
    TestOptimizationFlakyTestsManagementPoliciesAttemptToFix,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_auto_disable_rule import (
    TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_auto_quarantine_rule import (
    TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_branch_rule import (
    TestOptimizationFlakyTestsManagementPoliciesBranchRule,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_disabled import (
    TestOptimizationFlakyTestsManagementPoliciesDisabled,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_disabled_failure_rate_rule import (
    TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_disabled_status import (
    TestOptimizationFlakyTestsManagementPoliciesDisabledStatus,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_quarantined import (
    TestOptimizationFlakyTestsManagementPoliciesQuarantined,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_quarantined_failure_rate_rule import (
    TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_update_request import (
    TestOptimizationFlakyTestsManagementPoliciesUpdateRequest,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_update_request_attributes import (
    TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes,
)
from datadog_api_client.v2.model.test_optimization_flaky_tests_management_policies_update_request_data import (
    TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData,
)
from datadog_api_client.v2.model.test_optimization_update_flaky_tests_management_policies_request_data_type import (
    TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType,
)

body = TestOptimizationFlakyTestsManagementPoliciesUpdateRequest(
    data=TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData(
        attributes=TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes(
            attempt_to_fix=TestOptimizationFlakyTestsManagementPoliciesAttemptToFix(
                retries=3,
            ),
            disabled=TestOptimizationFlakyTestsManagementPoliciesDisabled(
                auto_disable_rule=TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule(
                    enabled=False,
                    status=TestOptimizationFlakyTestsManagementPoliciesDisabledStatus.ACTIVE,
                    window_seconds=3600,
                ),
                branch_rule=TestOptimizationFlakyTestsManagementPoliciesBranchRule(
                    branches=[
                        "main",
                    ],
                    enabled=True,
                    excluded_branches=[],
                    excluded_test_services=[],
                ),
                enabled=False,
                failure_rate_rule=TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule(
                    branches=[],
                    enabled=False,
                    min_runs=10,
                    status=TestOptimizationFlakyTestsManagementPoliciesDisabledStatus.ACTIVE,
                    threshold=0.5,
                ),
            ),
            quarantined=TestOptimizationFlakyTestsManagementPoliciesQuarantined(
                auto_quarantine_rule=TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule(
                    enabled=True,
                    window_seconds=3600,
                ),
                branch_rule=TestOptimizationFlakyTestsManagementPoliciesBranchRule(
                    branches=[
                        "main",
                    ],
                    enabled=True,
                    excluded_branches=[],
                    excluded_test_services=[],
                ),
                enabled=True,
                failure_rate_rule=TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule(
                    branches=[
                        "main",
                    ],
                    enabled=True,
                    min_runs=10,
                    threshold=0.5,
                ),
            ),
            repository_id="github.com/datadog/shopist",
        ),
        type=TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType.TEST_OPTIMIZATION_UPDATE_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = TestOptimizationApi(api_client)
    response = api_instance.update_flaky_tests_management_policies(body=body)

    print(response)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" python3 "example.py"

# Update Flaky Tests Management policies returns "OK" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::TestOptimizationAPI.new

body = DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesUpdateRequest.new({
  data: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData.new({
    attributes: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes.new({
      attempt_to_fix: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesAttemptToFix.new({
        retries: 3,
      }),
      disabled: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesDisabled.new({
        auto_disable_rule: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule.new({
          enabled: false,
          status: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesDisabledStatus::ACTIVE,
          window_seconds: 3600,
        }),
        branch_rule: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesBranchRule.new({
          branches: [
            "main",
          ],
          enabled: true,
          excluded_branches: [],
          excluded_test_services: [],
        }),
        enabled: false,
        failure_rate_rule: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule.new({
          branches: [],
          enabled: false,
          min_runs: 10,
          status: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesDisabledStatus::ACTIVE,
          threshold: 0.5,
        }),
      }),
      quarantined: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesQuarantined.new({
        auto_quarantine_rule: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule.new({
          enabled: true,
          window_seconds: 3600,
        }),
        branch_rule: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesBranchRule.new({
          branches: [
            "main",
          ],
          enabled: true,
          excluded_branches: [],
          excluded_test_services: [],
        }),
        enabled: true,
        failure_rate_rule: DatadogAPIClient::V2::TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule.new({
          branches: [
            "main",
          ],
          enabled: true,
          min_runs: 10,
          threshold: 0.5,
        }),
      }),
      repository_id: "github.com/datadog/shopist",
    }),
    type: DatadogAPIClient::V2::TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType::TEST_OPTIMIZATION_UPDATE_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST,
  }),
})
p api_instance.update_flaky_tests_management_policies(body)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" rb "example.rb"

// Update Flaky Tests Management policies returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	body := datadogV2.TestOptimizationFlakyTestsManagementPoliciesUpdateRequest{
		Data: datadogV2.TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData{
			Attributes: datadogV2.TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes{
				AttemptToFix: &datadogV2.TestOptimizationFlakyTestsManagementPoliciesAttemptToFix{
					Retries: datadog.PtrInt64(3),
				},
				Disabled: &datadogV2.TestOptimizationFlakyTestsManagementPoliciesDisabled{
					AutoDisableRule: &datadogV2.TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule{
						Enabled:       datadog.PtrBool(false),
						Status:        datadogV2.TESTOPTIMIZATIONFLAKYTESTSMANAGEMENTPOLICIESDISABLEDSTATUS_ACTIVE.Ptr(),
						WindowSeconds: datadog.PtrInt64(3600),
					},
					BranchRule: &datadogV2.TestOptimizationFlakyTestsManagementPoliciesBranchRule{
						Branches: []string{
							"main",
						},
						Enabled:              datadog.PtrBool(true),
						ExcludedBranches:     []string{},
						ExcludedTestServices: []string{},
					},
					Enabled: datadog.PtrBool(false),
					FailureRateRule: &datadogV2.TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule{
						Branches:  []string{},
						Enabled:   datadog.PtrBool(false),
						MinRuns:   datadog.PtrInt64(10),
						Status:    datadogV2.TESTOPTIMIZATIONFLAKYTESTSMANAGEMENTPOLICIESDISABLEDSTATUS_ACTIVE.Ptr(),
						Threshold: datadog.PtrFloat64(0.5),
					},
				},
				Quarantined: &datadogV2.TestOptimizationFlakyTestsManagementPoliciesQuarantined{
					AutoQuarantineRule: &datadogV2.TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule{
						Enabled:       datadog.PtrBool(true),
						WindowSeconds: datadog.PtrInt64(3600),
					},
					BranchRule: &datadogV2.TestOptimizationFlakyTestsManagementPoliciesBranchRule{
						Branches: []string{
							"main",
						},
						Enabled:              datadog.PtrBool(true),
						ExcludedBranches:     []string{},
						ExcludedTestServices: []string{},
					},
					Enabled: datadog.PtrBool(true),
					FailureRateRule: &datadogV2.TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule{
						Branches: []string{
							"main",
						},
						Enabled:   datadog.PtrBool(true),
						MinRuns:   datadog.PtrInt64(10),
						Threshold: datadog.PtrFloat64(0.5),
					},
				},
				RepositoryId: "github.com/datadog/shopist",
			},
			Type: datadogV2.TESTOPTIMIZATIONUPDATEFLAKYTESTSMANAGEMENTPOLICIESREQUESTDATATYPE_TEST_OPTIMIZATION_UPDATE_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewTestOptimizationApi(apiClient)
	resp, r, err := api.UpdateFlakyTestsManagementPolicies(ctx, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `TestOptimizationApi.UpdateFlakyTestsManagementPolicies`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `TestOptimizationApi.UpdateFlakyTestsManagementPolicies`:\n%s\n", responseContent)
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" go run "main.go"

// Update Flaky Tests Management policies returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.TestOptimizationApi;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesAttemptToFix;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesBranchRule;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesDisabled;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesDisabledStatus;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesQuarantined;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesResponse;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesUpdateRequest;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes;
import com.datadog.api.client.v2.model.TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData;
import com.datadog.api.client.v2.model.TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType;
import java.util.Collections;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    TestOptimizationApi apiInstance = new TestOptimizationApi(defaultClient);

    TestOptimizationFlakyTestsManagementPoliciesUpdateRequest body =
        new TestOptimizationFlakyTestsManagementPoliciesUpdateRequest()
            .data(
                new TestOptimizationFlakyTestsManagementPoliciesUpdateRequestData()
                    .attributes(
                        new TestOptimizationFlakyTestsManagementPoliciesUpdateRequestAttributes()
                            .attemptToFix(
                                new TestOptimizationFlakyTestsManagementPoliciesAttemptToFix()
                                    .retries(3L))
                            .disabled(
                                new TestOptimizationFlakyTestsManagementPoliciesDisabled()
                                    .autoDisableRule(
                                        new TestOptimizationFlakyTestsManagementPoliciesAutoDisableRule()
                                            .enabled(false)
                                            .status(
                                                TestOptimizationFlakyTestsManagementPoliciesDisabledStatus
                                                    .ACTIVE)
                                            .windowSeconds(3600L))
                                    .branchRule(
                                        new TestOptimizationFlakyTestsManagementPoliciesBranchRule()
                                            .branches(Collections.singletonList("main"))
                                            .enabled(true))
                                    .enabled(false)
                                    .failureRateRule(
                                        new TestOptimizationFlakyTestsManagementPoliciesDisabledFailureRateRule()
                                            .enabled(false)
                                            .minRuns(10L)
                                            .status(
                                                TestOptimizationFlakyTestsManagementPoliciesDisabledStatus
                                                    .ACTIVE)
                                            .threshold(0.5)))
                            .quarantined(
                                new TestOptimizationFlakyTestsManagementPoliciesQuarantined()
                                    .autoQuarantineRule(
                                        new TestOptimizationFlakyTestsManagementPoliciesAutoQuarantineRule()
                                            .enabled(true)
                                            .windowSeconds(3600L))
                                    .branchRule(
                                        new TestOptimizationFlakyTestsManagementPoliciesBranchRule()
                                            .branches(Collections.singletonList("main"))
                                            .enabled(true))
                                    .enabled(true)
                                    .failureRateRule(
                                        new TestOptimizationFlakyTestsManagementPoliciesQuarantinedFailureRateRule()
                                            .branches(Collections.singletonList("main"))
                                            .enabled(true)
                                            .minRuns(10L)
                                            .threshold(0.5)))
                            .repositoryId("github.com/datadog/shopist"))
                    .type(
                        TestOptimizationUpdateFlakyTestsManagementPoliciesRequestDataType
                            .TEST_OPTIMIZATION_UPDATE_FLAKY_TESTS_MANAGEMENT_POLICIES_REQUEST));

    try {
      TestOptimizationFlakyTestsManagementPoliciesResponse result =
          apiInstance.updateFlakyTestsManagementPolicies(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println(
          "Exception when calling TestOptimizationApi#updateFlakyTestsManagementPolicies");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

Instructions

First install the library and its dependencies and then save the example to Example.java and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" java "Example.java"

// 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 configuration = datadog::Configuration::new();
    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());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

/**
 * Update Flaky Tests Management policies returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.TestOptimizationApi(configuration);

const params: v2.TestOptimizationApiUpdateFlakyTestsManagementPoliciesRequest =
  {
    body: {
      data: {
        attributes: {
          attemptToFix: {
            retries: 3,
          },
          disabled: {
            autoDisableRule: {
              enabled: false,
              status: "active",
              windowSeconds: 3600,
            },
            branchRule: {
              branches: ["main"],
              enabled: true,
              excludedBranches: [],
              excludedTestServices: [],
            },
            enabled: false,
            failureRateRule: {
              branches: [],
              enabled: false,
              minRuns: 10,
              status: "active",
              threshold: 0.5,
            },
          },
          quarantined: {
            autoQuarantineRule: {
              enabled: true,
              windowSeconds: 3600,
            },
            branchRule: {
              branches: ["main"],
              enabled: true,
              excludedBranches: [],
              excludedTestServices: [],
            },
            enabled: true,
            failureRateRule: {
              branches: ["main"],
              enabled: true,
              minRuns: 10,
              threshold: 0.5,
            },
          },
          repositoryId: "github.com/datadog/shopist",
        },
        type: "test_optimization_update_flaky_tests_management_policies_request",
      },
    },
  };

apiInstance
  .updateFlakyTestsManagementPolicies(params)
  .then((data: v2.TestOptimizationFlakyTestsManagementPoliciesResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" tsc "example.ts"