Test data sources

1
using LaunchDarkly.Sdk.Client.Integrations;
2
3
var td = TestData.DataSource();
4
// You can set any initial flag states here with td.Update
5
6
var config = Configuration
7
    .Builder("mobile-key-123abc", ConfigurationBuilder.AutoEnvAttributes.Enabled)
8
    .DataSource(td)
9
    .Build();
10
var client = LdClient.Init(config, context, startWaitTime);

1
td.Update(td.Flag("flag-key-123abc").Variation(false);

1
// This flag is true for the context key "context-key-123abc" and false for everyone else
2
td.Update(td.Flag("flag-key-456def")
3
    .Variation(false)
4
    .VariationForKey(ContextKind.Of("user"), "context-key-123abc", true));
5
6
// This flag returns the string variation "green" for contexts where the custom
7
// attribute "admin" has a value of true, and "red" for all other contexts.
8
td.Update(td.Flag("flag-key-789ghi")
9
    .Variations(LdValue.Of("red"), LdValue.Of("green"))
10
    .VariationFunc(context =>
11
        context.GetValue("admin").AsBool ? 1 : 0);

1
using com.launchdarkly.sdk.*;
2
using com.launchdarkly.sdk.server.*;
3
using com.launchdarkly.sdk.server.integrations.*;
4
5
TestData td = TestData.dataSource();
6
// You can set any initial flag states here with td.update
7
8
LDConfig config = new LDConfig.Builder(AutoEnvAttributes.Enabled)
9
  .mobileKey("mobile-key-123abc")
10
  .dataSource(td)
11
  .build();
12
LDClient client = LDClient.init(this.getApplication(), ldConfig, context, secondsToBlock);

1
td.update(td.flag("flag-key-123abc").variation(false));

1
// This flag is true for the context with the key "context-key-123abc" and kind of "organization",
2
// and false for everyone else
3
td.update(td.flag("flag-key-123abc")
4
  .variation(false)
5
  .variationForKey(ContextKind.of("organization"), "context-key-123abc", true));
6
7
// This flag returns the string variation "green" for contexts who have the custom
8
// attribute "admin" with a value of true, and "red" for everyone else.
9
td.update(td.flag("flag-key-123abc")
10
  .variations(LDValue.of("red"), LDValue.of("green"))
11
  .variationFunc(context ->
12
    context.getValue("admin").booleanValue() ? 1 : 0));

1
using LaunchDarkly.Sdk.Server.Integrations;
2
3
var td = TestData.DataSource();
4
// You can set any initial flag states here with td.Update
5
6
var config = Configuration.Builder("sdk-key-123abc")
7
    .DataSource(td)
8
    .Build();
9
var client = new LdClient(config);

1
td.Update(td.Flag("flag-key-123abc").VariationForAll(false));

1
// This flag is true for the context with the key "context-key-123abc" and kind of "organization",
2
// and false for everyone else
3
td.Update(td.Flag("flag-key-456def")
4
    .VariationForKey(ContextKind.Of("organization"), "context-key-123abc", true)
5
    .FallthroughVariation(false));
6
7
// This flag returns the string variation "green" for contexts that have the
8
// attribute "admin" with a value of true, and "red" for everyone else.
9
td.Update(td.Flag("flag-key-789ghi")
10
    .Variations(LdValue.Of("red"), LdValue.Of("green"))
11
    .FallthroughVariation(0)
12
    .IfMatch("admin", LdValue.Of(true))
13
    .ThenReturn(1));

1
#include <launchdarkly/integrations/test_data.h>
2
3
struct LDTestData *td = LDTestDataInit();
4
5
LDConfigSetDataSource(config, LDTestDataCreateDataSource(td));
6
7
// Call LDClientInit with config as usual.

1
// After LDClientClose:
2
LDTestDataFree(td)

1
struct LDFlagBuilder *flag = LDTestDataFlag(td, "flag-key-123abc");
2
LDFlagBuilderVariationForAllUsersBoolean(flag, LDBooleanTrue);
3
LDTestDataUpdate(td, flag);

1
// This flag is true for the user key "user-key-123abc"
2
// and false for everyone else.
3
struct LDFlagBuilder *flag2 = LDTestDataFlag(td, "flag-key-456def");
4
LDFlagBuilderVariationForUserBoolean(flag2, "user-key-123abc", LDBooleanTrue);
5
LDFlagBuilderFallthroughVariationBoolean(flag2, LDBooleanFalse);
6
LDTestDataUpdate(td, flag2);
7
8
9
// This flag returns the string variation "green" for
10
// users who have the custom attribute "admin" with a
11
// value of true, and "red" for everyone else.
12
13
struct LDJSON *variations = LDNewArray();
14
LDArrayPush(variations, LDNewText("red"));
15
LDArrayPush(variations, LDNewText("green"));
16
17
struct LDFlagBuilder *flag3 = LDTestDataFlag(td, "flag-key-789ghi");
18
LDFlagBuilderVariations(flag3, variations);
19
LDFlagBuilderFallthroughVariation(flag3, 0);
20
21
struct LDFlagRuleBuilder *rule = LDFlagBuilderIfMatch(flag3, "admin", LDNewBool(LDBooleanTrue));
22
LDFlagRuleBuilderThenReturn(rule, 1);
23
24
LDTestDataUpdate(td, flag3);

1
Options = #{
2
  datasource => testdata,
3
  send_events => false,
4
  feature_store => ldclient_storage_map
5
},
6
ldclient:start_instance(SdkKey, Options),

1
{ok, Flag} = ldclient_testdata:flag("flag-key-123abc"),
2
ldclient_testdata:update(ldclient_flagbuilder:variation_for_all(true, Flag)),

1
%% This flag is true for the context key "user-key-123abc" and false for everyone else
2
{ok, Flag2} = ldclient_testdata:flag("flag-key-456def"),
3
UpdatedFlag2 = ldclient_flagbuilder:fallthrough_variation(false,
4
  ldclient_flagbuilder:variation_for_context(true,  <<"user">>, <<"user-key-123abc">>, Flag2)
5
),
6
7
%% This flag returns the string variation "green" for contexts that have the custom
8
%% attribute "admin" with a value of true, and "red" for everyone else.
9
{ok, Flag} = ldclient_testdata:flag("flag-key-789ghi"),
10
UpdatedFlag = ldclient_flagbuilder:fallthrough_variation(0,
11
              ldclient_flagbuilder:then_return(1,
12
              ldclient_flagbuilder:if_match(<<"user">>, <<"admin">>, [true],
13
              ldclient_flagbuilder:variations([<<"red">>, <<"green">>], Flag)))),
14
ldclient_testdata:update(UpdatedFlag),

1
import (
2
    ld "github.com/launchdarkly/go-server-sdk/v6"
3
    "github.com/launchdarkly/go-server-sdk/v6/testhelpers/ldtestdata"
4
    "github.com/launchdarkly/go-sdk-common/v3/ldcontext"
5
    "github.com/launchdarkly/go-sdk-common/v3/ldvalue"
6
)
7
8
td := ldtestdata.DataSource()
9
// You can set any initial flag states here with td.Update
10
11
config := ld.Config{
12
    DataSource: td,
13
}
14
client, _ := ld.MakeCustomClient("sdk-key-123abc", config, 0)

1
td.Update(td.Flag("flag-key-123abc").VariationForAll(false))

1
// This flag is true for the context with the key "context-key-123abc" and kind of "organization",
2
// and false for everyone else
3
td.Update(td.Flag("flag-key-456def").
4
    VariationForKey("organization", "context-key-123abc", true).
5
    FallthroughVariation(false));
6
7
8
// This flag returns the string variation "green" for contexts that have the
9
// attribute "admin" with a value of true, and "red" for everyone else.
10
td.Update(td.Flag("flag-key-789ghi").
11
    Variations(ldvalue.String("red"), ldvalue.String("green")).
12
    FallthroughVariationIndex(0).
13
    IfMatch(ldcontext.GetValue("admin"), ldvalue.Bool(true)).
14
    ThenReturnIndex(1));

1
import qualified LaunchDarkly.Server.Integrations.TestData as TestData
2
3
 td <- TestData.newTestData
4
 let config = LD.configSetDataSourceFactory (Just $ TestData.dataSourceFactory td) $ LD.makeConfig "sdk-key-123abc"
5
 client <- LD.makeClient config

1
TestData.update td =<< ( TestData.flag td "flag-key-123abc"
2
	<&> TestData.booleanFlag
3
	<&> TestData.variationForAll True
4
)

1
-- This flag is true for the context with kind "context-kind" and key "context-key-123abc", and false for everyone else
2
TestData.update td =<< ( TestData.flag td "flag-key-456def"
3
	<&> TestData.booleanFlag
4
	<&> TestData.variationForKey "context-kind" "context-key-123abc" (0 :: TestData.VariationIndex)
5
	<&> TestData.fallthroughVariation (1 :: TestData.VariationIndex)
6
)
7
8
-- This flag returns the string variation "green" for contexts with kind "context-kind"
9
-- that have the custom attribute "admin" with a value of true, and "red" for everyone else.
10
TestData.update td =<< ( TestData.flag td "flag-key-456def"
11
	<&> TestData.variations [toJSON "red", toJSON "green"]
12
	<&> TestData.ifMatchContext "context-kind" "admin" [Aeson.Bool True]
13
	<&> TestData.thenReturn (1 :: TestData.VariationIndex)
14
	<&> TestData.fallthroughVariation (0 :: TestData.VariationIndex))
15
)

