datadog.SyntheticsTest

import * as pulumi from "@pulumi/pulumi";
import * as datadog from "@pulumi/datadog";

// Example Usage (Synthetics API test)
// Create a new Datadog Synthetics API/HTTP test on https://www.example.org
const testUptime = new datadog.SyntheticsTest("test_uptime", {
    name: "An Uptime test on example.org",
    type: "api",
    subtype: "http",
    status: "live",
    message: "Notify @pagerduty",
    locations: ["aws:eu-central-1"],
    tags: [
        "foo:bar",
        "foo",
        "env:test",
    ],
    requestDefinition: {
        method: "GET",
        url: "https://www.example.org",
    },
    requestHeaders: {
        "Content-Type": "application/json",
    },
    assertions: [{
        type: "statusCode",
        operator: "is",
        target: "200",
    }],
    optionsList: {
        tickEvery: 900,
        retry: {
            count: 2,
            interval: 300,
        },
        monitorOptions: {
            renotifyInterval: 120,
        },
    },
});
// Example Usage (Authenticated API test)
// Create a new Datadog Synthetics API/HTTP test on https://www.example.org
const testApi = new datadog.SyntheticsTest("test_api", {
    name: "An API test on example.org",
    type: "api",
    subtype: "http",
    status: "live",
    message: "Notify @pagerduty",
    locations: ["aws:eu-central-1"],
    tags: [
        "foo:bar",
        "foo",
        "env:test",
    ],
    requestDefinition: {
        method: "GET",
        url: "https://www.example.org",
    },
    requestHeaders: {
        "Content-Type": "application/json",
        Authentication: "Token: 1234566789",
    },
    assertions: [{
        type: "statusCode",
        operator: "is",
        target: "200",
    }],
    optionsList: {
        tickEvery: 900,
        retry: {
            count: 2,
            interval: 300,
        },
        monitorOptions: {
            renotifyInterval: 120,
        },
    },
});
// Example Usage (Synthetics SSL test)
// Create a new Datadog Synthetics API/SSL test on example.org
const testSsl = new datadog.SyntheticsTest("test_ssl", {
    name: "An API test on example.org",
    type: "api",
    subtype: "ssl",
    status: "live",
    message: "Notify @pagerduty",
    locations: ["aws:eu-central-1"],
    tags: [
        "foo:bar",
        "foo",
        "env:test",
    ],
    requestDefinition: {
        host: "example.org",
        port: "443",
    },
    assertions: [{
        type: "certificate",
        operator: "isInMoreThan",
        target: "30",
    }],
    optionsList: {
        tickEvery: 900,
        acceptSelfSigned: true,
    },
});
// Example Usage (Synthetics TCP test)
// Create a new Datadog Synthetics API/TCP test on example.org
const testTcp = new datadog.SyntheticsTest("test_tcp", {
    name: "An API test on example.org",
    type: "api",
    subtype: "tcp",
    status: "live",
    message: "Notify @pagerduty",
    locations: ["aws:eu-central-1"],
    tags: [
        "foo:bar",
        "foo",
        "env:test",
    ],
    requestDefinition: {
        host: "example.org",
        port: "443",
    },
    assertions: [{
        type: "responseTime",
        operator: "lessThan",
        target: "2000",
    }],
    configVariables: [{
        type: "global",
        name: "MY_GLOBAL_VAR",
        id: "76636cd1-82e2-4aeb-9cfe-51366a8198a2",
    }],
    optionsList: {
        tickEvery: 900,
    },
});
// Example Usage (Synthetics DNS test)
// Create a new Datadog Synthetics API/DNS test on example.org
const testDns = new datadog.SyntheticsTest("test_dns", {
    name: "An API test on example.org",
    type: "api",
    subtype: "dns",
    status: "live",
    message: "Notify @pagerduty",
    locations: ["aws:eu-central-1"],
    tags: [
        "foo:bar",
        "foo",
        "env:test",
    ],
    requestDefinition: {
        host: "example.org",
    },
    assertions: [{
        type: "recordSome",
        operator: "is",
        property: "A",
        target: "0.0.0.0",
    }],
    optionsList: {
        tickEvery: 900,
    },
});
// Example Usage (Synthetics Multistep API test)
// Create a new Datadog Synthetics Multistep API test
const testMultiStep = new datadog.SyntheticsTest("test_multi_step", {
    name: "Multistep API test",
    type: "api",
    subtype: "multi",
    status: "live",
    locations: ["aws:eu-central-1"],
    tags: [
        "foo:bar",
        "foo",
        "env:test",
    ],
    apiSteps: [
        {
            name: "An API test on example.org",
            subtype: "http",
            assertions: [{
                type: "statusCode",
                operator: "is",
                target: "200",
            }],
            requestDefinition: {
                method: "GET",
                url: "https://www.example.org",
            },
            requestHeaders: {
                "Content-Type": "application/json",
                Authentication: "Token: 1234566789",
            },
        },
        {
            name: "An API test on example.org",
            subtype: "http",
            assertions: [{
                type: "statusCode",
                operator: "is",
                target: "200",
            }],
            requestDefinition: {
                method: "GET",
                url: "http://example.org",
            },
        },
        {
            name: "A gRPC health check on example.org",
            subtype: "grpc",
            assertions: [{
                type: "statusCode",
                operator: "is",
                target: "200",
            }],
            requestDefinition: {
                host: "example.org",
                port: "443",
                callType: "healthcheck",
                service: "greeter.Greeter",
            },
        },
        {
            name: "A gRPC behavior check on example.org",
            subtype: "grpc",
            assertions: [{
                type: "statusCode",
                operator: "is",
                target: "200",
            }],
            requestDefinition: {
                host: "example.org",
                port: "443",
                callType: "unary",
                service: "greeter.Greeter",
                method: "SayHello",
                message: "{\"name\": \"John\"}",
                plainProtoFile: `syntax = "proto3";

package greeter;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}
`,
            },
        },
    ],
    optionsList: {
        tickEvery: 900,
        acceptSelfSigned: true,
    },
});
// Example Usage (Synthetics Browser test)
// Create a new Datadog Synthetics Browser test starting on https://www.example.org
const testBrowser = new datadog.SyntheticsTest("test_browser", {
    name: "A Browser test on example.org",
    type: "browser",
    status: "paused",
    message: "Notify @qa",
    deviceIds: ["laptop_large"],
    locations: ["aws:eu-central-1"],
    tags: [],
    requestDefinition: {
        method: "GET",
        url: "https://www.example.org",
    },
    browserSteps: [
        {
            name: "Check current url",
            type: "assertCurrentUrl",
            params: {
                check: "contains",
                value: "datadoghq",
            },
        },
        {
            name: "Test a downloaded file",
            type: "assertFileDownload",
            params: {
                file: JSON.stringify({
                    md5: "abcdef1234567890",
                    sizeCheck: {
                        type: "equals",
                        value: 1,
                    },
                    nameCheck: {
                        type: "contains",
                        value: ".xls",
                    },
                }),
            },
        },
    ],
    browserVariables: [
        {
            type: "text",
            name: "MY_PATTERN_VAR",
            pattern: "{{numeric(3)}}",
            example: "597",
        },
        {
            type: "email",
            name: "MY_EMAIL_VAR",
            pattern: "jd8-afe-ydv.{{ numeric(10) }}@synthetics.dtdg.co",
            example: "jd8-afe-ydv.4546132139@synthetics.dtdg.co",
        },
        {
            type: "global",
            name: "MY_GLOBAL_VAR",
            id: "76636cd1-82e2-4aeb-9cfe-51366a8198a2",
        },
    ],
    optionsList: {
        tickEvery: 3600,
    },
});
// Example Usage (Synthetics Mobile test)
// Create a new Datadog Synthetics Mobile test starting on https://www.example.org
const testMobile = new datadog.SyntheticsTest("test_mobile", {
    type: "mobile",
    name: "A Mobile test on example.org",
    status: "paused",
    message: "Notify @datadog.user",
    tags: [
        "foo:bar",
        "baz",
    ],
    configVariables: [{
        example: "123",
        name: "VARIABLE_NAME",
        pattern: "{{numeric(3)}}",
        type: "text",
        secure: false,
    }],
    configInitialApplicationArguments: {
        test_process_argument: "test1",
    },
    deviceIds: ["synthetics:mobile:device:apple_iphone_14_plus_ios_16"],
    locations: ["aws:eu-central-1"],
    mobileOptionsList: {
        minFailureDuration: 0,
        retry: {
            count: 0,
            interval: 300,
        },
        tickEvery: 43200,
        scheduling: {
            timeframes: [
                {
                    day: 5,
                    from: "07:00",
                    to: "16:00",
                },
                {
                    day: 7,
                    from: "07:00",
                    to: "16:00",
                },
            ],
            timezone: "UTC",
        },
        monitorName: "mobile-test-monitor",
        monitorOptions: {
            renotifyInterval: 10,
            escalationMessage: "test escalation message",
            renotifyOccurrences: 3,
            notificationPresetName: "show_all",
        },
        monitorPriority: 5,
        restrictedRoles: [
            "role1",
            "role2",
        ],
        bindings: [{
            principals: [
                "org:8dee7c38-0000-aaaa-zzzz-8b5a08d3b091",
                "team:3a0cdd74-0000-aaaa-zzzz-da7ad0900002",
            ],
            relation: "editor",
        }],
        ci: {
            executionRule: "blocking",
        },
        defaultStepTimeout: 10,
        deviceIds: ["synthetics:mobile:device:apple_iphone_14_plus_ios_16"],
        noScreenshot: true,
        allowApplicationCrash: false,
        disableAutoAcceptAlert: true,
        mobileApplication: {
            applicationId: "5f055d15-0000-aaaa-zzzz-6739f83346aa",
            referenceId: "434d4719-0000-aaaa-zzzz-31082b544718",
            referenceType: "version",
        },
    },
    mobileSteps: [
        {
            name: "Tap on StaticText \"Tap\"",
            params: {
                element: {
                    context: "NATIVE_APP",
                    viewName: "StaticText",
                    contextType: "native",
                    textContent: "Tap",
                    multiLocator: {},
                    relativePosition: {
                        x: 0.07256155303030302,
                        y: 0.41522381756756754,
                    },
                    userLocator: {
                        failTestOnCannotLocate: false,
                        values: [{
                            type: "id",
                            value: "some_id",
                        }],
                    },
                    elementDescription: "<XCUIElementTypeStaticText value=\"Tap\" name=\"Tap\" label=\"Tap\">",
                },
            },
            timeout: 100,
            type: "tap",
            allowFailure: false,
            isCritical: true,
            noScreenshot: false,
            hasNewStepElement: false,
        },
        {
            name: "Test View \"Tap\" content",
            params: {
                check: "contains",
                value: "Tap",
                element: {
                    context: "NATIVE_APP",
                    viewName: "View",
                    contextType: "native",
                    textContent: "Tap",
                    multiLocator: {},
                    relativePosition: {
                        x: 0.27660448306074764,
                        y: 0.6841517857142857,
                    },
                    userLocator: {
                        failTestOnCannotLocate: false,
                        values: [{
                            type: "id",
                            value: "some_id",
                        }],
                    },
                    elementDescription: "<XCUIElementTypeOther name=\"Tap\" label=\"Tap\">",
                },
            },
            timeout: 100,
            type: "assertElementContent",
            allowFailure: false,
            isCritical: true,
            noScreenshot: false,
            hasNewStepElement: false,
        },
    ],
});
// Example Usage (GRPC API behavior check test)
// Create a new Datadog GRPC API test calling host example.org on port 443
// targeting service `greeter.Greeter` with the method `SayHello`
// and the message {"name": "John"}
const testGrpcUnary = new datadog.SyntheticsTest("test_grpc_unary", {
    name: "GRPC API behavior check test",
    type: "api",
    subtype: "grpc",
    status: "live",
    locations: ["aws:eu-central-1"],
    tags: [
        "foo:bar",
        "foo",
        "env:test",
    ],
    requestDefinition: {
        host: "example.org",
        port: "443",
        callType: "unary",
        service: "greeter.Greeter",
        method: "SayHello",
        message: "{\"name\": \"John\"}",
        plainProtoFile: `syntax = "proto3";

package greeter;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}
`,
    },
    requestMetadata: {
        header: "value",
    },
    assertions: [
        {
            type: "responseTime",
            operator: "lessThan",
            target: "2000",
        },
        {
            operator: "is",
            type: "grpcHealthcheckStatus",
            target: "1",
        },
        {
            operator: "is",
            type: "grpcProto",
            target: "proto target",
        },
        {
            operator: "is",
            property: "property",
            type: "grpcMetadata",
            target: "123",
        },
    ],
    optionsList: {
        tickEvery: 900,
    },
});
// Example Usage (GRPC API health check test)
// Create a new Datadog GRPC API test calling host example.org on port 443
// testing the overall health of the service
const testGrpcHealth = new datadog.SyntheticsTest("test_grpc_health", {
    name: "GRPC API health check test",
    type: "api",
    subtype: "grpc",
    status: "live",
    locations: ["aws:eu-central-1"],
    tags: [
        "foo:bar",
        "foo",
        "env:test",
    ],
    requestDefinition: {
        host: "example.org",
        port: "443",
        callType: "healthcheck",
        service: "greeter.Greeter",
    },
    assertions: [
        {
            type: "responseTime",
            operator: "lessThan",
            target: "2000",
        },
        {
            operator: "is",
            type: "grpcHealthcheckStatus",
            target: "1",
        },
    ],
    optionsList: {
        tickEvery: 900,
    },
});

