Edit a Network Path test

"""
Edit a Network Path test returns "OK" response
"""

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.synthetics_api import SyntheticsApi
from datadog_api_client.v2.model.synthetics_network_assertion_latency import SyntheticsNetworkAssertionLatency
from datadog_api_client.v2.model.synthetics_network_assertion_latency_type import SyntheticsNetworkAssertionLatencyType
from datadog_api_client.v2.model.synthetics_network_assertion_operator import SyntheticsNetworkAssertionOperator
from datadog_api_client.v2.model.synthetics_network_assertion_property import SyntheticsNetworkAssertionProperty
from datadog_api_client.v2.model.synthetics_network_test import SyntheticsNetworkTest
from datadog_api_client.v2.model.synthetics_network_test_config import SyntheticsNetworkTestConfig
from datadog_api_client.v2.model.synthetics_network_test_edit import SyntheticsNetworkTestEdit
from datadog_api_client.v2.model.synthetics_network_test_edit_request import SyntheticsNetworkTestEditRequest
from datadog_api_client.v2.model.synthetics_network_test_request import SyntheticsNetworkTestRequest
from datadog_api_client.v2.model.synthetics_network_test_request_tcp_method import SyntheticsNetworkTestRequestTCPMethod
from datadog_api_client.v2.model.synthetics_network_test_sub_type import SyntheticsNetworkTestSubType
from datadog_api_client.v2.model.synthetics_network_test_type import SyntheticsNetworkTestType
from datadog_api_client.v2.model.synthetics_test_options import SyntheticsTestOptions
from datadog_api_client.v2.model.synthetics_test_options_monitor_options import SyntheticsTestOptionsMonitorOptions
from datadog_api_client.v2.model.synthetics_test_options_monitor_options_notification_preset_name import (
    SyntheticsTestOptionsMonitorOptionsNotificationPresetName,
)
from datadog_api_client.v2.model.synthetics_test_options_retry import SyntheticsTestOptionsRetry
from datadog_api_client.v2.model.synthetics_test_options_scheduling import SyntheticsTestOptionsScheduling
from datadog_api_client.v2.model.synthetics_test_options_scheduling_timeframe import (
    SyntheticsTestOptionsSchedulingTimeframe,
)
from datadog_api_client.v2.model.synthetics_test_pause_status import SyntheticsTestPauseStatus

