auth0.Experiment

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

const loginUi = new auth0.ExperimentFeatureFlag("login_ui", {
    parameters: [{
        name: "show_new_login",
        type: "boolean",
        value: "false",
    }],
    variations: [
        {
            name: "control",
        },
        {
            overrides: [{
                name: "show_new_login",
                type: "boolean",
                value: "true",
            }],
            name: "new-login",
        },
    ],
    name: "new-login-ui",
    description: "Controls whether the new login UI is shown.",
    status: "active",
});
// Percentage strategy: split traffic between variations by weight.
const percentage = new auth0.Experiment("percentage", {
    allocations: [
        {
            variationId: loginUi.variationIds.control,
            isControl: true,
            weight: 50,
        },
        {
            variationId: loginUi.variationIds["new-login"],
            isControl: false,
            weight: 50,
        },
    ],
    name: "login-ui-percentage-test",
    description: "Show the new login UI to half of the traffic.",
    featureFlagId: loginUi.id,
    authenticationFlow: "authentication",
    allocationStrategy: "percentage",
    status: "draft",
});
const usTraffic = new auth0.ExperimentSegment("us_traffic", {
    rules: [{
        match: {
            country: {
                contains: ["US"],
            },
        },
    }],
    name: "us-traffic",
});
// Segment strategy: route each segment to a variation; other traffic gets the
// fallback allocation.
const segment = new auth0.Experiment("segment", {
    allocations: [
        {
            variationId: loginUi.variationIds.control,
            isControl: true,
            segmentId: usTraffic.id,
            priority: 1,
        },
        {
            variationId: loginUi.variationIds["new-login"],
            isControl: false,
            isFallback: true,
        },
    ],
    name: "login-ui-segment-test",
    description: "Keep US traffic on the current login UI and show the new UI elsewhere.",
    featureFlagId: loginUi.id,
    authenticationFlow: "mfa_challenge",
    allocationStrategy: "segment",
    status: "draft",
});

import pulumi
import pulumi_auth0 as auth0

login_ui = auth0.ExperimentFeatureFlag("login_ui",
    parameters=[{
        "name": "show_new_login",
        "type": "boolean",
        "value": "false",
    }],
    variations=[
        {
            "name": "control",
        },
        {
            "overrides": [{
                "name": "show_new_login",
                "type": "boolean",
                "value": "true",
            }],
            "name": "new-login",
        },
    ],
    name="new-login-ui",
    description="Controls whether the new login UI is shown.",
    status="active")
# Percentage strategy: split traffic between variations by weight.
percentage = auth0.Experiment("percentage",
    allocations=[
        {
            "variation_id": login_ui.variation_ids["control"],
            "is_control": True,
            "weight": 50,
        },
        {
            "variation_id": login_ui.variation_ids["new-login"],
            "is_control": False,
            "weight": 50,
        },
    ],
    name="login-ui-percentage-test",
    description="Show the new login UI to half of the traffic.",
    feature_flag_id=login_ui.id,
    authentication_flow="authentication",
    allocation_strategy="percentage",
    status="draft")
us_traffic = auth0.ExperimentSegment("us_traffic",
    rules=[{
        "match": {
            "country": {
                "contains": ["US"],
            },
        },
    }],
    name="us-traffic")
# Segment strategy: route each segment to a variation; other traffic gets the
# fallback allocation.
segment = auth0.Experiment("segment",
    allocations=[
        {
            "variation_id": login_ui.variation_ids["control"],
            "is_control": True,
            "segment_id": us_traffic.id,
            "priority": 1,
        },
        {
            "variation_id": login_ui.variation_ids["new-login"],
            "is_control": False,
            "is_fallback": True,
        },
    ],
    name="login-ui-segment-test",
    description="Keep US traffic on the current login UI and show the new UI elsewhere.",
    feature_flag_id=login_ui.id,
    authentication_flow="mfa_challenge",
    allocation_strategy="segment",
    status="draft")

package main