import pulumi
import json
import pulumi_datadog as datadog

# Example Usage (Synthetics API test)
# Create a new Datadog Synthetics API/HTTP test on https://www.example.org
test_uptime = datadog.SyntheticsTest("test_uptime",
    name="An Uptime test on example.org",
    type="api",
    subtype="http",
    status="live",
    message="Notify @pagerduty",
    locations=["aws:eu-central-1"],
    tags=[
        "foo:bar",
        "foo",
        "env:test",
    ],
    request_definition={
        "method": "GET",
        "url": "https://www.example.org",
    },
    request_headers={
        "Content-Type": "application/json",
    },
    assertions=[{
        "type": "statusCode",
        "operator": "is",
        "target": "200",
    }],
    options_list={
        "tick_every": 900,
        "retry": {
            "count": 2,
            "interval": 300,
        },
        "monitor_options": {
            "renotify_interval": 120,
        },
    })
# Example Usage (Authenticated API test)
# Create a new Datadog Synthetics API/HTTP test on https://www.example.org
test_api = datadog.SyntheticsTest("test_api",
    name="An API test on example.org",
    type="api",
    subtype="http",
    status="live",
    message="Notify @pagerduty",
    locations=["aws:eu-central-1"],
    tags=[
        "foo:bar",
        "foo",
        "env:test",
    ],
    request_definition={
        "method": "GET",
        "url": "https://www.example.org",
    },
    request_headers={
        "Content-Type": "application/json",
        "Authentication": "Token: 1234566789",
    },
    assertions=[{
        "type": "statusCode",
        "operator": "is",
        "target": "200",
    }],
    options_list={
        "tick_every": 900,
        "retry": {
            "count": 2,
            "interval": 300,
        },
        "monitor_options": {
            "renotify_interval": 120,
        },
    })
