public void LoadConfig_WhenConfigContainsTableArrays_LoadsThatConfigCorrectly_() { using (var fn = TestFileName.Create("productinfo", ".toml")) { File.WriteAllText(fn, @" [info] [[info.product]] name = ""product1"" number = 10000 [[info.product]] name = ""product2"" number = 10001 "); var config = Config.CreateAs() .MappedToType(() => new ProductInfo()) .StoredAs(store => store.File(fn)) .Initialize() .Get(_ => _); config.info.product.Length.Should().Be(2); config.info.product[0].name.Should().Be("product1"); config.info.product[1].name.Should().Be("product2"); } }
public void Write_WithTomlTable_WritesCorrectFileContent() { // Arrange using (var filename = TestFileName.Create("test", ".toml")) { // Act var server = Toml.Create(); server.Add("Timeout", TimeSpan.FromMinutes(2)); var client = Toml.Create(); client.Add("ServerAddress", "http://*****:*****@" EnableDebug = false [Server] Timeout = 2m [Client] ServerAddress = ""http://localhost:8082"""); } }
public void SetProperty_InSpecializedScopeForConvertedMultiLevelType_WritesItBackToSpecScope() { using (var main = TestFileName.Create("main", Toml.FileExtension)) using (var spec = TestFileName.Create("spec", Toml.FileExtension)) { // Arrange var tmlCfg = TomlSettings.Create(c => c .ConfigureType <MultiTableConverterObject>(tc => tc .WithConversionFor <TomlString>(conv => conv .ToToml(o => o.ToString()) .FromToml(s => MultiTableConverterObject.Parse(s.Value))))); Toml.WriteFile(Toml.Create(), main, tmlCfg);; Toml.WriteFile(Toml.Create(CreateWithUnitItem(2.0, "X")), spec, tmlCfg); var cfg = Config.CreateAs() .MappedToType(() => new Root()) .UseTomlConfiguration(tmlCfg) .StoredAs(s => s .File(main).MergeWith( s.File(spec))) .Initialize(); // Act cfg.Set(c => c.ConvertedItem.UnitItem.Unit, "EX"); // Assert var root = Toml.ReadFile <Root>(spec, tmlCfg); root.ConvertedItem.UnitItem.Unit.Should().Be("EX"); } }
public void Write_WithDictionary_WritesCorrectFileContent() { // Arrange using (var filename = TestFileName.Create("test", ".toml")) { // Act var data = new Dictionary <string, object>() { { "EnableDebug", false }, { "Server", new Dictionary <string, object>() { { "Timeout", TimeSpan.FromMinutes(2) } } }, { "Client", new Dictionary <string, object>() { { "ServerAddress", "http://*****:*****@" EnableDebug = false [Server] Timeout = 2m [Client] ServerAddress = ""http://localhost:8082"""); } }
public void ReadConfigPropertyAfterInit_WhenMultiLevelTypeHasConverterInSpecializedScope_ReadsItemFromSpecScope() { using (var main = TestFileName.Create("main", Toml.FileExtension)) using (var spec = TestFileName.Create("spec", Toml.FileExtension)) { // Arrange var tmlCfg = TomlSettings.Create(c => c .ConfigureType <MultiTableConverterObject>(tc => tc .WithConversionFor <TomlString>(conv => conv .ToToml(o => o.ToString()) .FromToml(s => MultiTableConverterObject.Parse(s.Value))))); Toml.WriteFile(Toml.Create(), main, tmlCfg);; Toml.WriteFile(Toml.Create(CreateWithUnitItem(2.0, "X")), spec, tmlCfg); var cfg = Config.CreateAs() .MappedToType(() => new Root()) .UseTomlConfiguration(tmlCfg) .StoredAs(s => s.File(main).AccessedBySource("main", out var _).MergeWith( s.File(spec).AccessedBySource("spec", out var _))) .Initialize(); // Act var val = cfg.Get(c => c.ConvertedItem.UnitItem.Unit); var src = cfg.GetSource(c => c.ConvertedItem.UnitItem.Unit); // Assert val.Should().Be("X"); src.Name.Should().Be("spec"); } }
public void SetConfigProperty_WhenMultiLevelTypeHasConverter_WritesTheSubPropertyCorrectly() { using (var fn = TestFileName.Create("file", Toml.FileExtension)) { // Arrange var tmlCfg = TomlSettings.Create(c => c .ConfigureType <MultiTableConverterObject>(tc => tc .WithConversionFor <TomlString>(conv => conv .ToToml(o => o.ToString()) .FromToml(s => MultiTableConverterObject.Parse(s.Value))))); var cfg = Config.CreateAs() .MappedToType(() => new Root()) .UseTomlConfiguration(tmlCfg) .StoredAs(s => s.File(fn)) .Initialize(); // Act cfg.Set(c => c.ConvertedItem.UnitItem.Unit, "B"); // Assert var tbl = Toml.ReadFile <Root>(fn, tmlCfg); tbl.ConvertedItem.UnitItem.Unit.Should().Be("B"); } }
public void WhenUpdatingRowWithNewValues_WrittenTomlHasTheseNewRowValues() { using var machine = TestFileName.Create("machine", ".toml"); // Arrange const string machineText = @" [Tbl] a = 1 d = ""D"" e = [""b"", ""c""]"; File.WriteAllText(machine, machineText); var cfg = Config.CreateAs() .MappedToType(() => new DictConfig()) .StoredAs(store => store.File(machine)) .Initialize(); // Act cfg.Set(c => c.Tbl["e"], new string[] { "x", "y" }); // Assert File.ReadAllText(machine).Should().BeAfterTransforms(StringTransformForComparison, @" [Tbl] a = 1 d = ""D"" e = [""x"", ""y""]"); }
public void Foo() { using (var fn = TestFileName.Create("input", ".toml")) { // Arrange const string tml = @" [User] [User.Items] first = true second = false third = true "; File.WriteAllText(fn, tml); // Act var cfg = Config.CreateAs() .MappedToType(() => new AppSettings()) .StoredAs(store => store.File(fn)) .Initialize(); var u = Toml.ReadString <AppSettings>(tml); // Assert cfg.Get(c => c.User.Items).Count.Should().Be(3); } }
public void WhenUpdatingValueOfLoadedGenericDict_TheWrittentomlContainsTheUpdatedValue() { using var machine = TestFileName.Create("machine", ".toml"); using var user = TestFileName.Create("user", ".toml"); // Arrange const string machineText = @"[Tbl] x = 1"; const string userText = @"[Tbl] x = 2"; File.WriteAllText(machine, machineText); File.WriteAllText(user, userText); // Act IConfigSource src = null; var cfg = Config.CreateAs() .MappedToType(() => new DictConfig()) .StoredAs(store => store.File(machine) .MergeWith(store.File(user).AccessedBySource("user", out src))) .Initialize(); var tbl = cfg.Get(c => c.Tbl); tbl["x"] = 4; cfg.Set(c => c.Tbl, tbl, src); // Assert File.ReadAllText(user).ShouldBeSemanticallyEquivalentTo(@"[Tbl] x = 4"); }
public void Write_WithInlineTableProperty_WritesThatTableAsInlineTable() { using (var file = TestFileName.Create("Input", ".toml")) { // Arrange const string expected = @"UserItems = { X = true, Y = false } "; const string input = "UserItems = { 'X' = false, 'Y' = true }"; File.WriteAllText(file, input); var toWrite = new Cfg.Items() { { "X", true }, { "Y", false } }; // Act var cfg = Config.CreateAs() .MappedToType(() => new Cfg()) .StoredAs(store => store.File(file)) .Initialize(); cfg.Set(c => c.UserItems, toWrite); // Assert var f = File.ReadAllText(file); f.ShouldBeNormalizedEqualTo(expected); } }
public void WasChangedExternally_WhenFileWasModified_ReturnsTrueUntilLoadIsPerformed() { using (var file = TestFileName.Create("x", Toml.FileExtension)) { // Arrange File.WriteAllText(file, "x=0"); var cfg = new FileConfigStore(TomlSettings.DefaultInstance, file); cfg.Load(); using (var sw = File.AppendText(file)) { sw.WriteLine(); sw.WriteLine("y=1"); } // Act var r1 = cfg.WasChangedExternally(); var r2 = cfg.WasChangedExternally(); cfg.Load(); var r3 = cfg.WasChangedExternally(); // Assert r1.Should().Be(true); r2.Should().Be(true); r3.Should().Be(false); } }
public void CommentsNotLostWhenPorpertyValueIsSet() { // Arrange var expectedChanged = @"#Some comment b = false #Comment on nested table [a] #Comment on C c = """" "; using var filename = TestFileName.Create($"settings", Toml.FileExtension); var config = Config.CreateAs() .MappedToType(() => new Configuration()) .StoredAs(builder => builder.File(filename)) .Initialize(); var readValue = File.ReadAllText(filename); readValue.ShouldBeNormalizedEqualTo(InitialToml); // Act config.Set(c => c.b, false); // Assert readValue = File.ReadAllText(filename); readValue.ShouldBeNormalizedEqualTo(expectedChanged); }
private MoneyScenario(string test) { this.FilePath = TestFileName.Create("money", Toml.FileExtension, test); this.TmlConfig = TomlSettings.Create(cfg => cfg .ConfigureType <Money>(typeConfig => typeConfig .WithConversionFor <TomlString>(conversion => conversion .ToToml(m => m.ToString()) .FromToml(s => Money.Parse(s.Value))))); }
public void WasChangedExternally_WhenThereWasNoModification_ReturnsFalse() { using (var file = TestFileName.Create("x", Toml.FileExtension)) { // Arrange File.WriteAllText(file, "x=0"); var cfg = new FileConfigStore(TomlSettings.DefaultInstance, file); cfg.Load(); // Act var r = cfg.WasChangedExternally(); // Assert r.Should().Be(false); } }
public void VerifyIssue25_UnitializedDateTime_DoesNotCrasComaInit() { using (var fn = TestFileName.Create("thecfg", ".toml")) { // Act Action a = () => Config.CreateAs() .MappedToType(() => new TheCfg()) .StoredAs(store => store.File(fn)) .Initialize(); // Assert a.ShouldNotThrow <ArgumentOutOfRangeException>(because: "Nett's converters should be able to handle the " + "following case internally in any time zone: var off = new DateTimeOfffset(DateTime.MinValue) which happens " + "when the DateTime field of a class is not initialized with an explicit value."); } }
public void WasChangedExternally_WhenFileWasNotLoadedAtLeastOnce_WillAlwaysReturnTrue() { using (var file = TestFileName.Create("x", Toml.FileExtension)) { // Arrange File.WriteAllText(file, "x=0"); var cfg = new FileConfigStore(TomlSettings.DefaultInstance, file); // Act var r1 = cfg.WasChangedExternally(); var r2 = cfg.WasChangedExternally(); // Assert r1.Should().Be(true); r2.Should().Be(true); } }
public void Save_UpdatesInMemoryConfigSoNextLoadWillDeliverThatConfig() { using (var fn = TestFileName.Create("file", Toml.FileExtension)) { // Arrange var fc = new FileConfigStore(TomlSettings.DefaultInstance, fn); var oc = new ConfigStoreWithSource(new ConfigSource(fn), fc); File.WriteAllText(fn, "X = 1"); oc.Load(); // At least one load needs to be done, otherwise a load will be done because not any data was loaded yet // Act oc.Save(Toml.ReadString("X = 2")); // Assert var readBack = oc.Load(); ((TomlInt)readBack["X"]).Value.Should().Be(2); } }
public void Read_AsTomlTable_ReadsTableCorrectly() { // Arrange using (var filename = TestFileName.Create("test", ".toml")) { File.WriteAllText(filename, exp); // Act var toml = Toml.ReadFile(filename); Console.WriteLine("EnableDebug: " + toml.Get <bool>("EnableDebug")); Console.WriteLine("Timeout: " + toml.Get <TomlTable>("Server").Get <TimeSpan>("Timeout")); Console.WriteLine("ServerAddress: " + toml.Get <TomlTable>("Client").Get <string>("ServerAddress")); // Assert toml.Get <bool>("EnableDebug").Should().Be(true); toml.Get <TomlTable>("Server").Get <TimeSpan>("Timeout").Should().Be(TimeSpan.FromMinutes(1)); toml.Get <TomlTable>("Client").Get <string>("ServerAddress").Should().Be("http://127.0.0.1:8080"); } }
public void Write_WithCustomObject_WritesCorrectFileContent() { // Arrange using (var filename = TestFileName.Create("test", ".toml")) { // Act var obj = new Configuration(); Toml.WriteFile(obj, filename); // Assert File.ReadAllText(filename).ShouldBeSemanticallyEquivalentTo( @" EnableDebug = false [Server] Timeout = 2m [Client] ServerAddress = ""http://localhost:8082"""); } }
public void Read_AsCustomObject_ReadsTableCorrectly() { // Arrange using (var filename = TestFileName.Create("test", ".toml")) { File.WriteAllText(filename, exp); // Act var cust = Toml.ReadFile <Configuration>(filename); Console.WriteLine("EnableDebug: " + cust.EnableDebug); Console.WriteLine("Timeout: " + cust.Server.Timeout); Console.WriteLine("ServerAddress: " + cust.Client.ServerAddress); // Assert cust.EnableDebug.Should().Be(true); cust.Server.Timeout.Should().Be(TimeSpan.FromMinutes(1)); cust.Client.ServerAddress.Should().Be("http://127.0.0.1:8080"); } }
public void LoadMergedConfig_LocalSettingOverwritesMoreGlobalSetting() { using (var global = TestFileName.Create("global", Toml.FileExtension)) using (var local = TestFileName.Create("local", Toml.FileExtension)) { // Arrange File.WriteAllText(global, Config1); File.WriteAllText(local, Config1A); // Act var c = Config.CreateAs() .MappedToType(() => new SingleLevelConfig()) .StoredAs(store => store.File(global).MergeWith( store.File(local))) .Initialize(); // Assert c.Get(r => r.IntValue).Equals(2); } }
public void Read_WithInlineTableProperty_ReadsThatPropertyCorrectly() { using (var file = TestFileName.Create("input", ".toml")) { // Arrange const string input = "UserItems = { 'X' = false, 'Y' = true }"; File.WriteAllText(file, input); // Act var cfg = Config.CreateAs() .MappedToType(() => new Cfg()) .StoredAs(store => store.File(file)) .Initialize(); var items = cfg.Get(c => c.UserItems); // Assert items.Count.Should().Be(2); items["X"].Should().Be(false); items["Y"].Should().Be(true); } }
public void Read_AsDictionary_ReadsTableCorrectly() { // Arrange using (var filename = TestFileName.Create("test", ".toml")) { File.WriteAllText(filename, exp); // Act var data = Toml.ReadFile(filename).ToDictionary(); var server = (Dictionary <string, object>)data["Server"]; var client = (Dictionary <string, object>)data["Client"]; Console.WriteLine("EnableDebug: " + data["EnableDebug"]); Console.WriteLine("Timeout: " + server["Timeout"]); Console.WriteLine("ServerAddress: " + client["ServerAddress"]); // Assert data["EnableDebug"].Should().Be(true); server["Timeout"].Should().Be(TimeSpan.FromMinutes(1)); client["ServerAddress"].Should().Be("http://127.0.0.1:8080"); } }
public void Init_WhenMergeSourceIsUsedAndNoManualInitIsDone_BothFilesAreCreatedButOnlyTheFirstHasAllDefaultData() { using (var main = TestFileName.Create("main", Toml.FileExtension)) using (var user = TestFileName.Create("user", Toml.FileExtension)) { // Act var merged = Config.CreateAs() .MappedToType(() => new TestData.TestAppSettings()) .StoredAs(store => store .File(main).MergeWith().File(user)) .Initialize(); // Assert File.Exists(main).Should().Be(true); File.Exists(user).Should().Be(true); var mainTbl = Toml.ReadFile(main); var usertbl = Toml.ReadFile(user); mainTbl.Count.Should().BeGreaterThan(0); usertbl.Count.Should().Be(0); } }
public void GivenTomlWithTable_ComaCanMapItIntoAGenericDictionaryOfObjectValues() { using var machine = TestFileName.Create("machine", ".toml"); // Arrange const string machineText = @" [Tbl] a = 1 d = ""D"" e = [""b"", ""c""]"; File.WriteAllText(machine, machineText); var cfg = Config.CreateAs() .MappedToType(() => new DictConfig()) .StoredAs(store => store.File(machine)) .Initialize(); // Act var r = cfg.GetAs <string[]>(c => c.Tbl["e"]); // Assert r.Should().Equal("b", "c"); }
private GitScenario(string testName) { this.SystemFile = TestFileName.Create("system", GitConfig.Extension, testName); this.UserFile = TestFileName.Create("user", GitConfig.Extension, testName); this.RepoFile = TestFileName.Create("repo", GitConfig.Extension, testName); }
private SingleConfigFileScenario(string test) { this.File = TestFileName.Create("conffile", Toml.FileExtension, test); }