body = SyntheticsNetworkTestEditRequest(
    data=SyntheticsNetworkTestEdit(
        attributes=SyntheticsNetworkTest(
            config=SyntheticsNetworkTestConfig(
                assertions=[
                    SyntheticsNetworkAssertionLatency(
                        operator=SyntheticsNetworkAssertionOperator.LESS_THAN,
                        _property=SyntheticsNetworkAssertionProperty.AVG,
                        target=500.0,
                        type=SyntheticsNetworkAssertionLatencyType.LATENCY,
                    ),
                ],
                request=SyntheticsNetworkTestRequest(
                    e2e_queries=50,
                    host="",
                    max_ttl=30,
                    port=443,
                    tcp_method=SyntheticsNetworkTestRequestTCPMethod.PREFER_SACK,
                    traceroute_queries=3,
                ),
            ),
            locations=[
                "aws:us-east-1",
                "agent:my-agent-name",
            ],
            message="Network Path test notification",
            name="Example Network Path test",
            options=SyntheticsTestOptions(
                monitor_options=SyntheticsTestOptionsMonitorOptions(
                    notification_preset_name=SyntheticsTestOptionsMonitorOptionsNotificationPresetName.SHOW_ALL,
                ),
                restricted_roles=[
                    "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
                ],
                retry=SyntheticsTestOptionsRetry(),
                scheduling=SyntheticsTestOptionsScheduling(
                    timeframes=[
                        SyntheticsTestOptionsSchedulingTimeframe(
                            day=1,
                            _from="07:00",
                            to="16:00",
                        ),
                        SyntheticsTestOptionsSchedulingTimeframe(
                            day=3,
                            _from="07:00",
                            to="16:00",
                        ),
                    ],
                    timezone="America/New_York",
                ),
            ),
            status=SyntheticsTestPauseStatus.LIVE,
            subtype=SyntheticsNetworkTestSubType.TCP,
            tags=[
                "env:production",
            ],
            type=SyntheticsNetworkTestType.NETWORK,
        ),
        type=SyntheticsNetworkTestType.NETWORK,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = SyntheticsApi(api_client)
    response = api_instance.update_synthetics_network_test(public_id="public_id", body=body)

    print(response)

# Edit a Network Path test returns "OK" response

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

body = DatadogAPIClient::V2::SyntheticsNetworkTestEditRequest.new({
  data: DatadogAPIClient::V2::SyntheticsNetworkTestEdit.new({
    attributes: DatadogAPIClient::V2::SyntheticsNetworkTest.new({
      config: DatadogAPIClient::V2::SyntheticsNetworkTestConfig.new({
        assertions: [
          DatadogAPIClient::V2::SyntheticsNetworkAssertionLatency.new({
            operator: DatadogAPIClient::V2::SyntheticsNetworkAssertionOperator::LESS_THAN,
            property: DatadogAPIClient::V2::SyntheticsNetworkAssertionProperty::AVG,
            target: 500,
            type: DatadogAPIClient::V2::SyntheticsNetworkAssertionLatencyType::LATENCY,
          }),
        ],
        request: DatadogAPIClient::V2::SyntheticsNetworkTestRequest.new({
          e2e_queries: 50,
          host: "",
          max_ttl: 30,
          port: 443,
          tcp_method: DatadogAPIClient::V2::SyntheticsNetworkTestRequestTCPMethod::PREFER_SACK,
          traceroute_queries: 3,
        }),
      }),
      locations: [
        "aws:us-east-1",
        "agent:my-agent-name",
      ],
      message: "Network Path test notification",
      name: "Example Network Path test",
      options: DatadogAPIClient::V2::SyntheticsTestOptions.new({
        monitor_options: DatadogAPIClient::V2::SyntheticsTestOptionsMonitorOptions.new({
          notification_preset_name: DatadogAPIClient::V2::SyntheticsTestOptionsMonitorOptionsNotificationPresetName::SHOW_ALL,
        }),
        restricted_roles: [
          "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
        ],
        _retry: DatadogAPIClient::V2::SyntheticsTestOptionsRetry.new({}),
        scheduling: DatadogAPIClient::V2::SyntheticsTestOptionsScheduling.new({
          timeframes: [
            DatadogAPIClient::V2::SyntheticsTestOptionsSchedulingTimeframe.new({
              day: 1,
              from: "07:00",
              to: "16:00",
            }),
            DatadogAPIClient::V2::SyntheticsTestOptionsSchedulingTimeframe.new({
              day: 3,
              from: "07:00",
              to: "16:00",
            }),
          ],
          timezone: "America/New_York",
        }),
      }),
      status: DatadogAPIClient::V2::SyntheticsTestPauseStatus::LIVE,
      subtype: DatadogAPIClient::V2::SyntheticsNetworkTestSubType::TCP,
      tags: [
        "env:production",
      ],
      type: DatadogAPIClient::V2::SyntheticsNetworkTestType::NETWORK,
    }),
    type: DatadogAPIClient::V2::SyntheticsNetworkTestType::NETWORK,
  }),
})
p api_instance.update_synthetics_network_test("public_id", body)

// Edit a Network Path test 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.SyntheticsNetworkTestEditRequest{
		Data: datadogV2.SyntheticsNetworkTestEdit{
			Attributes: datadogV2.SyntheticsNetworkTest{
				Config: datadogV2.SyntheticsNetworkTestConfig{
					Assertions: []datadogV2.SyntheticsNetworkAssertion{
						datadogV2.SyntheticsNetworkAssertion{
							SyntheticsNetworkAssertionLatency: &datadogV2.SyntheticsNetworkAssertionLatency{
								Operator: datadogV2.SYNTHETICSNETWORKASSERTIONOPERATOR_LESS_THAN,
								Property: datadogV2.SYNTHETICSNETWORKASSERTIONPROPERTY_AVG,
								Target:   500,
								Type:     datadogV2.SYNTHETICSNETWORKASSERTIONLATENCYTYPE_LATENCY,
							}},
					},
					Request: &datadogV2.SyntheticsNetworkTestRequest{
						E2eQueries:        50,
						Host:              "",
						MaxTtl:            30,
						Port:              datadog.PtrInt64(443),
						TcpMethod:         datadogV2.SYNTHETICSNETWORKTESTREQUESTTCPMETHOD_PREFER_SACK.Ptr(),
						TracerouteQueries: 3,
					},
				},
				Locations: []string{
					"aws:us-east-1",
					"agent:my-agent-name",
				},
				Message: "Network Path test notification",
				Name:    "Example Network Path test",
				Options: datadogV2.SyntheticsTestOptions{
					MonitorOptions: &datadogV2.SyntheticsTestOptionsMonitorOptions{
						NotificationPresetName: datadogV2.SYNTHETICSTESTOPTIONSMONITOROPTIONSNOTIFICATIONPRESETNAME_SHOW_ALL.Ptr(),
					},
					RestrictedRoles: []string{
						"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
					},
					Retry: &datadogV2.SyntheticsTestOptionsRetry{},
					Scheduling: &datadogV2.SyntheticsTestOptionsScheduling{
						Timeframes: []datadogV2.SyntheticsTestOptionsSchedulingTimeframe{
							{
								Day:  1,
								From: "07:00",
								To:   "16:00",
							},
							{
								Day:  3,
								From: "07:00",
								To:   "16:00",
							},
						},
						Timezone: "America/New_York",
					},
				},
				Status:  datadogV2.SYNTHETICSTESTPAUSESTATUS_LIVE.Ptr(),
				Subtype: datadogV2.SYNTHETICSNETWORKTESTSUBTYPE_TCP.Ptr(),
				Tags: []string{
					"env:production",
				},
				Type: datadogV2.SYNTHETICSNETWORKTESTTYPE_NETWORK,
			},
			Type: datadogV2.SYNTHETICSNETWORKTESTTYPE_NETWORK,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewSyntheticsApi(apiClient)
	resp, r, err := api.UpdateSyntheticsNetworkTest(ctx, "public_id", body)

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

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