// 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")); }