1
using com.launchdarkly.sdk.*;
2
using com.launchdarkly.sdk.server.*;
3
using com.launchdarkly.sdk.server.integrations.*;
4
5
TestData td = TestData.dataSource();
6
// You can set any initial flag states here with td.update
7
8
LDConfig config = new LDConfig.Builder()
9
    .dataSource(td)
10
    .build();
11
LDClient client = new LDClient(sdkKey, config);

1
td.update(td.flag("flag-key-123abc").variationForAll(false));

1
// This flag is true for the context with the key "context-key-123abc" and kind of "organization",
2
// and false for everyone else
3
td.update(td.flag("flag-key-123abc")
4
  .variationForKey(ContextKind.of("organization"), "context-key-123abc", true)
5
  .fallthroughVariation(false));
6
7
// This flag returns the string variation "green" for contexts who have the custom
8
// attribute "admin" with a value of true, and "red" for everyone else.
9
td.update(td.flag("flag-key-123abc")
10
  .variations(LDValue.of("red"), LDValue.of("green"))
11
  .fallthroughVariation(0)
12
  .ifMatch(ContextAttribute.forName("admin"), LDValue.of(true))
13
  .thenReturn(1));

1
const { TestData } = require('@launchdarkly/node-server-sdk/integrations');
2
3
const td = new TestData();
4
testData.update(td.flag('flag-key-123abc').booleanFlag().variationForAllUsers(true));
5
const client = new LDClient('sdk-key-123abc', { updateProcessor: td.getFactory() });
6
7
// flags can be updated at any time:
8
td.update(td.flag('flag-key-456def')
9
    .variationForUser('user-key-123abc', true)
10
    .fallthroughVariation(false));

