public void Can_Write_Recursive_Class_To_File()
{
var dict = new Dictionary <string, string>
{
{ "Item", "TEST_VAL_ITEM" },
{ "SubItem_Item", "TEST_VAL_SUBITEM_ITEM" },
{ "SubItem_SubSubItem_Item", "TEST_VAL_SUBITEM_SUBSUBITEM_ITEM" },
{ "SubItem_SubSubItem_Bool", "true" },
{ "SubItem_SubSubItem_Int", "10" },
{ "SubItem_SubSubItem_Long", "10000000" },
{ "SubItem_SubSubItem_Double", "2.2" },
{ "SubItem_SubSubItem_Float", "2.22" }
};
// Set the environment variables we're going to use.
EnvironmentVariableSource.SetEnvironment(dict);
var parsed = ConfigurationParser.ParseConfiguration <TestClass>();
ConfigurationWriter.WriteToFile(parsed, "cwrctf.txt", true);
// Read in that file.
var instance = ConfigurationParser.Parse <TestClass>("cwrctf.txt");
Assert.Equal("TEST_VAL_ITEM", instance.Item);
Assert.Equal("TEST_VAL_SUBITEM_ITEM", instance?.SubItem?.Item);
Assert.Equal("TEST_VAL_SUBITEM_SUBSUBITEM_ITEM", instance?.SubItem?.SubSubItem?.Item);
Assert.True(instance?.SubItem?.SubSubItem?.Bool);
Assert.Equal(10, instance?.SubItem?.SubSubItem?.Int);
Assert.Equal(10000000, instance?.SubItem?.SubSubItem?.Long);
Assert.Equal(2.2D, instance?.SubItem?.SubSubItem?.Double);
Assert.Equal(2.22F, instance?.SubItem?.SubSubItem?.Float);
}
public void Can_Properly_Deserialize()
{
var dict = new Dictionary <string, string>
{
{ "Item", "TEST_VAL_ITEM" },
{ "SubItem_Item", "TEST_VAL_SUBITEM_ITEM" },
{ "SubItem_SubSubItem_Item", "TEST_VAL_SUBITEM_SUBSUBITEM_ITEM" },
{ "SubItem_SubSubItem_Bool", "true" },
{ "SubItem_SubSubItem_Int", "10" },
{ "SubItem_SubSubItem_Long", "10000000" },
{ "SubItem_SubSubItem_Double", "2.2" },
{ "SubItem_SubSubItem_Float", "2.22" }
};
// Set the environment variables we're going to use.
EnvironmentVariableSource.SetEnvironment(dict);
var instance = ConfigurationParser.ParseConfiguration <TestClass>();
Assert.Equal("TEST_VAL_ITEM", instance.Item);
Assert.Equal("TEST_VAL_SUBITEM_ITEM", instance.SubItem?.Item);
Assert.Equal("TEST_VAL_SUBITEM_SUBSUBITEM_ITEM", instance.SubItem?.SubSubItem?.Item);
Assert.True(instance.SubItem?.SubSubItem?.Bool);
Assert.Equal(10, instance.SubItem?.SubSubItem?.Int);
Assert.Equal(10000000, instance.SubItem?.SubSubItem?.Long);
Assert.Equal(2.2D, instance.SubItem?.SubSubItem?.Double);
Assert.Equal(2.22F, instance.SubItem?.SubSubItem?.Float);
}
public void Get_Returns_Value_From_Environment()
{
var source = new EnvironmentVariableSource();
var result = source.Get(Name, null, out string value);
Assert.AreEqual(Value, value);
Assert.IsTrue(result);
}
public void Get_Returns_Null_When_No_Matching_Environment_Variable()
{
const string name = " garbage string: P(*TO(*HFJJJFS#@(**&&^$%#*&()FDGO*^FDC VBNJUYT";
var source = new EnvironmentVariableSource();
var result = source.Get(name, null, out string value);
Assert.IsNull(value);
Assert.IsFalse(result);
}
public void Throws_Exception_When_Item_Is_Required_And_Not_Found()
{
var dict = new Dictionary <string, string>();
// Set the environment variables we're going to use.
EnvironmentVariableSource.SetEnvironment(dict);
Assert.Throws <KeyNotFoundException>(() =>
{
ConfigurationParser.ParseConfiguration <RequiredItemClass>();
});
}
public void Throws_When_Enum_Fails_To_Parse()
{
var dict = new Dictionary <string, string>
{
{ "Enum", "Item3" },
};
// Set the environment variables we're going to use.
EnvironmentVariableSource.SetEnvironment(dict);
var msg = Assert.Throws <Exception>(() => ConfigurationParser.ParseConfiguration <EnumClass>());
Assert.Contains("Could not parse", msg.Message);
}
public void Allows_Items_To_Be_Missing_If_Not_Required()
{
var dict = new Dictionary <string, string>
{
{ "RequiredItem", "Test" },
};
// Set the environment variables we're going to use.
EnvironmentVariableSource.SetEnvironment(dict);
var instance = ConfigurationParser.ParseConfiguration <NotRequiredItemClass>();
Assert.Null(instance.NotRequiredItem);
Assert.Equal("Test", instance.RequiredItem);
}
public void Can_Read_Default_Enum_Values()
{
var dict = new Dictionary <string, string>
{
{ "Enum", "Item2" },
};
// Set the environment variables we're going to use.
EnvironmentVariableSource.SetEnvironment(dict);
var configParsed = ConfigurationParser.ParseConfiguration <EnumClass>();
Assert.Equal(TestEnum.Item1, configParsed.NotRequired);
Assert.Equal(TestEnum.Item2, configParsed.Enum);
}
public void Check_For_Nullable()
{
var dict = new Dictionary <string, string>
{
{ "Test", "20" },
{ "TestBool", "true" }
};
EnvironmentVariableSource.SetEnvironment(dict);
EnvironmentVariableRepository.SetConfigurationType(ConfigurationTypeEnum.PreferEnvironment);
var output = ConfigurationParser.Parse <NullableClass>(EnvironmentVariableRepository);
Assert.Equal(20, output.Test);
Assert.True(output.TestBool);
Assert.Null(output.NotRequired);
}
public void Allows_Class_To_Be_Used_More_Than_Once()
{
var dict = new Dictionary <string, string>
{
{ "SubClass1_Item", "Val1" },
{ "SubClass2_Item", "Val2" },
{ "SubClass3_Item", "Val3" },
};
// Set the environment variables we're going to use.
EnvironmentVariableSource.SetEnvironment(dict);
var instance = ConfigurationParser.ParseConfiguration <ReUsableClass>();
Assert.Equal("Val1", instance?.SubClass1?.Item);
Assert.Equal("Val2", instance?.SubClass2?.Item);
Assert.Equal("Val3", instance?.SubClass3?.Item);
}
public void Environment_Only()
{
var values = new[]
{
"Test=fromFile",
};
var dict = new Dictionary <string, string>
{
{ "Test", "fromEnv" }
};
EnvironmentVariableSource.SetEnvironment(dict);
FileSource.SetEnvironment(values);
EnvironmentVariableRepository.SetConfigurationType(ConfigurationTypeEnum.EnvironmentOnly);
var output = ConfigurationParser.Parse <ConfigurationClass>(EnvironmentVariableRepository);
Assert.Equal("fromEnv", output.Test);
}
public void Can_Write_To_File()
{
var dict = new Dictionary <string, string>
{
{ "Test", "20" },
{ "TestBool", "true" }
};
EnvironmentVariableSource.SetEnvironment(dict);
EnvironmentVariableRepository.SetConfigurationType(ConfigurationTypeEnum.PreferEnvironment);
var output = ConfigurationParser.Parse <NullableClass>(EnvironmentVariableRepository);
ConfigurationWriter.WriteToFile(output, "cwtf.txt", true);
// Read in that file.
var parsedConfig = ConfigurationParser.Parse <NullableClass>("cwtf.txt");
Assert.Equal(20, parsedConfig.Test);
Assert.True(parsedConfig.TestBool);
}
public void Prefer_File_Over_Environment()
{
var values = new[]
{
"Test=fromFile",
"test=fromFile"
};
var dict = new Dictionary <string, string>
{
{ "Test", "fromEnv" },
};
EnvironmentVariableSource.SetEnvironment(dict);
FileSource.SetEnvironment(values);
EnvironmentVariableRepository.SetConfigurationType(ConfigurationTypeEnum.PreferFile);
var output = ConfigurationParser.Parse <PreferClass>(EnvironmentVariableRepository);
Assert.Equal("fromFile", output.Test);
Assert.Equal("fromFile", output.test);
}