import (
	"github.com/pulumi/pulumi-auth0/sdk/v3/go/auth0"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		loginUi, err := auth0.NewExperimentFeatureFlag(ctx, "login_ui", &auth0.ExperimentFeatureFlagArgs{
			Parameters: auth0.ExperimentFeatureFlagParameterArray{
				&auth0.ExperimentFeatureFlagParameterArgs{
					Name:  pulumi.String("show_new_login"),
					Type:  pulumi.String("boolean"),
					Value: pulumi.String("false"),
				},
			},
			Variations: auth0.ExperimentFeatureFlagVariationArray{
				&auth0.ExperimentFeatureFlagVariationArgs{
					Name: pulumi.String("control"),
				},
				&auth0.ExperimentFeatureFlagVariationArgs{
					Overrides: auth0.ExperimentFeatureFlagVariationOverrideArray{
						&auth0.ExperimentFeatureFlagVariationOverrideArgs{
							Name:  pulumi.String("show_new_login"),
							Type:  pulumi.String("boolean"),
							Value: pulumi.String("true"),
						},
					},
					Name: pulumi.String("new-login"),
				},
			},
			Name:        pulumi.String("new-login-ui"),
			Description: pulumi.String("Controls whether the new login UI is shown."),
			Status:      pulumi.String("active"),
		})
		if err != nil {
			return err
		}
		// Percentage strategy: split traffic between variations by weight.
		_, err = auth0.NewExperiment(ctx, "percentage", &auth0.ExperimentArgs{
			Allocations: auth0.ExperimentAllocationArray{
				&auth0.ExperimentAllocationArgs{
					VariationId: loginUi.VariationIds.ApplyT(func(variationIds map[string]string) (string, error) {
						return variationIds["control"], nil
					}).(pulumi.StringOutput),
					IsControl: pulumi.Bool(true),
					Weight:    pulumi.Int(50),
				},
				&auth0.ExperimentAllocationArgs{
					VariationId: loginUi.VariationIds.ApplyT(func(variationIds map[string]string) (string, error) {
						return variationIds["new-login"], nil
					}).(pulumi.StringOutput),
					IsControl: pulumi.Bool(false),
					Weight:    pulumi.Int(50),
				},
			},
			Name:               pulumi.String("login-ui-percentage-test"),
			Description:        pulumi.String("Show the new login UI to half of the traffic."),
			FeatureFlagId:      loginUi.ID(),
			AuthenticationFlow: pulumi.String("authentication"),
			AllocationStrategy: pulumi.String("percentage"),
			Status:             pulumi.String("draft"),
		})
		if err != nil {
			return err
		}
		usTraffic, err := auth0.NewExperimentSegment(ctx, "us_traffic", &auth0.ExperimentSegmentArgs{
			Rules: auth0.ExperimentSegmentRuleArray{
				&auth0.ExperimentSegmentRuleArgs{
					Match: &auth0.ExperimentSegmentRuleMatchArgs{
						Country: &auth0.ExperimentSegmentRuleMatchCountryArgs{
							Contains: pulumi.StringArray{
								pulumi.String("US"),
							},
						},
					},
				},
			},
			Name: pulumi.String("us-traffic"),
		})
		if err != nil {
			return err
		}
		// Segment strategy: route each segment to a variation; other traffic gets the
		// fallback allocation.
		_, err = auth0.NewExperiment(ctx, "segment", &auth0.ExperimentArgs{
			Allocations: auth0.ExperimentAllocationArray{
				&auth0.ExperimentAllocationArgs{
					VariationId: loginUi.VariationIds.ApplyT(func(variationIds map[string]string) (string, error) {
						return variationIds["control"], nil
					}).(pulumi.StringOutput),
					IsControl: pulumi.Bool(true),
					SegmentId: usTraffic.ID(),
					Priority:  pulumi.Int(1),
				},
				&auth0.ExperimentAllocationArgs{
					VariationId: loginUi.VariationIds.ApplyT(func(variationIds map[string]string) (string, error) {
						return variationIds["new-login"], nil
					}).(pulumi.StringOutput),
					IsControl:  pulumi.Bool(false),
					IsFallback: pulumi.Bool(true),
				},
			},
			Name:               pulumi.String("login-ui-segment-test"),
			Description:        pulumi.String("Keep US traffic on the current login UI and show the new UI elsewhere."),
			FeatureFlagId:      loginUi.ID(),
			AuthenticationFlow: pulumi.String("mfa_challenge"),
			AllocationStrategy: pulumi.String("segment"),
			Status:             pulumi.String("draft"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Auth0 = Pulumi.Auth0;

return await Deployment.RunAsync(() => 
{
    var loginUi = new Auth0.ExperimentFeatureFlag("login_ui", new()
    {
        Parameters = new[]
        {
            new Auth0.Inputs.ExperimentFeatureFlagParameterArgs
            {
                Name = "show_new_login",
                Type = "boolean",
                Value = "false",
            },
        },
        Variations = new[]
        {
            new Auth0.Inputs.ExperimentFeatureFlagVariationArgs
            {
                Name = "control",
            },
            new Auth0.Inputs.ExperimentFeatureFlagVariationArgs
            {
                Overrides = new[]
                {
                    new Auth0.Inputs.ExperimentFeatureFlagVariationOverrideArgs
                    {
                        Name = "show_new_login",
                        Type = "boolean",
                        Value = "true",
                    },
                },
                Name = "new-login",
            },
        },
        Name = "new-login-ui",
        Description = "Controls whether the new login UI is shown.",
        Status = "active",
    });

    // Percentage strategy: split traffic between variations by weight.
    var percentage = new Auth0.Experiment("percentage", new()
    {
        Allocations = new[]
        {
            new Auth0.Inputs.ExperimentAllocationArgs
            {
                VariationId = loginUi.VariationIds.Apply(variationIds => variationIds.Control),
                IsControl = true,
                Weight = 50,
            },
            new Auth0.Inputs.ExperimentAllocationArgs
            {
                VariationId = loginUi.VariationIds.Apply(variationIds => variationIds.New_login),
                IsControl = false,
                Weight = 50,
            },
        },
        Name = "login-ui-percentage-test",
        Description = "Show the new login UI to half of the traffic.",
        FeatureFlagId = loginUi.Id,
        AuthenticationFlow = "authentication",
        AllocationStrategy = "percentage",
        Status = "draft",
    });

    var usTraffic = new Auth0.ExperimentSegment("us_traffic", new()
    {
        Rules = new[]
        {
            new Auth0.Inputs.ExperimentSegmentRuleArgs
            {
                Match = new Auth0.Inputs.ExperimentSegmentRuleMatchArgs
                {
                    Country = new Auth0.Inputs.ExperimentSegmentRuleMatchCountryArgs
                    {
                        Contains = new[]
                        {
                            "US",
                        },
                    },
                },
            },
        },
        Name = "us-traffic",
    });

    // Segment strategy: route each segment to a variation; other traffic gets the
    // fallback allocation.
    var segment = new Auth0.Experiment("segment", new()
    {
        Allocations = new[]
        {
            new Auth0.Inputs.ExperimentAllocationArgs
            {
                VariationId = loginUi.VariationIds.Apply(variationIds => variationIds.Control),
                IsControl = true,
                SegmentId = usTraffic.Id,
                Priority = 1,
            },
            new Auth0.Inputs.ExperimentAllocationArgs
            {
                VariationId = loginUi.VariationIds.Apply(variationIds => variationIds.New_login),
                IsControl = false,
                IsFallback = true,
            },
        },
        Name = "login-ui-segment-test",
        Description = "Keep US traffic on the current login UI and show the new UI elsewhere.",
        FeatureFlagId = loginUi.Id,
        AuthenticationFlow = "mfa_challenge",
        AllocationStrategy = "segment",
        Status = "draft",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.ExperimentFeatureFlag;
import com.pulumi.auth0.ExperimentFeatureFlagArgs;
import com.pulumi.auth0.inputs.ExperimentFeatureFlagParameterArgs;
import com.pulumi.auth0.inputs.ExperimentFeatureFlagVariationArgs;
import com.pulumi.auth0.inputs.ExperimentFeatureFlagVariationOverrideArgs;
import com.pulumi.auth0.Experiment;
import com.pulumi.auth0.ExperimentArgs;
import com.pulumi.auth0.inputs.ExperimentAllocationArgs;
import com.pulumi.auth0.ExperimentSegment;
import com.pulumi.auth0.ExperimentSegmentArgs;
import com.pulumi.auth0.inputs.ExperimentSegmentRuleArgs;
import com.pulumi.auth0.inputs.ExperimentSegmentRuleMatchArgs;
import com.pulumi.auth0.inputs.ExperimentSegmentRuleMatchCountryArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var loginUi = new ExperimentFeatureFlag("loginUi", ExperimentFeatureFlagArgs.builder()
            .parameters(ExperimentFeatureFlagParameterArgs.builder()
                .name("show_new_login")
                .type("boolean")
                .value("false")
                .build())
            .variations(            
                ExperimentFeatureFlagVariationArgs.builder()
                    .name("control")
                    .build(),
                ExperimentFeatureFlagVariationArgs.builder()
                    .overrides(ExperimentFeatureFlagVariationOverrideArgs.builder()
                        .name("show_new_login")
                        .type("boolean")
                        .value("true")
                        .build())
                    .name("new-login")
                    .build())
            .name("new-login-ui")
            .description("Controls whether the new login UI is shown.")
            .status("active")
            .build());

        // Percentage strategy: split traffic between variations by weight.
        var percentage = new Experiment("percentage", ExperimentArgs.builder()
            .allocations(            
                ExperimentAllocationArgs.builder()
                    .variationId(loginUi.variationIds().applyValue(_variationIds -> _variationIds.get("control")))
                    .isControl(true)
                    .weight(50)
                    .build(),
                ExperimentAllocationArgs.builder()
                    .variationId(loginUi.variationIds().applyValue(_variationIds -> _variationIds.get("new-login")))
                    .isControl(false)
                    .weight(50)
                    .build())
            .name("login-ui-percentage-test")
            .description("Show the new login UI to half of the traffic.")
            .featureFlagId(loginUi.id())
            .authenticationFlow("authentication")
            .allocationStrategy("percentage")
            .status("draft")
            .build());

        var usTraffic = new ExperimentSegment("usTraffic", ExperimentSegmentArgs.builder()
            .rules(ExperimentSegmentRuleArgs.builder()
                .match(ExperimentSegmentRuleMatchArgs.builder()
                    .country(ExperimentSegmentRuleMatchCountryArgs.builder()
                        .contains("US")
                        .build())
                    .build())
                .build())
            .name("us-traffic")
            .build());

        // Segment strategy: route each segment to a variation; other traffic gets the
        // fallback allocation.
        var segment = new Experiment("segment", ExperimentArgs.builder()
            .allocations(            
                ExperimentAllocationArgs.builder()
                    .variationId(loginUi.variationIds().applyValue(_variationIds -> _variationIds.get("control")))
                    .isControl(true)
                    .segmentId(usTraffic.id())
                    .priority(1)
                    .build(),
                ExperimentAllocationArgs.builder()
                    .variationId(loginUi.variationIds().applyValue(_variationIds -> _variationIds.get("new-login")))
                    .isControl(false)
                    .isFallback(true)
                    .build())
            .name("login-ui-segment-test")
            .description("Keep US traffic on the current login UI and show the new UI elsewhere.")
            .featureFlagId(loginUi.id())
            .authenticationFlow("mfa_challenge")
            .allocationStrategy("segment")
            .status("draft")
            .build());

    }
}

resources:
  loginUi:
    type: auth0:ExperimentFeatureFlag
    name: login_ui
    properties:
      parameters:
        - name: show_new_login
          type: boolean
          value: 'false'
      variations:
        - name: control
        - overrides:
            - name: show_new_login
              type: boolean
              value: 'true'
          name: new-login
      name: new-login-ui
      description: Controls whether the new login UI is shown.
      status: active
  # Percentage strategy: split traffic between variations by weight.
  percentage:
    type: auth0:Experiment
    properties:
      allocations:
        - variationId: ${loginUi.variationIds.control}
          isControl: true
          weight: 50
        - variationId: ${loginUi.variationIds["new-login"]}
          isControl: false
          weight: 50
      name: login-ui-percentage-test
      description: Show the new login UI to half of the traffic.
      featureFlagId: ${loginUi.id}
      authenticationFlow: authentication
      allocationStrategy: percentage
      status: draft
  usTraffic:
    type: auth0:ExperimentSegment
    name: us_traffic
    properties:
      rules:
        - match:
            country:
              contains:
                - US
      name: us-traffic
  # Segment strategy: route each segment to a variation; other traffic gets the
  # fallback allocation.
  segment:
    type: auth0:Experiment
    properties:
      allocations:
        - variationId: ${loginUi.variationIds.control}
          isControl: true
          segmentId: ${usTraffic.id}
          priority: 1
        - variationId: ${loginUi.variationIds["new-login"]}
          isControl: false
          isFallback: true
      name: login-ui-segment-test
      description: Keep US traffic on the current login UI and show the new UI elsewhere.
      featureFlagId: ${loginUi.id}
      authenticationFlow: mfa_challenge
      allocationStrategy: segment
      status: draft

terraform {
  required_providers {
    auth0 = {
      source = "pulumi/auth0"
    }
  }
}

resource "auth0_experiment_feature_flag" "login_ui" {
  lifecycle {
    create_before_destroy = true
  }
  parameters {
    name  = "show_new_login"
    type  = "boolean"
    value = "false"
  }
  variations {
    name = "control"
  }
  variations {
    overrides {
      name  = "show_new_login"
      type  = "boolean"
      value = "true"
    }
    name = "new-login"
  }
  name        = "new-login-ui"
  description = "Controls whether the new login UI is shown."
  status      = "active"
}
# Percentage strategy: split traffic between variations by weight.
resource "auth0_experiment" "percentage" {
  lifecycle {
    create_before_destroy = true
  }
  allocations {
    variation_id = auth0_experiment_feature_flag.login_ui.variation_ids["control"]
    is_control   = true
    weight       = 50
  }
  allocations {
    variation_id = auth0_experiment_feature_flag.login_ui.variation_ids["new-login"]
    is_control   = false
    weight       = 50
  }
  name                = "login-ui-percentage-test"
  description         = "Show the new login UI to half of the traffic."
  feature_flag_id     = auth0_experiment_feature_flag.login_ui.id
  authentication_flow = "authentication"
  allocation_strategy = "percentage"
  status              = "draft"
}
resource "auth0_experiment_segment" "us_traffic" {
  lifecycle {
    create_before_destroy = true
  }
  rules {
    match {
      country {
        contains = ["US"]
      }
    }
  }
  name = "us-traffic"
}
# Segment strategy: route each segment to a variation; other traffic gets the
# fallback allocation.
resource "auth0_experiment" "segment" {
  lifecycle {
    create_before_destroy = true
  }
  allocations {
    variation_id = auth0_experiment_feature_flag.login_ui.variation_ids["control"]
    is_control   = true
    segment_id   = auth0_experiment_segment.us_traffic.id
    priority     = 1
  }
  allocations {
    variation_id = auth0_experiment_feature_flag.login_ui.variation_ids["new-login"]
    is_control   = false
    is_fallback  = true
  }
  name                = "login-ui-segment-test"
  description         = "Keep US traffic on the current login UI and show the new UI elsewhere."
  feature_flag_id     = auth0_experiment_feature_flag.login_ui.id
  authentication_flow = "mfa_challenge"
  allocation_strategy = "segment"
  status              = "draft"
}

var experimentResource = new Auth0.Experiment("experimentResource", new()
{
    AllocationStrategy = "string",
    AuthenticationFlow = "string",
    FeatureFlagId = "string",
    Allocations = new[]
    {
        new Auth0.Inputs.ExperimentAllocationArgs
        {
            IsControl = false,
            VariationId = "string",
            IsFallback = false,
            Priority = 0,
            SegmentId = "string",
            SegmentName = "string",
            SegmentSnapshot = "string",
            VariationName = "string",
            VariationSnapshot = "string",
            Weight = 0,
        },
    },
    DefaultConfig = "string",
    Description = "string",
    Levels = new[]
    {
        0,
    },
    Name = "string",
    Status = "string",
});

example, err := auth0.NewExperiment(ctx, "experimentResource", &auth0.ExperimentArgs{
	AllocationStrategy: pulumi.String("string"),
	AuthenticationFlow: pulumi.String("string"),
	FeatureFlagId:      pulumi.String("string"),
	Allocations: auth0.ExperimentAllocationArray{
		&auth0.ExperimentAllocationArgs{
			IsControl:         pulumi.Bool(false),
			VariationId:       pulumi.String("string"),
			IsFallback:        pulumi.Bool(false),
			Priority:          pulumi.Int(0),
			SegmentId:         pulumi.String("string"),
			SegmentName:       pulumi.String("string"),
			SegmentSnapshot:   pulumi.String("string"),
			VariationName:     pulumi.String("string"),
			VariationSnapshot: pulumi.String("string"),
			Weight:            pulumi.Int(0),
		},
	},
	DefaultConfig: pulumi.String("string"),
	Description:   pulumi.String("string"),
	Levels: pulumi.IntArray{
		pulumi.Int(0),
	},
	Name:   pulumi.String("string"),
	Status: pulumi.String("string"),
})

resource "auth0_experiment" "experimentResource" {
  lifecycle {
    create_before_destroy = true
  }
  allocation_strategy = "string"
  authentication_flow = "string"
  feature_flag_id     = "string"
  allocations {
    is_control         = false
    variation_id       = "string"
    is_fallback        = false
    priority           = 0
    segment_id         = "string"
    segment_name       = "string"
    segment_snapshot   = "string"
    variation_name     = "string"
    variation_snapshot = "string"
    weight             = 0
  }
  default_config = "string"
  description    = "string"
  levels         = [0]
  name           = "string"
  status         = "string"
}

var experimentResource = new Experiment("experimentResource", ExperimentArgs.builder()
    .allocationStrategy("string")
    .authenticationFlow("string")
    .featureFlagId("string")
    .allocations(ExperimentAllocationArgs.builder()
        .isControl(false)
        .variationId("string")
        .isFallback(false)
        .priority(0)
        .segmentId("string")
        .segmentName("string")
        .segmentSnapshot("string")
        .variationName("string")
        .variationSnapshot("string")
        .weight(0)
        .build())
    .defaultConfig("string")
    .description("string")
    .levels(0)
    .name("string")
    .status("string")
    .build());

experiment_resource = auth0.Experiment("experimentResource",
    allocation_strategy="string",
    authentication_flow="string",
    feature_flag_id="string",
    allocations=[{
        "is_control": False,
        "variation_id": "string",
        "is_fallback": False,
        "priority": 0,
        "segment_id": "string",
        "segment_name": "string",
        "segment_snapshot": "string",
        "variation_name": "string",
        "variation_snapshot": "string",
        "weight": 0,
    }],
    default_config="string",
    description="string",
    levels=[0],
    name="string",
    status="string")

const experimentResource = new auth0.Experiment("experimentResource", {
    allocationStrategy: "string",
    authenticationFlow: "string",
    featureFlagId: "string",
    allocations: [{
        isControl: false,
        variationId: "string",
        isFallback: false,
        priority: 0,
        segmentId: "string",
        segmentName: "string",
        segmentSnapshot: "string",
        variationName: "string",
        variationSnapshot: "string",
        weight: 0,
    }],
    defaultConfig: "string",
    description: "string",
    levels: [0],
    name: "string",
    status: "string",
});

type: auth0:Experiment
properties:
    allocationStrategy: string
    allocations:
        - isControl: false
          isFallback: false
          priority: 0
          segmentId: string
          segmentName: string
          segmentSnapshot: string
          variationId: string
          variationName: string
          variationSnapshot: string
          weight: 0
    authenticationFlow: string
    defaultConfig: string
    description: string
    featureFlagId: string
    levels:
        - 0
    name: string
    status: string