# Example Usage (Synthetics SSL test)
# Create a new Datadog Synthetics API/SSL test on example.org
test_ssl = datadog.SyntheticsTest("test_ssl",
    name="An API test on example.org",
    type="api",
    subtype="ssl",
    status="live",
    message="Notify @pagerduty",
    locations=["aws:eu-central-1"],
    tags=[
        "foo:bar",
        "foo",
        "env:test",
    ],
    request_definition={
        "host": "example.org",
        "port": "443",
    },
    assertions=[{
        "type": "certificate",
        "operator": "isInMoreThan",
        "target": "30",
    }],
    options_list={
        "tick_every": 900,
        "accept_self_signed": True,
    })
# Example Usage (Synthetics TCP test)
# Create a new Datadog Synthetics API/TCP test on example.org
test_tcp = datadog.SyntheticsTest("test_tcp",
    name="An API test on example.org",
    type="api",
    subtype="tcp",
    status="live",
    message="Notify @pagerduty",
    locations=["aws:eu-central-1"],
    tags=[
        "foo:bar",
        "foo",
        "env:test",
    ],
    request_definition={
        "host": "example.org",
        "port": "443",
    },
    assertions=[{
        "type": "responseTime",
        "operator": "lessThan",
        "target": "2000",
    }],
    config_variables=[{
        "type": "global",
        "name": "MY_GLOBAL_VAR",
        "id": "76636cd1-82e2-4aeb-9cfe-51366a8198a2",
    }],
    options_list={
        "tick_every": 900,
    })
# Example Usage (Synthetics DNS test)
# Create a new Datadog Synthetics API/DNS test on example.org
test_dns = datadog.SyntheticsTest("test_dns",
    name="An API test on example.org",
    type="api",
    subtype="dns",
    status="live",
    message="Notify @pagerduty",
    locations=["aws:eu-central-1"],
    tags=[
        "foo:bar",
        "foo",
        "env:test",
    ],
    request_definition={
        "host": "example.org",
    },
    assertions=[{
        "type": "recordSome",
        "operator": "is",
        "property": "A",
        "target": "0.0.0.0",
    }],
    options_list={
        "tick_every": 900,
    })
# Example Usage (Synthetics Multistep API test)
# Create a new Datadog Synthetics Multistep API test
test_multi_step = datadog.SyntheticsTest("test_multi_step",
    name="Multistep API test",
    type="api",
    subtype="multi",
    status="live",
    locations=["aws:eu-central-1"],
    tags=[
        "foo:bar",
        "foo",
        "env:test",
    ],
    api_steps=[
        {
            "name": "An API test on example.org",
            "subtype": "http",
            "assertions": [{
                "type": "statusCode",
                "operator": "is",
                "target": "200",
            }],
            "request_definition": {
                "method": "GET",
                "url": "https://www.example.org",
            },
            "request_headers": {
                "Content-Type": "application/json",
                "Authentication": "Token: 1234566789",
            },
        },
        {
            "name": "An API test on example.org",
            "subtype": "http",
            "assertions": [{
                "type": "statusCode",
                "operator": "is",
                "target": "200",
            }],
            "request_definition": {
                "method": "GET",
                "url": "http://example.org",
            },
        },
        {
            "name": "A gRPC health check on example.org",
            "subtype": "grpc",
            "assertions": [{
                "type": "statusCode",
                "operator": "is",
                "target": "200",
            }],
            "request_definition": {
                "host": "example.org",
                "port": "443",
                "call_type": "healthcheck",
                "service": "greeter.Greeter",
            },
        },
        {
            "name": "A gRPC behavior check on example.org",
            "subtype": "grpc",
            "assertions": [{
                "type": "statusCode",
                "operator": "is",
                "target": "200",
            }],
            "request_definition": {
                "host": "example.org",
                "port": "443",
                "call_type": "unary",
                "service": "greeter.Greeter",
                "method": "SayHello",
                "message": "{\"name\": \"John\"}",
                "plain_proto_file": """syntax = "proto3";

package greeter;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}
""",
            },
        },
    ],
    options_list={
        "tick_every": 900,
        "accept_self_signed": True,
    })
