public void Configuration_Ctor_ExclusiveRequirementsSupplied_Multiple_ThrowsAggregate()
{
const int numberOfConflictingRequirements = 5;
List <IConfigurationRequirement> requirements =
new List <IConfigurationRequirement>()
{
TestUtil.CreateConfigurationRequirement()
};
for (int counter = 0; counter < numberOfConflictingRequirements; counter++)
{
requirements.Add(TestUtil.CreateConfigurationRequirement(
exclusiveWith: new IConfigurationRequirement[] { requirements.Last() }));
}
Dictionary <IConfigurationRequirement, object> values = requirements
.Select(x => new KeyValuePair <IConfigurationRequirement, object>(
x,
TestUtil.GetDefaultValidObjectForRequirement(x)))
.ToDictionary(x => x.Key, x => x.Value);
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(requirements.ToArray());
AggregateException exception = Assert.ThrowsException <AggregateException>(() =>
new Configuration(configurable, values));
Assert.AreEqual(numberOfConflictingRequirements, exception.InnerExceptions.Count);
Assert.IsTrue(
exception
.InnerExceptions
.Select(x => x.Message)
.All(x => x.Contains("has conflicting requirements specified.")),
"Unexpected exception message encountered.");
}
public void Configuration_CanBeEnumerated_Succeeds()
{
const int numberOfRequirements = 50;
IConfigurationRequirement[] requirements = TestUtil
.CreateIConfigurationRequirementCollection(numberOfRequirements, randomTypes: true)
.ToArray();
Dictionary <IConfigurationRequirement, object> supplied = requirements
.Select(x =>
new KeyValuePair <IConfigurationRequirement, object>(
x,
TestUtil.GetDefaultValidObjectForRequirement(x)))
.ToDictionary(x => x.Key, x => x.Value);
IMapping[] expected = supplied.Select(x => new Mapping(x.Key, x.Value)).ToArray();
IRequirementSource requirementSource = ConfigurationTests.CreateRequirementSource(requirements);
IConfiguration configuration = new Configuration(requirementSource, supplied);
IMapping[] actual = configuration.ToArray();
CollectionAssert.AreEquivalent(expected, actual);
}
public void Configuration_Ctor_RequiredDependsOnMissing_MultipleMissing_ThrowsAggregate()
{
const int numberOfMissingDependedUpons = 5;
IConfigurationRequirement[] dependedUpons = Enumerable
.Range(1, numberOfMissingDependedUpons)
.Select(x => TestUtil.CreateConfigurationRequirement(isOptional: true))
.ToArray();
IConfigurationRequirement[] dependsOns = dependedUpons
.Select(x => TestUtil.CreateConfigurationRequirement(dependsOn: new IConfigurationRequirement[] { x }))
.ToArray();
Dictionary <IConfigurationRequirement, object> values = dependsOns
.Select(x => new KeyValuePair <IConfigurationRequirement, object>(
x,
TestUtil.GetDefaultValidObjectForRequirement(x)))
.ToDictionary(x => x.Key, x => x.Value);
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(dependsOns);
AggregateException exception = Assert.ThrowsException <AggregateException>(() =>
new Configuration(configurable, values));
Assert.AreEqual(numberOfMissingDependedUpons, exception.InnerExceptions.Count);
Assert.IsTrue(
exception
.InnerExceptions
.Select(x => x.Message)
.All(x => x.Contains("does not have its dependencies fulfilled.")),
"Unexpected exception message encountered.");
}
public void Configuration_Ctor_MultipleFailuresOccur_ThrowsAggregateException()
{
const string validationFailureMessage = "BOUNDCONFIGURATIONTESTS_MultipleFailuresOccur";
const string testFailureMessage = "Missing/too many matches for expected exception.";
const int expectedFailureCount = 4;
IConfigurationRequirement requiredButMissing = TestUtil.CreateConfigurationRequirement(
baseName: nameof(requiredButMissing),
isOptional: false);
IConfigurationRequirement dependsOnIsMissing = TestUtil.CreateConfigurationRequirement(
baseName: nameof(dependsOnIsMissing),
dependsOn: new IConfigurationRequirement[] { requiredButMissing });
IConfigurationRequirement failsValidation = TestUtil.CreateConfigurationRequirement(
baseName: nameof(failsValidation),
validator: (x, y, z) => throw new NotImplementedException(validationFailureMessage));
IConfigurationRequirement exclusiveWith = TestUtil.CreateConfigurationRequirement(
baseName: nameof(exclusiveWith),
exclusiveWith: new IConfigurationRequirement[] { failsValidation });
IConfigurationRequirement isFine = TestUtil.CreateConfigurationRequirement(
baseName: nameof(isFine),
validator: (x, y, z) => null);
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(
requiredButMissing,
dependsOnIsMissing,
failsValidation,
exclusiveWith,
isFine);
Dictionary <IConfigurationRequirement, object> bindings =
new IConfigurationRequirement[] { dependsOnIsMissing, failsValidation, exclusiveWith, isFine }
.Select(x => new KeyValuePair <IConfigurationRequirement, object>(x, null))
.ToDictionary(x => x.Key, x => x.Value);
AggregateException exception = Assert.ThrowsException <AggregateException>(() =>
new Configuration(configurable, bindings));
Assert.AreEqual(expectedFailureCount, exception.InnerExceptions.Count);
Assert.IsNotNull(
exception
.InnerExceptions
.SingleOrDefault(x => x.Message.Contains(validationFailureMessage)),
testFailureMessage);
Assert.IsNotNull(
exception
.InnerExceptions
.SingleOrDefault(x => x.Message.Contains("has conflicting requirements specified.")),
testFailureMessage);
Assert.IsNotNull(
exception
.InnerExceptions
.SingleOrDefault(x => x.Message.Contains("does not have its dependencies fulfilled.")),
testFailureMessage);
Assert.IsNotNull(
exception
.InnerExceptions
.SingleOrDefault(x => x.Message.Contains("Missing required requirement")),
testFailureMessage);
}
public void Configuration_GetOrDefault_ValueFactoryNull_ThrowsArgumentNull()
{
Configuration configuration = ConfigurationTests.CreateConfiguration(
TestUtil.GetDefaultValidObjectForRequirement,
out IConfigurationRequirement requirement);
Assert.ThrowsException <ArgumentNullException>(() => configuration.GetOrDefault(requirement, null));
}
public void Configuration_TryGetOrDefault_RequirementNull_ThrowsArgumentNull()
{
Configuration configuration = ConfigurationTests.CreateConfiguration(
TestUtil.GetDefaultValidObjectForRequirement,
out IConfigurationRequirement requirement);
Assert.ThrowsException <ArgumentNullException>(
() => configuration.TryGetOrDefault <object>(null, () => null, out object dontCare));
}
public void Configuration_Ctor_RequiredRequirementIsNotPresent_ThrowsAggregate()
{
IConfigurationRequirement required =
TestUtil.CreateConfigurationRequirement(isOptional: false);
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(required);
AggregateException exception = Assert.ThrowsException <AggregateException>(() =>
new Configuration(configurable, new Dictionary <IConfigurationRequirement, object>()));
Assert.AreEqual(1, exception.InnerExceptions.Count);
StringAssert.Contains(exception.InnerExceptions.Single().Message, "Missing required requirement");
}
public void Configuration_TryGetOrDefault_ValueNotPresent_UsesValueFactory()
{
ConfigurationRequirementType type = ConfigurationRequirementType.Uri;
Configuration configuration = ConfigurationTests.CreateConfiguration(
TestUtil.GetDefaultValidObjectForRequirement,
out IConfigurationRequirement present);
IConfigurationRequirement notPresent = TestUtil.CreateConfigurationRequirement(type: type);
Uri expected = (Uri)TestUtil.GetDefaultValidObjectForRequirement(notPresent);
Assert.IsFalse(configuration.TryGetOrDefault(notPresent, () => expected, out Uri actual));
Assert.AreEqual(expected, actual);
}
public void Configuration_TryGetOrDefault_ValuePresentButWrongType_ConversionFails_UsesValueFactory()
{
const string expected = "Configuration_TryGetOrDefault";
// `expected` must be of a different type than `type`
ConfigurationRequirementType type = ConfigurationRequirementType.Int32;
Configuration configuration = ConfigurationTests.CreateConfiguration(
TestUtil.GetDefaultValidObjectForRequirement,
out IConfigurationRequirement requirement,
() => TestUtil.CreateConfigurationRequirement(type: type));
Assert.IsFalse(configuration.TryGetOrDefault <string>(requirement, () => expected, out string actual));
Assert.AreEqual(expected, actual);
}
public void Configuration_TryGetOrDefault_ValuePresentButWrongType_ConversionSucceeds()
{
const long expected = 8675309L;
const int notExpected = 111111;
ConfigurationRequirementType type = ConfigurationRequirementType.Int32;
Configuration configuration = ConfigurationTests.CreateConfiguration(
x => expected,
out IConfigurationRequirement requirement,
() => TestUtil.CreateConfigurationRequirement(type: type));
Assert.IsTrue(configuration.TryGetOrDefault <long>(requirement, () => notExpected, out long actual));
Assert.AreEqual(expected, actual);
}
public void Configuration_Indexer_Get_Succeeds()
{
IConfigurationRequirement requirement = TestUtil.CreateConfigurationRequirement();
object expected = TestUtil.GetDefaultValidObjectForRequirement(requirement);
Dictionary <IConfigurationRequirement, object> bindings =
new Dictionary <IConfigurationRequirement, object>()
{
[requirement] = expected
};
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(requirement);
Configuration configuration = new Configuration(configurable, bindings);
Assert.AreEqual(expected, configuration[requirement]);
}
public void Configuration_GetOrDefault_Succeeds()
{
object expected = null;
Func <IConfigurationRequirement, object> valueFactory =
x =>
{
expected = TestUtil.GetDefaultValidObjectForRequirement(x);
return(expected);
};
Configuration configuration = ConfigurationTests.CreateConfiguration(
valueFactory,
out IConfigurationRequirement requirement);
Assert.AreEqual(expected, configuration.GetOrDefault(requirement, () => null));
}
private static Configuration CreateConfiguration(
Func <IConfigurationRequirement, object> valueFactory,
out IConfigurationRequirement requirement,
Func <IConfigurationRequirement> requirementFactory = null)
{
requirement = (requirementFactory ?? (() => TestUtil.CreateConfigurationRequirement())).Invoke();
Dictionary <IConfigurationRequirement, object> bindings =
new Dictionary <IConfigurationRequirement, object>()
{
[requirement] = valueFactory.Invoke(requirement)
};
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(requirement);
return(new Configuration(configurable, bindings));
}
public void Configuration_GetOrDefault_ValueNotPresent_UsesValueFactory()
{
const string fallbackValue = "Configuration_GetOrDefault";
IConfigurationRequirement present = TestUtil.CreateConfigurationRequirement();
IConfigurationRequirement notPresent = TestUtil.CreateConfigurationRequirement(isOptional: true);
object expected = TestUtil.GetDefaultValidObjectForRequirement(present);
Dictionary <IConfigurationRequirement, object> bindings =
new Dictionary <IConfigurationRequirement, object>()
{
[present] = expected
};
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(notPresent);
Configuration configuration = new Configuration(configurable, bindings);
Assert.AreEqual(fallbackValue, configuration.GetOrDefault(notPresent, () => fallbackValue));
}
public void Configuration_Ctor_RequirementFailsValidation_ThrowsAggregate()
{
const string exceptionMessage = "BOUNDCONFIGURATIONTESTS_RequirementFailsValidation";
IConfigurationRequirement required = TestUtil.CreateConfigurationRequirement(
validator: (x, y, z) => throw new NotImplementedException(exceptionMessage));
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(required);
AggregateException exception = Assert.ThrowsException <AggregateException>(() =>
new Configuration(
configurable,
new Dictionary <IConfigurationRequirement, object>()
{
[required] = "dontCare"
}));
Assert.AreEqual(1, exception.InnerExceptions.Count);
Assert.AreEqual(exceptionMessage, exception.InnerExceptions.Single().Message);
}
public void Configuration_TryGetOrDefault_Succeeds()
{
// The type here needs to match the expected generic type used later.
ConfigurationRequirementType type = ConfigurationRequirementType.Bool;
bool expected = false;
Configuration configuration = ConfigurationTests.CreateConfiguration(
x =>
{
// Use the inverse of the default value for our expected (just in case the default somehow slips in)
expected = !(bool)TestUtil.GetDefaultValidObjectForRequirement(x);
return(expected);
},
out IConfigurationRequirement requirement,
() => TestUtil.CreateConfigurationRequirement(type: type));
Assert.IsTrue(configuration.TryGetOrDefault <bool>(requirement, () => !expected, out bool actual));
Assert.AreEqual(expected, actual);
}
public void Configuration_Ctor_RequirementDependsOnMissing_ThrowsAggregate()
{
// dependedUpon needs to be optional or we'll get two errors (because required requirement is missing).
IConfigurationRequirement dependedUpon = TestUtil.CreateConfigurationRequirement(isOptional: true);
IConfigurationRequirement dependsOn = TestUtil.CreateConfigurationRequirement(
type: ConfigurationRequirementType.String,
dependsOn: new IConfigurationRequirement[] { dependedUpon });
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(dependedUpon, dependsOn);
AggregateException exception = Assert.ThrowsException <AggregateException>(() =>
new Configuration(
configurable,
new Dictionary <IConfigurationRequirement, object>()
{
[dependsOn] = "Passes validation"
}));
Assert.AreEqual(1, exception.InnerExceptions.Count);
StringAssert.Contains(
exception.InnerExceptions.Single().Message,
"does not have its dependencies fulfilled.");
}
public void Configuration_Ctor_ExclusiveRequirementsSupplied_ThrowsAggregate()
{
IConfigurationRequirement first = TestUtil.CreateConfigurationRequirement(
type: ConfigurationRequirementType.String);
IConfigurationRequirement second = TestUtil.CreateConfigurationRequirement(
type: ConfigurationRequirementType.String,
exclusiveWith: new IConfigurationRequirement[] { first });
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(first, second);
AggregateException exception = Assert.ThrowsException <AggregateException>(() =>
new Configuration(
configurable,
new Dictionary <IConfigurationRequirement, object>()
{
[first] = "Passes validation",
[second] = "Also passes validation"
}));
Assert.AreEqual(1, exception.InnerExceptions.Count);
StringAssert.Contains(
exception.InnerExceptions.Single().Message,
"has conflicting requirements specified.");
}
