// Snippet Start
public static void Run(string fileName)
{
// DataSet is the object used to interact with the data file.
// DataSetBuilder creates Dataset with pool of binary readers to
// perform device lookup using file on disk. The type is
// disposable and is therefore contained in using block to
// ensure file handles and resources are freed.
using (DataSet dataSet = DataSetBuilder.File()
.ConfigureDefaultCaches()
// Set the cache size for the Values cache to 200,000
// This is done because FindProfiles performs significantly
// faster when all Value objects can be held in memory.
// The number of Value objects varies by data file type:
// Lite < 5000
// Premium < 180,000
// Enterprise < 200,000
.SetCacheSize(CacheType.ValuesCache, 200000)
.SetTempFile(false)
.Build(fileName))
{
Console.WriteLine("Staring Find Profiles Example.");
// Retrieve all mobile profiles from the data set.
Profile[] profiles = dataSet.FindProfiles("IsMobile", "True");
Console.WriteLine("There are " + profiles.Count()
+ " mobile profiles in the " + dataSet.Name
+ " data set.");
// Retrieve all non-mobile profiles from the data set.
profiles = dataSet.FindProfiles("IsMobile", "False");
Console.WriteLine("There are " + profiles.Count()
+ " non-mobile profiles in the " + dataSet.Name
+ " data set.");
}
}
public void CorrectColumnsWhenAddingMultiple()
{
var datasetBuilder = new DataSetBuilder();
var dataSet = datasetBuilder
.AddDataTable("Users")
.AddColumns(new Column {
Name = "Id", Type = typeof(int)
}, new Column {
Name = "FirstName"
})
.Build();
Assert.That(dataSet.Tables.Count, Is.EqualTo(1));
var table = dataSet.Tables[0];
Assert.That(table.Columns.Count, Is.EqualTo(2));
Assert.That(table.Columns.Contains("Id"));
Assert.That(table.Columns.Contains("Firstname"));
Assert.That(table.Columns[0].DataType, Is.EqualTo(typeof(int)));
Assert.That(table.Columns[1].DataType, Is.EqualTo(typeof(string)));
}
public void UpsertUpdatesPersistentStore()
{
var flag1a = new FeatureFlagBuilder().Version(1).Value(true).Build();
var flag1b = new FeatureFlagBuilder().Version(2).Value(true).Build();
var flag2 = new FeatureFlagBuilder().Version(1).Value(false).Build();
var data1a = new DataSetBuilder().Add("flag1", flag1a).Add("flag2", flag2).Build();
var data1b = new DataSetBuilder().Add("flag1", flag1b).Add("flag2", flag2).Build();
var store = MakeStore(1);
store.Init(BasicUser, data1a, true);
var updated = store.Upsert("flag1", flag1b.ToItemDescriptor());
Assert.True(updated);
var item = store.Get("flag1"); // this is reading only from memory, not the persistent store
Assert.Equal(flag1b.ToItemDescriptor(), item);
var data = _persistentStore.InspectUserData(BasicMobileKey, BasicUser.Key);
Assert.NotNull(data);
AssertHelpers.DataSetsEqual(data1b, data.Value);
}
public void CorrectDatasetReturned()
{
var datasetBuilder =
new DataSetBuilder().AddDataTable("Users")
.AddColumn("Id", typeof(int))
.AddColumn("Firstname")
.AddColumn("Lastname")
.AddColumn("DateOfBirth", typeof(DateTime))
.AddColumn("IsActive", typeof(bool))
.AddRow(1, "Andy", "Robinson", "1980-04-06", true)
.AddRow(2, "Dave", "Clarke", "1970-03-28", true)
.AddDataTable("Logins")
.AddColumn("Id", typeof(Guid))
.AddColumn("UserId", typeof(int))
.AddColumn("LoginDate", typeof(DateTime))
.AddRow(Guid.NewGuid(), 1, "2014-12-19");
var result = datasetBuilder.Build();
Assert.That(result.Tables.Count, Is.EqualTo(2));
Assert.That(result.Tables[0].TableName, Is.EqualTo("Users"));
Assert.That(result.Tables[1].TableName, Is.EqualTo("Logins"));
var users = result.Tables["Users"];
Assert.That(users.Rows.Count, Is.EqualTo(2));
Assert.That(users.Rows[0][0].ToString(), Is.EqualTo("Andy"));
Assert.That(users.Rows[0][1].ToString(), Is.EqualTo("Robinson"));
Assert.That(users.Rows[0][2].ToString(), Is.EqualTo(""));
}
public void CorrectColumnsAreCreated()
{
var datasetBuilder = new DataSetBuilder();
var dataSet = datasetBuilder.AddDataTable("Users")
.AddColumn("Id", typeof(int))
.AddColumn("Firstname")
.AddColumn("Lastname")
.AddColumn("DateOfBirth", typeof(DateTime))
.AddColumn("IsActive", typeof(bool))
.Build();
Assert.That(dataSet.Tables.Count, Is.EqualTo(1));
var table = dataSet.Tables[0];
Assert.That(table.Columns.Count, Is.EqualTo(5));
Assert.That(table.Columns.Contains("Id"));
Assert.That(table.Columns.Contains("Firstname"));
Assert.That(table.Columns.Contains("Lastname"));
Assert.That(table.Columns.Contains("DateOfBirth"));
Assert.That(table.Columns.Contains("IsActive"));
Assert.That(table.Columns[0].DataType, Is.EqualTo(typeof(int)));
Assert.That(table.Columns[1].DataType, Is.EqualTo(typeof(string)));
Assert.That(table.Columns[2].DataType, Is.EqualTo(typeof(string)));
Assert.That(table.Columns[3].DataType, Is.EqualTo(typeof(DateTime)));
Assert.That(table.Columns[4].DataType, Is.EqualTo(typeof(bool)));
}
public void SendsEventsOnUpdateForFlagsWhosePrerequisitesChanged()
{
var dataBuilder = new DataSetBuilder().Flags(
new FeatureFlagBuilder("flag1").Version(1).Build(),
new FeatureFlagBuilder("flag2").Version(1)
.Prerequisites(new Prerequisite("flag1", 0)).Build(),
new FeatureFlagBuilder("flag3").Version(1).Build(),
new FeatureFlagBuilder("flag4").Version(1)
.Prerequisites(new Prerequisite("flag1", 0)).Build(),
new FeatureFlagBuilder("flag5").Version(1)
.Prerequisites(new Prerequisite("flag4", 0)).Build(),
new FeatureFlagBuilder("flag6").Version(1).Build()
);
var updates = MakeInstance();
updates.Init(dataBuilder.Build());
var eventSink = new EventSink <FlagChangeEvent>();
updates.FlagChanged += eventSink.Add;
updates.Upsert(DataModel.Features, "flag1", DescriptorOf(
new FeatureFlagBuilder("flag1").Version(2).Build()));
ExpectFlagChangeEvents(eventSink, "flag1", "flag2", "flag4", "flag5");
}
public void EventIsSentForChangedFlagOnInit()
{
var events = new EventSink <FlagValueChangeEvent>();
_flagTracker.FlagValueChanged += events.Add;
var initData1 = new DataSetBuilder()
.Add("key1", new FeatureFlagBuilder().Value(LdValue.Of(true)).Variation(0).Build())
.Add("key2", new FeatureFlagBuilder().Value(LdValue.Of(true)).Variation(0).Build())
.Build();
_updateSink.Init(_basicUser, initData1);
var initData2 = new DataSetBuilder()
.Add("key1", new FeatureFlagBuilder().Value(LdValue.Of(false)).Variation(1).Build())
.Add("key2", new FeatureFlagBuilder().Value(LdValue.Of(true)).Variation(0).Build())
.Build();
_updateSink.Init(_basicUser, initData2);
var e = events.ExpectValue();
Assert.Equal("key1", e.Key);
Assert.Equal(LdValue.Of(true), e.OldValue);
Assert.Equal(LdValue.Of(false), e.NewValue);
Assert.False(e.Deleted);
}
public void ValueChangesAreTrackedSeparatelyForEachUser()
{
var events = new EventSink <FlagValueChangeEvent>();
_flagTracker.FlagValueChanged += events.Add;
var initDataForBasicUser = new DataSetBuilder()
.Add("key1", new FeatureFlagBuilder().Version(100).Value(LdValue.Of("a")).Variation(1).Build())
.Add("key2", new FeatureFlagBuilder().Version(200).Value(LdValue.Of("b")).Variation(2).Build())
.Build();
_updateSink.Init(_basicUser, initDataForBasicUser);
var initDataForOtherUser = new DataSetBuilder()
.Add("key1", new FeatureFlagBuilder().Version(100).Value(LdValue.Of("c")).Variation(3).Build())
.Add("key2", new FeatureFlagBuilder().Version(200).Value(LdValue.Of("d")).Variation(4).Build())
.Build();
_updateSink.Init(_otherUser, initDataForOtherUser);
events.ExpectNoValue();
_updateSink.Upsert(_basicUser, "key1",
new FeatureFlagBuilder().Version(101).Value(LdValue.Of("c")).Variation(3).Build().ToItemDescriptor());
var e = events.ExpectValue();
Assert.Equal("key1", e.Key);
Assert.Equal(LdValue.Of("a"), e.OldValue);
Assert.Equal(LdValue.Of("c"), e.NewValue);
}
public void SendsEventsOnUpdateForFlagsWhoseSegmentsChanged()
{
var dataBuilder = new DataSetBuilder().Flags(
new FeatureFlagBuilder("flag1").Version(1).Build(),
new FeatureFlagBuilder("flag2").Version(1)
.Rules(
new RuleBuilder().Clauses(
new ClauseBuilder().Op("segmentMatch").Values(LdValue.Of(segment1.Key)).Build()
).Build()
)
.Build(),
new FeatureFlagBuilder("flag3").Version(1).Build(),
new FeatureFlagBuilder("flag4").Version(1)
.Prerequisites(new Prerequisite("flag2", 0)).Build()
)
.Segments(segment1, segment2);
var updates = MakeInstance();
updates.Init(dataBuilder.Build());
var eventSink = new EventSink <FlagChangeEvent>();
updates.FlagChanged += eventSink.Add;
updates.Upsert(DataModel.Segments, segment1.Key, DescriptorOf(segment1v2));
ExpectFlagChangeEvents(eventSink, "flag2", "flag4");
}
public void AddToData_DuplicateKeysHandling_Throw()
{
const string key = "flag1";
FeatureFlag initialFeatureFlag = new FeatureFlagBuilder(key).Version(0).Build();
var flagData = new Dictionary <string, ItemDescriptor>
{
{ key, new ItemDescriptor(1, initialFeatureFlag) }
};
var segmentData = new Dictionary <string, ItemDescriptor>();
var fileData = new DataSetBuilder()
.Flags(new FeatureFlagBuilder(key).Version(1).Build()).Build();
FlagFileDataMerger merger = new FlagFileDataMerger(FileDataTypes.DuplicateKeysHandling.Throw);
Exception err = Assert.Throws <Exception>(() =>
{
merger.AddToData(fileData, flagData, segmentData);
});
Assert.Equal("in \"features\", key \"flag1\" was already defined", err.Message);
ItemDescriptor postFeatureFlag = flagData[key];
Assert.Same(initialFeatureFlag, postFeatureFlag.Item);
Assert.Equal(1, postFeatureFlag.Version);
}
public void PingCausesPoll()
{
var data = new DataSetBuilder()
.Add("flag1", 1, LdValue.Of(true), 0)
.Build();
var streamWithPing = Handlers.SSE.Start()
.Then(PingEvent)
.Then(Handlers.SSE.LeaveOpen());
using (var pollingServer = HttpServer.Start(PollingResponse(data)))
{
using (var streamingServer = HttpServer.Start(streamWithPing))
{
using (var dataSource = MakeDataSource(streamingServer.Uri, BasicUser,
c => c.ServiceEndpoints(Components.ServiceEndpoints()
.Streaming(streamingServer.Uri).Polling(pollingServer.Uri))))
{
var initTask = dataSource.Start();
pollingServer.Recorder.RequireRequest();
var receivedData = _updateSink.ExpectInit(BasicUser);
AssertHelpers.DataSetsEqual(data, receivedData);
Assert.True(AsyncUtils.WaitSafely(() => initTask, TimeSpan.FromSeconds(1)));
Assert.False(initTask.IsFaulted);
Assert.True(dataSource.Initialized);
}
}
}
}
public void InitPassesDataToStore()
{
var initData = new DataSetBuilder().Add("key1", new FeatureFlagBuilder().Build()).Build();
_updateSink.Init(_basicUser, initData);
Assert.Equal(initData.Items, _store.GetAll().Value.Items);
}
/// <summary>
/// Creates a new <see cref="IndirectDataSet"/> from the file provided.
/// </summary>
/// <param name="filePath">Uncompressed file containing the data for
/// the data set</param>
/// <param name="lastModified">Date and time the source data was last
/// modified.</param>
/// <param name="isTempFile">True if the file should be deleted when
/// the source is disposed</param>
/// <returns>
/// A <see cref="IndirectDataSet"/>configured to read entities from the file
/// path when required
/// </returns>
public static IndirectDataSet Create(string filePath, DateTime lastModified, bool isTempFile)
{
return(DataSetBuilder.File()
.ConfigureDefaultCaches()
.SetTempFile(isTempFile)
.LastModified(lastModified)
.Build(filePath));
}
public void CreateDataSet()
{
_memory = new Utils.MemoryMonitor();
Utils.CheckFileExists(DataFile);
_dataSet = DataSetBuilder.File()
.ConfigureDefaultCaches()
.SetCacheSize(CacheType.ValuesCache, ValuesCacheSize)
.Build(DataFile);
}
public void RemoveUserData()
{
var data = new DataSetBuilder().Add("flagkey", 1, LdValue.Of(true), 0).Build();
_wrapper.SetUserData(UserHash, data);
Assert.NotNull(_persistentStore.GetValue(ExpectedEnvironmentNamespace, ExpectedUserFlagsKey));
_wrapper.RemoveUserData(UserHash);
Assert.Null(_persistentStore.GetValue(ExpectedEnvironmentNamespace, ExpectedUserFlagsKey));
}
public void GetUnknownFlagKeyAfterInitialized()
{
var initData = new DataSetBuilder()
.Add("flag1", 1, LdValue.Of(true), 0)
.Build();
_store.Init(BasicUser, initData, false);
Assert.Null(_store.Get("flag2"));
}
public void SetUserData()
{
var data = new DataSetBuilder().Add("flagkey", 1, LdValue.Of(true), 0).Build();
_wrapper.SetUserData(UserHash, data);
var serializedData = _persistentStore.GetValue(ExpectedEnvironmentNamespace, ExpectedUserFlagsKey);
AssertJsonEqual(data.ToJsonString(), serializedData);
}
public void Can_create_a_DataSet_with_a_single_table()
{
// arrange
// act
DataSet dataSet = new DataSetBuilder()
.HavingTable(table => table.HavingAnIntColumnNamed("SomeNumber"));
// assert
Assert.AreEqual(1, dataSet.Tables.Count);
}
public void GetDeletedFlagForKnownUser()
{
var initData = new DataSetBuilder()
.AddDeleted("flag1", 200)
.Build();
_store.Init(BasicUser, initData, false);
Assert.Equal(new ItemDescriptor(200, null), _store.Get("flag1"));
}
public void CreateDataSet()
{
Utils.CheckFileExists(DataFile);
_dataSet = DataSetBuilder.Buffer()
.ConfigureDefaultCaches()
.SetCacheSize(CacheType.ValuesCache, ValuesCacheSize)
.Build(File.ReadAllBytes(DataFile));
_provider = new Provider(_dataSet);
Console.WriteLine("Dataset: {0}", _dataSet.Name);
Console.WriteLine("Format: {0}", _dataSet.Format);
}
public void GetKnownFlag()
{
var flag1 = new FeatureFlagBuilder().Version(100).Value(LdValue.Of(true)).Build();
var initData = new DataSetBuilder()
.Add("flag1", flag1)
.Build();
_store.Init(BasicUser, initData, false);
Assert.Equal(flag1.ToItemDescriptor(), _store.Get("flag1"));
}
public void NoEventsAreSentForFirstInit()
{
var events = new EventSink <FlagValueChangeEvent>();
_flagTracker.FlagValueChanged += events.Add;
var initData = new DataSetBuilder().Add("key1", new FeatureFlagBuilder().Build()).Build();
_updateSink.Init(_basicUser, initData);
events.ExpectNoValue();
}
public DataSetControlModel(Action redraw_callback)
{
redraw = redraw_callback;
names = DataSetBuilder.ListDataSetsNames().ToList();
data_sets = new List <DataSet>();
foreach (var name in names)
{
data_sets.Add(DataSet.LoadSingleSection(name));
}
data_sets.Add(DataSet.LoadEverything());
names.Add("ALL");
}
public void UpsertPassesDataToStore()
{
var flag1a = new FeatureFlagBuilder().Version(100).Value(LdValue.Of(false)).Build();
var initData = new DataSetBuilder().Add("key1", flag1a).Build();
_updateSink.Init(_basicUser, initData);
var flag1b = new FeatureFlagBuilder().Version(101).Value(LdValue.Of(true)).Build();
_updateSink.Upsert(_basicUser, "key1", flag1b.ToItemDescriptor());
Assert.Equal(flag1b.ToItemDescriptor(), _store.Get("key1"));
}
public void GetUserDataForKnownUserWithValidData()
{
var expectedData = new DataSetBuilder().Add("flagkey", 1, LdValue.Of(true), 0).Build();
var serializedData = expectedData.ToJsonString();
_persistentStore.SetValue(ExpectedEnvironmentNamespace, ExpectedUserFlagsKey, serializedData);
var data = _wrapper.GetUserData(UserHash);
Assert.NotNull(data);
AssertHelpers.DataSetsEqual(expectedData, data.Value);
Assert.Empty(logCapture.GetMessages());
}
public void GetAllReturnsFlags()
{
var initData = new DataSetBuilder()
.Add("flag1", 1, LdValue.Of(true), 0)
.Add("flag2", 2, LdValue.Of(false), 1)
.Build();
_store.Init(BasicUser, initData, false);
var data = _store.GetAll();
Assert.NotNull(data);
AssertHelpers.DataSetsEqual(initData, data.Value);
}
public void CreateDataSet()
{
var start = DateTime.UtcNow;
Utils.CheckFileExists(DataFile);
_dataSet = DataSetBuilder.Buffer()
.ConfigureDefaultCaches()
.ConfigureCache(CacheType.ValuesCache,
new CacheOptions()
{
Builder = new LruCacheBuilder(), Size = ValuesCacheSize
})
.Build(File.ReadAllBytes(DataFile));
}
public void PutCausesDataToBeStoredAndDataSourceInitialized()
{
var data = new DataSetBuilder()
.Add("flag1", 1, LdValue.Of(true), 0)
.Build();
WithDataSourceAndServer(StreamWithInitialData(data), (dataSource, _, initTask) =>
{
var receivedData = _updateSink.ExpectInit(BasicUser);
AssertHelpers.DataSetsEqual(data, receivedData);
Assert.True(AsyncUtils.WaitSafely(() => initTask, TimeSpan.FromSeconds(1)));
Assert.False(initTask.IsFaulted);
Assert.True(dataSource.Initialized);
});
}
public void SendsEventOnUpdateForNewlyAddedFlag()
{
var dataBuilder = new DataSetBuilder().Flags(flag1).Segments(segment1);
var updates = MakeInstance();
updates.Init(dataBuilder.Build());
var eventSink = new EventSink <FlagChangeEvent>();
updates.FlagChanged += eventSink.Add;
updates.Upsert(DataModel.Features, flag2.Key, DescriptorOf(flag2));
ExpectFlagChangeEvents(eventSink, flag2.Key);
}
public void DoesNotSendEventOnUpdateIfItemWasNotReallyUpdated()
{
var dataBuilder = new DataSetBuilder().Flags(flag1, flag2);
var updates = MakeInstance();
updates.Init(dataBuilder.Build());
var eventSink = new EventSink <FlagChangeEvent>();
updates.FlagChanged += eventSink.Add;
updates.Upsert(DataModel.Features, flag2.Key, DescriptorOf(flag2));
eventSink.ExpectNoValue();
}
public void UpsertUndeletesFlag()
{
var initData = new DataSetBuilder()
.AddDeleted("flag1", 100)
.Build();
_store.Init(BasicUser, initData, false);
var flag1 = new FeatureFlagBuilder().Version(101).Value(LdValue.Of(true)).Build();
var updated = _store.Upsert("flag1", flag1.ToItemDescriptor());
Assert.True(updated);
Assert.Equal(flag1.ToItemDescriptor(), _store.Get("flag1"));
}