# Example Usage (Synthetics Browser test)
# Create a new Datadog Synthetics Browser test starting on https://www.example.org
test_browser = datadog.SyntheticsTest("test_browser",
    name="A Browser test on example.org",
    type="browser",
    status="paused",
    message="Notify @qa",
    device_ids=["laptop_large"],
    locations=["aws:eu-central-1"],
    tags=[],
    request_definition={
        "method": "GET",
        "url": "https://www.example.org",
    },
    browser_steps=[
        {
            "name": "Check current url",
            "type": "assertCurrentUrl",
            "params": {
                "check": "contains",
                "value": "datadoghq",
            },
        },
        {
            "name": "Test a downloaded file",
            "type": "assertFileDownload",
            "params": {
                "file": json.dumps({
                    "md5": "abcdef1234567890",
                    "sizeCheck": {
                        "type": "equals",
                        "value": 1,
                    },
                    "nameCheck": {
                        "type": "contains",
                        "value": ".xls",
                    },
                }),
            },
        },
    ],
    browser_variables=[
        {
            "type": "text",
            "name": "MY_PATTERN_VAR",
            "pattern": "{{numeric(3)}}",
            "example": "597",
        },
        {
            "type": "email",
            "name": "MY_EMAIL_VAR",
            "pattern": "jd8-afe-ydv.{{ numeric(10) }}@synthetics.dtdg.co",
            "example": "jd8-afe-ydv.4546132139@synthetics.dtdg.co",
        },
        {
            "type": "global",
            "name": "MY_GLOBAL_VAR",
            "id": "76636cd1-82e2-4aeb-9cfe-51366a8198a2",
        },
    ],
    options_list={
        "tick_every": 3600,
    })
# Example Usage (Synthetics Mobile test)
# Create a new Datadog Synthetics Mobile test starting on https://www.example.org
test_mobile = datadog.SyntheticsTest("test_mobile",
    type="mobile",
    name="A Mobile test on example.org",
    status="paused",
    message="Notify @datadog.user",
    tags=[
        "foo:bar",
        "baz",
    ],
    config_variables=[{
        "example": "123",
        "name": "VARIABLE_NAME",
        "pattern": "{{numeric(3)}}",
        "type": "text",
        "secure": False,
    }],
    config_initial_application_arguments={
        "test_process_argument": "test1",
    },
    device_ids=["synthetics:mobile:device:apple_iphone_14_plus_ios_16"],
    locations=["aws:eu-central-1"],
    mobile_options_list={
        "min_failure_duration": 0,
        "retry": {
            "count": 0,
            "interval": 300,
        },
        "tick_every": 43200,
        "scheduling": {
            "timeframes": [
                {
                    "day": 5,
                    "from_": "07:00",
                    "to": "16:00",
                },
                {
                    "day": 7,
                    "from_": "07:00",
                    "to": "16:00",
                },
            ],
            "timezone": "UTC",
        },
        "monitor_name": "mobile-test-monitor",
        "monitor_options": {
            "renotify_interval": 10,
            "escalation_message": "test escalation message",
            "renotify_occurrences": 3,
            "notification_preset_name": "show_all",
        },
        "monitor_priority": 5,
        "restricted_roles": [
            "role1",
            "role2",
        ],
        "bindings": [{
            "principals": [
                "org:8dee7c38-0000-aaaa-zzzz-8b5a08d3b091",
                "team:3a0cdd74-0000-aaaa-zzzz-da7ad0900002",
            ],
            "relation": "editor",
        }],
        "ci": {
            "execution_rule": "blocking",
        },
        "default_step_timeout": 10,
        "device_ids": ["synthetics:mobile:device:apple_iphone_14_plus_ios_16"],
        "no_screenshot": True,
        "allow_application_crash": False,
        "disable_auto_accept_alert": True,
        "mobile_application": {
            "application_id": "5f055d15-0000-aaaa-zzzz-6739f83346aa",
            "reference_id": "434d4719-0000-aaaa-zzzz-31082b544718",
            "reference_type": "version",
        },
    },
    mobile_steps=[
        {
            "name": "Tap on StaticText \"Tap\"",
            "params": {
                "element": {
                    "context": "NATIVE_APP",
                    "view_name": "StaticText",
                    "context_type": "native",
                    "text_content": "Tap",
                    "multi_locator": {},
                    "relative_position": {
                        "x": 0.07256155303030302,
                        "y": 0.41522381756756754,
                    },
                    "user_locator": {
                        "fail_test_on_cannot_locate": False,
                        "values": [{
                            "type": "id",
                            "value": "some_id",
                        }],
                    },
                    "element_description": "<XCUIElementTypeStaticText value=\"Tap\" name=\"Tap\" label=\"Tap\">",
                },
            },
            "timeout": 100,
            "type": "tap",
            "allow_failure": False,
            "is_critical": True,
            "no_screenshot": False,
            "has_new_step_element": False,
        },
        {
            "name": "Test View \"Tap\" content",
            "params": {
                "check": "contains",
                "value": "Tap",
                "element": {
                    "context": "NATIVE_APP",
                    "view_name": "View",
                    "context_type": "native",
                    "text_content": "Tap",
                    "multi_locator": {},
                    "relative_position": {
                        "x": 0.27660448306074764,
                        "y": 0.6841517857142857,
                    },
                    "user_locator": {
                        "fail_test_on_cannot_locate": False,
                        "values": [{
                            "type": "id",
                            "value": "some_id",
                        }],
                    },
                    "element_description": "<XCUIElementTypeOther name=\"Tap\" label=\"Tap\">",
                },
            },
            "timeout": 100,
            "type": "assertElementContent",
            "allow_failure": False,
            "is_critical": True,
            "no_screenshot": False,
            "has_new_step_element": False,
        },
    ])
# Example Usage (GRPC API behavior check test)
# Create a new Datadog GRPC API test calling host example.org on port 443
# targeting service `greeter.Greeter` with the method `SayHello`
# and the message {"name": "John"}
test_grpc_unary = datadog.SyntheticsTest("test_grpc_unary",
    name="GRPC API behavior check test",
    type="api",
    subtype="grpc",
    status="live",
    locations=["aws:eu-central-1"],
    tags=[
        "foo:bar",
        "foo",
        "env:test",
    ],
    request_definition={
        "host": "example.org",
        "port": "443",
        "call_type": "unary",
        "service": "greeter.Greeter",
        "method": "SayHello",
        "message": "{\"name\": \"John\"}",
        "plain_proto_file": """syntax = "proto3";

package greeter;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}
""",
    },
    request_metadata={
        "header": "value",
    },
    assertions=[
        {
            "type": "responseTime",
            "operator": "lessThan",
            "target": "2000",
        },
        {
            "operator": "is",
            "type": "grpcHealthcheckStatus",
            "target": "1",
        },
        {
            "operator": "is",
            "type": "grpcProto",
            "target": "proto target",
        },
        {
            "operator": "is",
            "property": "property",
            "type": "grpcMetadata",
            "target": "123",
        },
    ],
    options_list={
        "tick_every": 900,
    })