1
require 'vendor/autoload.php';
2
3
$td = new LaunchDarkly\Integrations\TestData();
4
// You can set any initial flag states here with td.update
5
6
$client = new LaunchDarkly\LDClient($sdkKey, ['feature_requester' => $td]);

1
$td->update($td->flag("flag-key-123abc")->variationForAll(false));

1
// This flag is true for the context with the key "context-key-123abc" and kind of "organization",
2
// and false for everyone else
3
$td->update(
4
    $td->flag("flag-key-123abc")
5
       ->variationForKey("organization", "context-key-123abc", true)
6
       ->fallthroughVariation(false)
7
);
8
9
// This flag returns the string variation "green" for contexts that have the custom
10
// attribute "admin" with a value of true, and "red" for everyone else.
11
$td->update(
12
    $td->flag("flag-key-123abc")
13
       ->variations("red", "green")
14
       ->fallthroughVariation(0)
15
       ->ifMatch("admin", true)
16
       ->thenReturn(1)
17
);

1
from ldclient.integrations.test_data import TestData
2
from ldclient import LDClient, Config
3
4
td = TestData.data_source()
5
# You can set any initial flag states here with td.update
6
client = LDClient(config=Config(sdk_key, update_processor_class = td))

1
td.update(td.flag("flag-key-123abc").variation_for_all(True))

1
# This flag is true for the context with the key "context-key-123abc" and kind
2
# of "organization", and false for everyone else.
3
4
td.update(
5
    td.flag("flag-key-456def") \
6
        .variation_for_key("organization", "context-key-123abc", True) \
7
        .fallthrough_variation(False)
8
)
9
10
# This flag returns the string variation "green" for contexts of the kind "user"
11
# who have the custom attribute "admin" with a value of true, and "red" for
12
# everyone else.
13
td.update(
14
    td.flag("flag-key-789ghi") \
15
        .variations("red", "green")
16
        .fallthrough_variation(0)
17
        .if_match_context("user", "admin", True)
18
        .then_return(1)
19
)

1
require 'ldclient-rb'
2
3
td = LaunchDarkly::Integrations::TestData.data_source
4
# You can set any initial flag states here with td.update
5
6
config = LaunchDarkly::Config.new(data_source = td)
7
client = LaunchDarkly::LDClient.new(sdk_key, config)

1
td.update(td.flag("flag-key-123abc").variation_for_all(false))

1
# This flag is true for the context key "context-key-123abc" and false for everyone else
2
td.update(td.flag("flag-key-456def").
3
    variation_for_user("context-key-123abc", true).
4
    fallthrough_variation(false))
5
6
# This flag returns the string variation "green" for contexts who have the custom
7
# attribute "admin" with a value of true, and "red" for everyone else.
8
td.update(td.flag("flag-key-789ghi").
9
    variations("red", "green").
10
    fallthrough_variation(0).
11
    if_match_context("user", "admin", true).then_return(1))