# Example Usage (GRPC API health check test)
# Create a new Datadog GRPC API test calling host example.org on port 443
# testing the overall health of the service
test_grpc_health = datadog.SyntheticsTest("test_grpc_health",
    name="GRPC API health check test",
    type="api",
    subtype="grpc",
    status="live",
    locations=["aws:eu-central-1"],
    tags=[
        "foo:bar",
        "foo",
        "env:test",
    ],
    request_definition={
        "host": "example.org",
        "port": "443",
        "call_type": "healthcheck",
        "service": "greeter.Greeter",
    },
    assertions=[
        {
            "type": "responseTime",
            "operator": "lessThan",
            "target": "2000",
        },
        {
            "operator": "is",
            "type": "grpcHealthcheckStatus",
            "target": "1",
        },
    ],
    options_list={
        "tick_every": 900,
    })

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-datadog/sdk/v4/go/datadog"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Example Usage (Synthetics API test)
		// Create a new Datadog Synthetics API/HTTP test on https://www.example.org
		_, err := datadog.NewSyntheticsTest(ctx, "test_uptime", &datadog.SyntheticsTestArgs{
			Name:    pulumi.String("An Uptime test on example.org"),
			Type:    pulumi.String("api"),
			Subtype: pulumi.String("http"),
			Status:  pulumi.String("live"),
			Message: pulumi.String("Notify @pagerduty"),
			Locations: pulumi.StringArray{
				pulumi.String("aws:eu-central-1"),
			},
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("foo"),
				pulumi.String("env:test"),
			},
			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
				Method: pulumi.String("GET"),
				Url:    pulumi.String("https://www.example.org"),
			},
			RequestHeaders: pulumi.StringMap{
				"Content-Type": pulumi.String("application/json"),
			},
			Assertions: datadog.SyntheticsTestAssertionArray{
				&datadog.SyntheticsTestAssertionArgs{
					Type:     pulumi.String("statusCode"),
					Operator: pulumi.String("is"),
					Target:   pulumi.String("200"),
				},
			},
			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
				TickEvery: pulumi.Int(900),
				Retry: &datadog.SyntheticsTestOptionsListRetryArgs{
					Count:    pulumi.Int(2),
					Interval: pulumi.Int(300),
				},
				MonitorOptions: &datadog.SyntheticsTestOptionsListMonitorOptionsArgs{
					RenotifyInterval: pulumi.Int(120),
				},
			},
		})
		if err != nil {
			return err
		}
		// Example Usage (Authenticated API test)
		// Create a new Datadog Synthetics API/HTTP test on https://www.example.org
		_, err = datadog.NewSyntheticsTest(ctx, "test_api", &datadog.SyntheticsTestArgs{
			Name:    pulumi.String("An API test on example.org"),
			Type:    pulumi.String("api"),
			Subtype: pulumi.String("http"),
			Status:  pulumi.String("live"),
			Message: pulumi.String("Notify @pagerduty"),
			Locations: pulumi.StringArray{
				pulumi.String("aws:eu-central-1"),
			},
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("foo"),
				pulumi.String("env:test"),
			},
			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
				Method: pulumi.String("GET"),
				Url:    pulumi.String("https://www.example.org"),
			},
			RequestHeaders: pulumi.StringMap{
				"Content-Type":   pulumi.String("application/json"),
				"Authentication": pulumi.String("Token: 1234566789"),
			},
			Assertions: datadog.SyntheticsTestAssertionArray{
				&datadog.SyntheticsTestAssertionArgs{
					Type:     pulumi.String("statusCode"),
					Operator: pulumi.String("is"),
					Target:   pulumi.String("200"),
				},
			},
			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
				TickEvery: pulumi.Int(900),
				Retry: &datadog.SyntheticsTestOptionsListRetryArgs{
					Count:    pulumi.Int(2),
					Interval: pulumi.Int(300),
				},
				MonitorOptions: &datadog.SyntheticsTestOptionsListMonitorOptionsArgs{
					RenotifyInterval: pulumi.Int(120),
				},
			},
		})
		if err != nil {
			return err
		}
		// Example Usage (Synthetics SSL test)
		// Create a new Datadog Synthetics API/SSL test on example.org
		_, err = datadog.NewSyntheticsTest(ctx, "test_ssl", &datadog.SyntheticsTestArgs{
			Name:    pulumi.String("An API test on example.org"),
			Type:    pulumi.String("api"),
			Subtype: pulumi.String("ssl"),
			Status:  pulumi.String("live"),
			Message: pulumi.String("Notify @pagerduty"),
			Locations: pulumi.StringArray{
				pulumi.String("aws:eu-central-1"),
			},
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("foo"),
				pulumi.String("env:test"),
			},
			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
				Host: pulumi.String("example.org"),
				Port: pulumi.String("443"),
			},
			Assertions: datadog.SyntheticsTestAssertionArray{
				&datadog.SyntheticsTestAssertionArgs{
					Type:     pulumi.String("certificate"),
					Operator: pulumi.String("isInMoreThan"),
					Target:   pulumi.String("30"),
				},
			},
			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
				TickEvery:        pulumi.Int(900),
				AcceptSelfSigned: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		// Example Usage (Synthetics TCP test)
		// Create a new Datadog Synthetics API/TCP test on example.org
		_, err = datadog.NewSyntheticsTest(ctx, "test_tcp", &datadog.SyntheticsTestArgs{
			Name:    pulumi.String("An API test on example.org"),
			Type:    pulumi.String("api"),
			Subtype: pulumi.String("tcp"),
			Status:  pulumi.String("live"),
			Message: pulumi.String("Notify @pagerduty"),
			Locations: pulumi.StringArray{
				pulumi.String("aws:eu-central-1"),
			},
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("foo"),
				pulumi.String("env:test"),
			},
			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
				Host: pulumi.String("example.org"),
				Port: pulumi.String("443"),
			},
			Assertions: datadog.SyntheticsTestAssertionArray{
				&datadog.SyntheticsTestAssertionArgs{
					Type:     pulumi.String("responseTime"),
					Operator: pulumi.String("lessThan"),
					Target:   pulumi.String("2000"),
				},
			},
			ConfigVariables: datadog.SyntheticsTestConfigVariableArray{
				&datadog.SyntheticsTestConfigVariableArgs{
					Type: pulumi.String("global"),
					Name: pulumi.String("MY_GLOBAL_VAR"),
					Id:   pulumi.String("76636cd1-82e2-4aeb-9cfe-51366a8198a2"),
				},
			},
			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
				TickEvery: pulumi.Int(900),
			},
		})
		if err != nil {
			return err
		}
		// Example Usage (Synthetics DNS test)
		// Create a new Datadog Synthetics API/DNS test on example.org
		_, err = datadog.NewSyntheticsTest(ctx, "test_dns", &datadog.SyntheticsTestArgs{
			Name:    pulumi.String("An API test on example.org"),
			Type:    pulumi.String("api"),
			Subtype: pulumi.String("dns"),
			Status:  pulumi.String("live"),
			Message: pulumi.String("Notify @pagerduty"),
			Locations: pulumi.StringArray{
				pulumi.String("aws:eu-central-1"),
			},
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("foo"),
				pulumi.String("env:test"),
			},
			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
				Host: pulumi.String("example.org"),
			},
			Assertions: datadog.SyntheticsTestAssertionArray{
				&datadog.SyntheticsTestAssertionArgs{
					Type:     pulumi.String("recordSome"),
					Operator: pulumi.String("is"),
					Property: pulumi.String("A"),
					Target:   pulumi.String("0.0.0.0"),
				},
			},
			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
				TickEvery: pulumi.Int(900),
			},
		})
		if err != nil {
			return err
		}
		// Example Usage (Synthetics Multistep API test)
		// Create a new Datadog Synthetics Multistep API test
		_, err = datadog.NewSyntheticsTest(ctx, "test_multi_step", &datadog.SyntheticsTestArgs{
			Name:    pulumi.String("Multistep API test"),
			Type:    pulumi.String("api"),
			Subtype: pulumi.String("multi"),
			Status:  pulumi.String("live"),
			Locations: pulumi.StringArray{
				pulumi.String("aws:eu-central-1"),
			},
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("foo"),
				pulumi.String("env:test"),
			},
			ApiSteps: datadog.SyntheticsTestApiStepArray{
				&datadog.SyntheticsTestApiStepArgs{
					Name:    pulumi.String("An API test on example.org"),
					Subtype: pulumi.String("http"),
					Assertions: datadog.SyntheticsTestApiStepAssertionArray{
						&datadog.SyntheticsTestApiStepAssertionArgs{
							Type:     pulumi.String("statusCode"),
							Operator: pulumi.String("is"),
							Target:   pulumi.String("200"),
						},
					},
					RequestDefinition: &datadog.SyntheticsTestApiStepRequestDefinitionArgs{
						Method: pulumi.String("GET"),
						Url:    pulumi.String("https://www.example.org"),
					},
					RequestHeaders: pulumi.StringMap{
						"Content-Type":   pulumi.String("application/json"),
						"Authentication": pulumi.String("Token: 1234566789"),
					},
				},
				&datadog.SyntheticsTestApiStepArgs{
					Name:    pulumi.String("An API test on example.org"),
					Subtype: pulumi.String("http"),
					Assertions: datadog.SyntheticsTestApiStepAssertionArray{
						&datadog.SyntheticsTestApiStepAssertionArgs{
							Type:     pulumi.String("statusCode"),
							Operator: pulumi.String("is"),
							Target:   pulumi.String("200"),
						},
					},
					RequestDefinition: &datadog.SyntheticsTestApiStepRequestDefinitionArgs{
						Method: pulumi.String("GET"),
						Url:    pulumi.String("http://example.org"),
					},
				},
				&datadog.SyntheticsTestApiStepArgs{
					Name:    pulumi.String("A gRPC health check on example.org"),
					Subtype: pulumi.String("grpc"),
					Assertions: datadog.SyntheticsTestApiStepAssertionArray{
						&datadog.SyntheticsTestApiStepAssertionArgs{
							Type:     pulumi.String("statusCode"),
							Operator: pulumi.String("is"),
							Target:   pulumi.String("200"),
						},
					},
					RequestDefinition: &datadog.SyntheticsTestApiStepRequestDefinitionArgs{
						Host:     pulumi.String("example.org"),
						Port:     pulumi.String("443"),
						CallType: pulumi.String("healthcheck"),
						Service:  pulumi.String("greeter.Greeter"),
					},
				},
				&datadog.SyntheticsTestApiStepArgs{
					Name:    pulumi.String("A gRPC behavior check on example.org"),
					Subtype: pulumi.String("grpc"),
					Assertions: datadog.SyntheticsTestApiStepAssertionArray{
						&datadog.SyntheticsTestApiStepAssertionArgs{
							Type:     pulumi.String("statusCode"),
							Operator: pulumi.String("is"),
							Target:   pulumi.String("200"),
						},
					},
					RequestDefinition: &datadog.SyntheticsTestApiStepRequestDefinitionArgs{
						Host:     pulumi.String("example.org"),
						Port:     pulumi.String("443"),
						CallType: pulumi.String("unary"),
						Service:  pulumi.String("greeter.Greeter"),
						Method:   pulumi.String("SayHello"),
						Message:  pulumi.String("{\"name\": \"John\"}"),
						PlainProtoFile: pulumi.String(`syntax = "proto3";

package greeter;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}
`),
					},
				},
			},
			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
				TickEvery:        pulumi.Int(900),
				AcceptSelfSigned: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"md5": "abcdef1234567890",
			"sizeCheck": map[string]interface{}{
				"type":  "equals",
				"value": 1,
			},
			"nameCheck": map[string]interface{}{
				"type":  "contains",
				"value": ".xls",
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		// Example Usage (Synthetics Browser test)
		// Create a new Datadog Synthetics Browser test starting on https://www.example.org
		_, err = datadog.NewSyntheticsTest(ctx, "test_browser", &datadog.SyntheticsTestArgs{
			Name:    pulumi.String("A Browser test on example.org"),
			Type:    pulumi.String("browser"),
			Status:  pulumi.String("paused"),
			Message: pulumi.String("Notify @qa"),
			DeviceIds: pulumi.StringArray{
				pulumi.String("laptop_large"),
			},
			Locations: pulumi.StringArray{
				pulumi.String("aws:eu-central-1"),
			},
			Tags: pulumi.StringArray{},
			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
				Method: pulumi.String("GET"),
				Url:    pulumi.String("https://www.example.org"),
			},
			BrowserSteps: datadog.SyntheticsTestBrowserStepArray{
				&datadog.SyntheticsTestBrowserStepArgs{
					Name: pulumi.String("Check current url"),
					Type: pulumi.String("assertCurrentUrl"),
					Params: &datadog.SyntheticsTestBrowserStepParamsArgs{
						Check: pulumi.String("contains"),
						Value: pulumi.String("datadoghq"),
					},
				},
				&datadog.SyntheticsTestBrowserStepArgs{
					Name: pulumi.String("Test a downloaded file"),
					Type: pulumi.String("assertFileDownload"),
					Params: &datadog.SyntheticsTestBrowserStepParamsArgs{
						File: pulumi.String(json0),
					},
				},
			},
			BrowserVariables: datadog.SyntheticsTestBrowserVariableArray{
				&datadog.SyntheticsTestBrowserVariableArgs{
					Type:    pulumi.String("text"),
					Name:    pulumi.String("MY_PATTERN_VAR"),
					Pattern: pulumi.String("{{numeric(3)}}"),
					Example: pulumi.String("597"),
				},
				&datadog.SyntheticsTestBrowserVariableArgs{
					Type:    pulumi.String("email"),
					Name:    pulumi.String("MY_EMAIL_VAR"),
					Pattern: pulumi.String("jd8-afe-ydv.{{ numeric(10) }}@synthetics.dtdg.co"),
					Example: pulumi.String("jd8-afe-ydv.4546132139@synthetics.dtdg.co"),
				},
				&datadog.SyntheticsTestBrowserVariableArgs{
					Type: pulumi.String("global"),
					Name: pulumi.String("MY_GLOBAL_VAR"),
					Id:   pulumi.String("76636cd1-82e2-4aeb-9cfe-51366a8198a2"),
				},
			},
			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
				TickEvery: pulumi.Int(3600),
			},
		})
		if err != nil {
			return err
		}
		// Example Usage (Synthetics Mobile test)
		// Create a new Datadog Synthetics Mobile test starting on https://www.example.org
		_, err = datadog.NewSyntheticsTest(ctx, "test_mobile", &datadog.SyntheticsTestArgs{
			Type:    pulumi.String("mobile"),
			Name:    pulumi.String("A Mobile test on example.org"),
			Status:  pulumi.String("paused"),
			Message: pulumi.String("Notify @datadog.user"),
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("baz"),
			},
			ConfigVariables: datadog.SyntheticsTestConfigVariableArray{
				&datadog.SyntheticsTestConfigVariableArgs{
					Example: pulumi.String("123"),
					Name:    pulumi.String("VARIABLE_NAME"),
					Pattern: pulumi.String("{{numeric(3)}}"),
					Type:    pulumi.String("text"),
					Secure:  pulumi.Bool(false),
				},
			},
			ConfigInitialApplicationArguments: pulumi.StringMap{
				"test_process_argument": pulumi.String("test1"),
			},
			DeviceIds: pulumi.StringArray{
				pulumi.String("synthetics:mobile:device:apple_iphone_14_plus_ios_16"),
			},
			Locations: pulumi.StringArray{
				pulumi.String("aws:eu-central-1"),
			},
			MobileOptionsList: &datadog.SyntheticsTestMobileOptionsListArgs{
				MinFailureDuration: pulumi.Int(0),
				Retry: &datadog.SyntheticsTestMobileOptionsListRetryArgs{
					Count:    pulumi.Int(0),
					Interval: pulumi.Int(300),
				},
				TickEvery: pulumi.Int(43200),
				Scheduling: &datadog.SyntheticsTestMobileOptionsListSchedulingArgs{
					Timeframes: datadog.SyntheticsTestMobileOptionsListSchedulingTimeframeArray{
						&datadog.SyntheticsTestMobileOptionsListSchedulingTimeframeArgs{
							Day:  pulumi.Int(5),
							From: pulumi.String("07:00"),
							To:   pulumi.String("16:00"),
						},
						&datadog.SyntheticsTestMobileOptionsListSchedulingTimeframeArgs{
							Day:  pulumi.Int(7),
							From: pulumi.String("07:00"),
							To:   pulumi.String("16:00"),
						},
					},
					Timezone: pulumi.String("UTC"),
				},
				MonitorName: pulumi.String("mobile-test-monitor"),
				MonitorOptions: &datadog.SyntheticsTestMobileOptionsListMonitorOptionsArgs{
					RenotifyInterval:       pulumi.Int(10),
					EscalationMessage:      pulumi.String("test escalation message"),
					RenotifyOccurrences:    pulumi.Int(3),
					NotificationPresetName: pulumi.String("show_all"),
				},
				MonitorPriority: pulumi.Int(5),
				RestrictedRoles: pulumi.StringArray{
					pulumi.String("role1"),
					pulumi.String("role2"),
				},
				Bindings: datadog.SyntheticsTestMobileOptionsListBindingArray{
					&datadog.SyntheticsTestMobileOptionsListBindingArgs{
						Principals: pulumi.StringArray{
							pulumi.String("org:8dee7c38-0000-aaaa-zzzz-8b5a08d3b091"),
							pulumi.String("team:3a0cdd74-0000-aaaa-zzzz-da7ad0900002"),
						},
						Relation: pulumi.String("editor"),
					},
				},
				Ci: &datadog.SyntheticsTestMobileOptionsListCiArgs{
					ExecutionRule: pulumi.String("blocking"),
				},
				DefaultStepTimeout: pulumi.Int(10),
				DeviceIds: pulumi.StringArray{
					pulumi.String("synthetics:mobile:device:apple_iphone_14_plus_ios_16"),
				},
				NoScreenshot:           pulumi.Bool(true),
				AllowApplicationCrash:  pulumi.Bool(false),
				DisableAutoAcceptAlert: pulumi.Bool(true),
				MobileApplication: &datadog.SyntheticsTestMobileOptionsListMobileApplicationArgs{
					ApplicationId: pulumi.String("5f055d15-0000-aaaa-zzzz-6739f83346aa"),
					ReferenceId:   pulumi.String("434d4719-0000-aaaa-zzzz-31082b544718"),
					ReferenceType: pulumi.String("version"),
				},
			},
			MobileSteps: datadog.SyntheticsTestMobileStepArray{
				&datadog.SyntheticsTestMobileStepArgs{
					Name: pulumi.String("Tap on StaticText \"Tap\""),
					Params: &datadog.SyntheticsTestMobileStepParamsArgs{
						Element: &datadog.SyntheticsTestMobileStepParamsElementArgs{
							Context:      pulumi.String("NATIVE_APP"),
							ViewName:     pulumi.String("StaticText"),
							ContextType:  pulumi.String("native"),
							TextContent:  pulumi.String("Tap"),
							MultiLocator: pulumi.StringMap{},
							RelativePosition: &datadog.SyntheticsTestMobileStepParamsElementRelativePositionArgs{
								X: pulumi.Float64(0.07256155303030302),
								Y: pulumi.Float64(0.41522381756756754),
							},
							UserLocator: &datadog.SyntheticsTestMobileStepParamsElementUserLocatorArgs{
								FailTestOnCannotLocate: pulumi.Bool(false),
								Values: datadog.SyntheticsTestMobileStepParamsElementUserLocatorValueArray{
									&datadog.SyntheticsTestMobileStepParamsElementUserLocatorValueArgs{
										Type:  pulumi.String("id"),
										Value: pulumi.String("some_id"),
									},
								},
							},
							ElementDescription: pulumi.String("<XCUIElementTypeStaticText value=\"Tap\" name=\"Tap\" label=\"Tap\">"),
						},
					},
					Timeout:           pulumi.Int(100),
					Type:              pulumi.String("tap"),
					AllowFailure:      pulumi.Bool(false),
					IsCritical:        pulumi.Bool(true),
					NoScreenshot:      pulumi.Bool(false),
					HasNewStepElement: pulumi.Bool(false),
				},
				&datadog.SyntheticsTestMobileStepArgs{
					Name: pulumi.String("Test View \"Tap\" content"),
					Params: &datadog.SyntheticsTestMobileStepParamsArgs{
						Check: pulumi.String("contains"),
						Value: pulumi.String("Tap"),
						Element: &datadog.SyntheticsTestMobileStepParamsElementArgs{
							Context:      pulumi.String("NATIVE_APP"),
							ViewName:     pulumi.String("View"),
							ContextType:  pulumi.String("native"),
							TextContent:  pulumi.String("Tap"),
							MultiLocator: pulumi.StringMap{},
							RelativePosition: &datadog.SyntheticsTestMobileStepParamsElementRelativePositionArgs{
								X: pulumi.Float64(0.27660448306074764),
								Y: pulumi.Float64(0.6841517857142857),
							},
							UserLocator: &datadog.SyntheticsTestMobileStepParamsElementUserLocatorArgs{
								FailTestOnCannotLocate: pulumi.Bool(false),
								Values: datadog.SyntheticsTestMobileStepParamsElementUserLocatorValueArray{
									&datadog.SyntheticsTestMobileStepParamsElementUserLocatorValueArgs{
										Type:  pulumi.String("id"),
										Value: pulumi.String("some_id"),
									},
								},
							},
							ElementDescription: pulumi.String("<XCUIElementTypeOther name=\"Tap\" label=\"Tap\">"),
						},
					},
					Timeout:           pulumi.Int(100),
					Type:              pulumi.String("assertElementContent"),
					AllowFailure:      pulumi.Bool(false),
					IsCritical:        pulumi.Bool(true),
					NoScreenshot:      pulumi.Bool(false),
					HasNewStepElement: pulumi.Bool(false),
				},
			},
		})
		if err != nil {
			return err
		}
		// Example Usage (GRPC API behavior check test)
		// Create a new Datadog GRPC API test calling host example.org on port 443
		// targeting service `greeter.Greeter` with the method `SayHello`
		// and the message {"name": "John"}
		_, err = datadog.NewSyntheticsTest(ctx, "test_grpc_unary", &datadog.SyntheticsTestArgs{
			Name:    pulumi.String("GRPC API behavior check test"),
			Type:    pulumi.String("api"),
			Subtype: pulumi.String("grpc"),
			Status:  pulumi.String("live"),
			Locations: pulumi.StringArray{
				pulumi.String("aws:eu-central-1"),
			},
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("foo"),
				pulumi.String("env:test"),
			},
			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
				Host:     pulumi.String("example.org"),
				Port:     pulumi.String("443"),
				CallType: pulumi.String("unary"),
				Service:  pulumi.String("greeter.Greeter"),
				Method:   pulumi.String("SayHello"),
				Message:  pulumi.String("{\"name\": \"John\"}"),
				PlainProtoFile: pulumi.String(`syntax = "proto3";

package greeter;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}
`),
			},
			RequestMetadata: pulumi.StringMap{
				"header": pulumi.String("value"),
			},
			Assertions: datadog.SyntheticsTestAssertionArray{
				&datadog.SyntheticsTestAssertionArgs{
					Type:     pulumi.String("responseTime"),
					Operator: pulumi.String("lessThan"),
					Target:   pulumi.String("2000"),
				},
				&datadog.SyntheticsTestAssertionArgs{
					Operator: pulumi.String("is"),
					Type:     pulumi.String("grpcHealthcheckStatus"),
					Target:   pulumi.String("1"),
				},
				&datadog.SyntheticsTestAssertionArgs{
					Operator: pulumi.String("is"),
					Type:     pulumi.String("grpcProto"),
					Target:   pulumi.String("proto target"),
				},
				&datadog.SyntheticsTestAssertionArgs{
					Operator: pulumi.String("is"),
					Property: pulumi.String("property"),
					Type:     pulumi.String("grpcMetadata"),
					Target:   pulumi.String("123"),
				},
			},
			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
				TickEvery: pulumi.Int(900),
			},
		})
		if err != nil {
			return err
		}
		// Example Usage (GRPC API health check test)
		// Create a new Datadog GRPC API test calling host example.org on port 443
		// testing the overall health of the service
		_, err = datadog.NewSyntheticsTest(ctx, "test_grpc_health", &datadog.SyntheticsTestArgs{
			Name:    pulumi.String("GRPC API health check test"),
			Type:    pulumi.String("api"),
			Subtype: pulumi.String("grpc"),
			Status:  pulumi.String("live"),
			Locations: pulumi.StringArray{
				pulumi.String("aws:eu-central-1"),
			},
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
				pulumi.String("foo"),
				pulumi.String("env:test"),
			},
			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
				Host:     pulumi.String("example.org"),
				Port:     pulumi.String("443"),
				CallType: pulumi.String("healthcheck"),
				Service:  pulumi.String("greeter.Greeter"),
			},
			Assertions: datadog.SyntheticsTestAssertionArray{
				&datadog.SyntheticsTestAssertionArgs{
					Type:     pulumi.String("responseTime"),
					Operator: pulumi.String("lessThan"),
					Target:   pulumi.String("2000"),
				},
				&datadog.SyntheticsTestAssertionArgs{
					Operator: pulumi.String("is"),
					Type:     pulumi.String("grpcHealthcheckStatus"),
					Target:   pulumi.String("1"),
				},
			},
			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
				TickEvery: pulumi.Int(900),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}