public void CreateReturnsValueCreatedWithoutArguments()
{
var buildHistory = new BuildHistory();
var expected = new Person();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var constructorResolver = Substitute.For <IConstructorResolver>();
var typeResolver = Substitute.For <ITypeResolver>();
var processor = Substitute.For <IBuildProcessor>();
var typeCapability = Substitute.For <IBuildCapability>();
typeCapability.SupportsCreate.Returns(true);
typeCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
buildConfiguration.ConstructorResolver.Returns(constructorResolver);
buildConfiguration.TypeResolver.Returns(typeResolver);
typeResolver.GetBuildType(buildConfiguration, typeof(Person)).Returns(x => x.Arg <Type>());
var sut = new DefaultExecuteStrategy <Person>(buildHistory, _buildLog, processor);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
typeof(Person))
.Returns(typeCapability);
constructorResolver.Resolve(typeof(Person))
.Returns(typeof(Person).GetConstructors().Single(x => x.GetParameters().Length == 0));
typeCapability.CreateType(sut, typeof(Person), Arg.Any <object?[]?>()).Returns(expected);
typeCapability.Populate(sut, expected).Returns(expected);
sut.Initialize(buildConfiguration);
var actual = sut.Create();
actual.Should().BeSameAs(expected);
}
public void CreateEvaluatesPostBuildActionsInOrderOfDescendingPriorityTest()
{
var firstAction = Substitute.For<IPostBuildAction>();
var secondAction = Substitute.For<IPostBuildAction>();
var buildStrategy = new DefaultBuildStrategyCompiler().Add(firstAction).Add(secondAction).Compile();
var executeCount = 0;
firstAction.IsSupported(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(true);
secondAction.IsSupported(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(true);
firstAction.WhenForAnyArgs(x => x.Execute(null, null, null)).Do(
x =>
{
executeCount++;
executeCount.Should().Be(1);
});
secondAction.WhenForAnyArgs(x => x.Execute(null, null, null)).Do(
x =>
{
executeCount++;
executeCount.Should().Be(2);
});
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
target.Create(typeof(Simple));
firstAction.Received().Execute(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>());
secondAction.Received().Execute(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>());
}
public void CreateParametersCanReturnNullParameter()
{
var buildHistory = new BuildHistory();
var method = typeof(SimpleConstructor).GetConstructors().First();
var parameters = method.GetParameters().OrderBy(x => x.Name);
var parameterCapability = Substitute.For <IBuildCapability>();
var processor = Substitute.For <IBuildProcessor>();
var parameterResolver = Substitute.For <IParameterResolver>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
parameterCapability.AutoPopulate.Returns(false);
parameterCapability.SupportsCreate.Returns(true);
parameterCapability.SupportsPopulate.Returns(false);
parameterCapability.ImplementedByType.Returns(GetType());
parameterCapability.CreateParameter(sut, Arg.Any <ParameterInfo>(), null).Returns(null);
processor.GetBuildCapability(sut, BuildRequirement.Create,
Arg.Any <ParameterInfo>()).Returns(parameterCapability);
parameterResolver.GetOrderedParameters(buildConfiguration, method).Returns(parameters);
buildConfiguration.ParameterResolver.Returns(parameterResolver);
sut.Initialize(buildConfiguration);
var actual = sut.CreateParameters(method) !;
actual.Should().HaveCount(1);
actual[0].Should().BeNull();
}
public void CreateEvaluatesPostBuildActionsInOrderOfDescendingPriority()
{
var firstAction = Substitute.For <IPostBuildAction>();
var secondAction = Substitute.For <IPostBuildAction>();
var buildConfiguration = Model.UsingDefaultConfiguration().Add(firstAction).Add(secondAction);
var executeCount = 0;
firstAction.IsMatch(Arg.Any <IBuildChain>(), typeof(Simple)).Returns(true);
firstAction.Priority.Returns(int.MaxValue);
secondAction.IsMatch(Arg.Any <IBuildChain>(), typeof(Simple)).Returns(true);
secondAction.Priority.Returns(int.MinValue);
firstAction.WhenForAnyArgs(x => x.Execute(null !, null !, (Type)null !)).Do(
x =>
{
executeCount++;
executeCount.Should().Be(1);
});
secondAction.WhenForAnyArgs(x => x.Execute(null !, null !, (Type)null !)).Do(
x =>
{
executeCount++;
executeCount.Should().Be(2);
});
var sut = new DefaultExecuteStrategy();
sut.Initialize(buildConfiguration);
sut.Create(typeof(Simple));
firstAction.Received().Execute(Arg.Any <IBuildChain>(), Arg.Any <Simple>(), Arg.Any <Type>());
secondAction.Received().Execute(Arg.Any <IBuildChain>(), Arg.Any <Simple>(), Arg.Any <Type>());
}
public void CreateThrowsExceptionWhenNoCapabilityFoundForProperty()
{
var buildHistory = new BuildHistory();
var expected = new SlimModel();
var processor = Substitute.For <IBuildProcessor>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var propertyResolver = Substitute.For <IPropertyResolver>();
var typeCapability = Substitute.For <IBuildCapability>();
typeCapability.AutoPopulate.Returns(true);
typeCapability.SupportsCreate.Returns(true);
typeCapability.SupportsPopulate.Returns(true);
typeCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
typeof(SlimModel))
.Returns(typeCapability);
typeCapability.CreateType(sut, typeof(SlimModel), null !).Returns(expected);
typeCapability.Populate(sut, expected).Returns(expected);
buildConfiguration.PropertyResolver.Returns(propertyResolver);
propertyResolver.GetOrderedProperties(buildConfiguration, typeof(SlimModel))
.Returns(typeof(SlimModel).GetProperties());
sut.Initialize(buildConfiguration);
Action action = () => sut.Create(typeof(SlimModel));
action.Should().Throw <BuildException>();
}
public void BuildChainShouldBeEmptyAfterCreateCompleted()
{
var buildHistory = new BuildHistory();
var expected = new SlimModel();
var processor = Substitute.For <IBuildProcessor>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var buildCapability = Substitute.For <IBuildCapability>();
buildCapability.AutoPopulate.Returns(true);
buildCapability.SupportsCreate.Returns(true);
buildCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(), typeof(SlimModel)).Returns(buildCapability);
buildCapability.CreateType(sut, typeof(SlimModel), Arg.Any <object[]>()).Returns(expected);
sut.Initialize(buildConfiguration);
sut.BuildChain.Should().BeEmpty();
sut.Create(typeof(SlimModel));
sut.BuildChain.Should().BeEmpty();
}
public void IsCreatedWithNullBuildChainAndBuildLog()
{
var sut = new DefaultExecuteStrategy();
sut.Log.Should().NotBeNull();
sut.BuildChain.Should().NotBeNull();
}
public void PopulateThrowsExceptionWhenProcessorReturnsNull()
{
var model = new SlimModel();
var buildHistory = new BuildHistory();
var processor = Substitute.For <IBuildProcessor>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var typeCapability = Substitute.For <IBuildCapability>();
typeCapability.SupportsCreate.Returns(true);
typeCapability.SupportsPopulate.Returns(true);
typeCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
typeof(SlimModel))
.Returns(typeCapability);
sut.Initialize(buildConfiguration);
Action action = () => sut.Populate(model);
action.Should().Throw <BuildException>();
}
public void CreatePopulatesWithProcessorWhenAutoPopulateDisabled()
{
var buildHistory = new BuildHistory();
var expected = new SlimModel();
var processor = Substitute.For <IBuildProcessor>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var typeCapability = Substitute.For <IBuildCapability>();
typeCapability.SupportsPopulate.Returns(true);
typeCapability.SupportsCreate.Returns(true);
typeCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
typeof(SlimModel))
.Returns(typeCapability);
typeCapability.CreateType(sut, typeof(SlimModel), Arg.Any <object[]>()).Returns(expected);
typeCapability.Populate(sut, expected).Returns(expected);
sut.Initialize(buildConfiguration);
var actual = (SlimModel)sut.Create(typeof(SlimModel)) !;
actual.Should().Be(expected);
actual.Value.Should().BeEmpty();
typeCapability.Received().Populate(sut, expected);
}
public void CreateReturnsValueCreatedFromProvidedArguments()
{
var buildHistory = new BuildHistory();
var expected = new Person();
var args = new object[]
{
Guid.NewGuid().ToString(),
Guid.NewGuid().ToString(),
DateTime.UtcNow,
true,
Guid.NewGuid(),
Environment.TickCount
};
var processor = Substitute.For <IBuildProcessor>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var propertyResolver = Substitute.For <IPropertyResolver>();
var typeCapability = Substitute.For <IBuildCapability>();
typeCapability.SupportsCreate.Returns(true);
typeCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
typeof(Person))
.Returns(typeCapability);
typeCapability.CreateType(sut, typeof(Person), args).Returns(expected);
buildConfiguration.PropertyResolver.Returns(propertyResolver);
sut.Initialize(buildConfiguration);
var actual = sut.Create(typeof(Person), args);
actual.Should().BeSameAs(expected);
}
public void CreateThrowsExceptionWhenNotInitialized()
{
var sut = new DefaultExecuteStrategy();
Action action = () => sut.Create(typeof(Person));
action.Should().Throw <BuildException>();
}
public void PopulateThrowsExceptionWithNullInstance()
{
var sut = new DefaultExecuteStrategy();
Action action = () => sut.Populate(null !);
action.Should().Throw <ArgumentNullException>();
}
public void InitializeThrowsExceptionWithNullBuildConfiguration()
{
var sut = new DefaultExecuteStrategy();
Action action = () => sut.Initialize(null !);
action.Should().Throw <ArgumentNullException>();
}
public void CreatePushesInstanceIntoBuildChain()
{
var testPassed = false;
var buildHistory = new BuildHistory();
var expected = new SlimModel();
var value = Guid.NewGuid();
var processor = Substitute.For <IBuildProcessor>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var propertyResolver = Substitute.For <IPropertyResolver>();
var typeCapability = Substitute.For <IBuildCapability>();
var valueCapability = Substitute.For <IBuildCapability>();
typeCapability.SupportsPopulate.Returns(true);
typeCapability.AutoPopulate.Returns(true);
typeCapability.SupportsCreate.Returns(true);
typeCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
valueCapability.SupportsCreate.Returns(true);
valueCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
typeof(SlimModel))
.Returns(typeCapability);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
Arg.Any <PropertyInfo>())
.Returns(valueCapability);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
typeof(Guid))
.Returns(valueCapability);
typeCapability.CreateType(sut, typeof(SlimModel), Arg.Any <object[]>()).Returns(expected);
valueCapability.CreateProperty(sut, Arg.Any <PropertyInfo>(), Arg.Any <object[]>()).Returns(value);
valueCapability.When(
x => x.CreateProperty(
Arg.Is <IExecuteStrategy>(y => y.BuildChain.Last == expected), Arg.Any <PropertyInfo>(),
Arg.Any <object[]>())).Do(
x =>
{
sut.BuildChain.Should().HaveCount(1);
sut.BuildChain.First().Should().BeOfType <SlimModel>();
testPassed = true;
});
typeCapability.Populate(sut, expected).Returns(expected);
buildConfiguration.PropertyResolver.Returns(propertyResolver);
propertyResolver.GetOrderedProperties(buildConfiguration, typeof(SlimModel))
.Returns(typeof(SlimModel).GetProperties());
sut.Initialize(buildConfiguration);
var actual = (SlimModel)sut.Create(typeof(SlimModel)) !;
actual.Should().Be(expected);
actual.Value.Should().Be(value);
sut.BuildChain.Count.Should().Be(0);
testPassed.Should().BeTrue();
}
public void InitializeStoresConfiguration()
{
var configuration = Substitute.For <IBuildConfiguration>();
var sut = new DefaultExecuteStrategy();
sut.Initialize(configuration);
sut.Configuration.Should().BeSameAs(configuration);
}
public void PopulateThrowsExceptionWhenNotInitialized()
{
var value = new Person();
var sut = new DefaultExecuteStrategy();
Action action = () => sut.Populate(value);
action.Should().Throw <BuildException>();
}
public void PopulateThrowsExceptionWithNullInstance()
{
var buildHistory = new BuildHistory();
var processor = Substitute.For <IBuildProcessor>();
var sut = new DefaultExecuteStrategy <Person>(buildHistory, _buildLog, processor);
Action action = () => sut.Populate(null !);
action.Should().Throw <ArgumentNullException>();
}
public void CreateThrowsExceptionWithNullType()
{
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var sut = new DefaultExecuteStrategy();
sut.Initialize(buildConfiguration);
Action action = () => sut.Create(null !);
action.Should().Throw <ArgumentNullException>();
}
public void CreateDoesNotEvaluateNullPostBuildActions()
{
var defaultConfiguration = Model.UsingDefaultConfiguration();
var sut = new DefaultExecuteStrategy();
sut.Initialize(defaultConfiguration);
var actual = sut.Create(typeof(SimpleConstructor));
actual.Should().NotBeNull();
}
public void ConfigurationThrowsExceptionWhenNotInitialized()
{
var sut = new DefaultExecuteStrategy();
Action action = () =>
{
// ReSharper disable once UnusedVariable
var config = sut.Configuration;
};
action.Should().Throw <InvalidOperationException>();
}
public void CreateThrowsExceptionWhenAutomaticTypeMappingCantFindMatch()
{
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var sut = new DefaultExecuteStrategy();
sut.Initialize(buildConfiguration);
Action action = () => sut.Create(typeof(ICantCreate));
action.Should().Throw <BuildException>();
}
public void CreateParametersThrowsExceptionWithNullMethod()
{
var buildHistory = new BuildHistory();
var processor = Substitute.For <IBuildProcessor>();
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
Action action = () => sut.CreateParameters(null !);
action.Should().Throw <ArgumentNullException>();
}
public void CreateDeterminesPropertiesToCreateByProvidingConstructorArgsForNestedType()
{
var buildHistory = new BuildHistory();
var model = new SlimModel();
var expected = new SimpleConstructor(model);
var age = Environment.TickCount;
var typeCapability = Substitute.For <IBuildCapability>();
var valueCapability = Substitute.For <IBuildCapability>();
var processor = Substitute.For <IBuildProcessor>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var propertyResolver = Substitute.For <IPropertyResolver>();
typeCapability.SupportsPopulate.Returns(true);
typeCapability.AutoPopulate.Returns(true);
typeCapability.SupportsCreate.Returns(true);
typeCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
valueCapability.SupportsCreate.Returns(true);
valueCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
typeof(SimpleConstructor))
.Returns(typeCapability);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
Arg.Any <PropertyInfo>())
.Returns(valueCapability);
processor.GetBuildCapability(sut, Arg.Any <BuildRequirement>(),
typeof(int))
.Returns(valueCapability);
typeCapability.CreateType(sut, typeof(SimpleConstructor), Arg.Any <object[]>()).Returns(expected);
valueCapability.CreateProperty(sut, Arg.Is <PropertyInfo>(x => x.Name == nameof(SimpleConstructor.Model)),
Arg.Any <object[]>()).Returns(model);
valueCapability.CreateProperty(sut, Arg.Is <PropertyInfo>(x => x.Name == nameof(SimpleConstructor.Age)),
Arg.Any <object[]>()).Returns(age);
typeCapability.Populate(sut, expected).Returns(expected);
buildConfiguration.PropertyResolver.Returns(propertyResolver);
propertyResolver.GetOrderedProperties(buildConfiguration, typeof(SimpleConstructor))
.Returns(typeof(SimpleConstructor).GetProperties());
sut.Initialize(buildConfiguration);
var actual = (SimpleConstructor)sut.Create(typeof(SimpleConstructor), model) !;
actual.Should().Be(expected);
actual.Model.Should().Be(model);
actual.Age.Should().Be(age);
}
public void BuildChainShouldBeEmptyAfterCreateCompletedTest()
{
var configuration = Model.BuildStrategy;
var buildLog = configuration.GetBuildLog();
var target = new DefaultExecuteStrategy();
target.Initialize(configuration, buildLog);
target.BuildChain.Should().BeEmpty();
target.Create(typeof(Company));
target.BuildChain.Should().BeEmpty();
}
public void CreateThrowsExceptionWhenNoCapabilityFoundForType()
{
var buildHistory = new BuildHistory();
var processor = Substitute.For <IBuildProcessor>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
sut.Initialize(buildConfiguration);
Action action = () => sut.Create(typeof(SlimModel));
action.Should().Throw <BuildException>();
}
public void PopulateDoesNotAssignIgnoredProperty()
{
var buildHistory = new BuildHistory();
var model = new SlimModel();
var processor = Substitute.For <IBuildProcessor>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var propertyResolver = Substitute.For <IPropertyResolver>();
var typeCapability = Substitute.For <IBuildCapability>();
var valueCapability = Substitute.For <IBuildCapability>();
typeCapability.AutoPopulate.Returns(true);
typeCapability.SupportsCreate.Returns(true);
typeCapability.SupportsPopulate.Returns(true);
typeCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
valueCapability.SupportsCreate.Returns(true);
valueCapability.ImplementedByType.Returns(typeof(DummyTypeCreator));
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
processor.GetBuildCapability(sut, BuildRequirement.Populate,
typeof(SlimModel))
.Returns(typeCapability);
buildConfiguration.PropertyResolver.Returns(propertyResolver);
propertyResolver.GetOrderedProperties(buildConfiguration, typeof(SlimModel))
.Returns(typeof(SlimModel).GetProperties());
processor.GetBuildCapability(sut, BuildRequirement.Create,
Arg.Is <PropertyInfo>(x => x.Name == nameof(SlimModel.Value)))
.Returns(valueCapability);
processor.GetBuildCapability(sut, BuildRequirement.Populate,
typeof(Guid))
.Returns(valueCapability);
typeCapability.Populate(sut, model).Returns(model);
propertyResolver.IsIgnored(
Arg.Any <IBuildConfiguration>(),
Arg.Any <object>(),
Arg.Any <PropertyInfo>(),
Arg.Any <object[]>()).Returns(true);
sut.Initialize(buildConfiguration);
var actual = (SlimModel)sut.Populate(model);
actual.Value.Should().BeEmpty();
typeCapability.DidNotReceive()
.CreateProperty(sut, Arg.Is <PropertyInfo>(x => x.Name == nameof(SlimModel.Value)), null !);
}
public void PopulateReturnsInstanceWhenNoBuildActionCapabilityFound()
{
var buildHistory = new BuildHistory();
var model = new SlimModel();
var processor = Substitute.For <IBuildProcessor>();
var buildConfiguration = Substitute.For <IBuildConfiguration>();
var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor);
sut.Initialize(buildConfiguration);
var actual = sut.Populate(model);
actual.Should().Be(model);
}
public void CreateEvaluatesPostBuildActionsWhenCapabilityDoesNotSupportPopulation()
{
var action = Substitute.For <IPostBuildAction>();
var buildConfiguration = Model.UsingDefaultConfiguration().Add(action);
action.IsMatch(Arg.Any <IBuildChain>(), Arg.Any <Type>()).Returns(true);
var sut = new DefaultExecuteStrategy();
sut.Initialize(buildConfiguration);
sut.Create(typeof(SlimModel));
action.Received().Execute(Arg.Any <IBuildChain>(), Arg.Any <SlimModel>(), typeof(SlimModel));
action.Received().Execute(Arg.Any <IBuildChain>(), Arg.Any <SlimModel>(), typeof(SlimModel));
}
public void CreateEvaluatesPostBuildActionsOfNestedInstancesExposedAsReadOnlyProperties()
{
var postBuildAction = Substitute.For <IPostBuildAction>();
var buildConfiguration = Model.UsingDefaultConfiguration().Add(postBuildAction);
var propertyInfo = typeof(ReadOnlyParent).GetProperty(nameof(ReadOnlyParent.Company)) !;
postBuildAction.IsMatch(Arg.Any <IBuildChain>(), propertyInfo)
.Returns(true);
var sut = new DefaultExecuteStrategy();
sut.Initialize(buildConfiguration);
sut.Create(typeof(ReadOnlyParent));
postBuildAction.Received().Execute(Arg.Any <IBuildChain>(), Arg.Any <Company>(), propertyInfo);
}
public void CreateEvaluatesPostBuildActionsThatSupportTheBuildScenario()
{
var firstAction = Substitute.For <IPostBuildAction>();
var secondAction = Substitute.For <IPostBuildAction>();
var buildConfiguration = Model.UsingDefaultConfiguration().Add(firstAction).Add(secondAction);
firstAction.IsMatch(Arg.Any <IBuildChain>(), Arg.Any <Type>()).Returns(false);
secondAction.IsMatch(Arg.Any <IBuildChain>(), Arg.Any <Type>()).Returns(true);
var sut = new DefaultExecuteStrategy();
sut.Initialize(buildConfiguration);
sut.Create(typeof(Simple));
firstAction.DidNotReceive().Execute(Arg.Any <IBuildChain>(), Arg.Any <object>(), Arg.Any <Type>());
secondAction.Received().Execute(Arg.Any <IBuildChain>(), Arg.Any <object>(), Arg.Any <Type>());
}
public void CreateEvaluatesPostBuildActionsForParameters()
{
var postBuildAction = Substitute.For <IPostBuildAction>();
var buildConfiguration = Model.UsingDefaultConfiguration().Add(postBuildAction);
var parameterInfo = typeof(SimpleConstructor).GetConstructors()
.First(x => x.GetParameters().FirstOrDefault()?.Name == "model").GetParameters().First();
postBuildAction.IsMatch(Arg.Any <IBuildChain>(), parameterInfo)
.Returns(true);
var sut = new DefaultExecuteStrategy();
sut.Initialize(buildConfiguration);
sut.Create(typeof(SimpleConstructor));
postBuildAction.Received().Execute(Arg.Any <IBuildChain>(), Arg.Any <SlimModel>(), parameterInfo);
}
public void PopulateAddsItemsToInstancesTest(Type type)
{
var configuration = Model.UsingDefaultConfiguration();
var sut = new EnumerableTypeCreator();
var executeStrategy = new DefaultExecuteStrategy();
executeStrategy.Initialize(configuration);
var actual = sut.Create(executeStrategy, type) !;
sut.Populate(executeStrategy, actual);
var converted = (IEnumerable)actual;
converted.Should().NotBeEmpty();
}
public void CreateEvaluatesPostBuildActionsThatSupportTheBuildScenarioTest()
{
var firstAction = Substitute.For<IPostBuildAction>();
var secondAction = Substitute.For<IPostBuildAction>();
var buildStrategy = new DefaultBuildStrategyCompiler().Add(firstAction).Add(secondAction).Compile();
firstAction.IsSupported(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(false);
secondAction.IsSupported(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(true);
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
target.Create(typeof(Simple));
firstAction.DidNotReceive().Execute(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>());
secondAction.Received().Execute(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>());
}
public void CreateWithReturnsValueFromSupportedCreatorTest()
{
var firstModel = new SlimModel();
var secondModel = new SlimModel();
var value = Guid.NewGuid();
var valueGenerators = new List<IValueGenerator>();
var typeCreators = new List<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
var firstCreator = Substitute.For<ITypeCreator>();
var secondCreator = Substitute.For<ITypeCreator>();
var generator = Substitute.For<IValueGenerator>();
typeCreators.Add(firstCreator);
typeCreators.Add(secondCreator);
valueGenerators.Add(generator);
buildStrategy.TypeCreators.Returns(typeCreators.AsReadOnly());
buildStrategy.ValueGenerators.Returns(valueGenerators.AsReadOnly());
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
firstCreator.CanCreate(typeof(SlimModel), null, Arg.Any<LinkedList<object>>()).Returns(false);
firstCreator.Create(typeof(SlimModel), null, Arg.Any<LinkedList<object>>()).Returns(firstModel);
firstCreator.Priority.Returns(10);
firstCreator.AutoPopulate.Returns(true);
firstCreator.Populate(firstModel, target).Returns(firstModel);
secondCreator.CanCreate(typeof(SlimModel), null, Arg.Any<LinkedList<object>>()).Returns(true);
secondCreator.Create(typeof(SlimModel), null, Arg.Any<LinkedList<object>>()).Returns(secondModel);
secondCreator.Priority.Returns(2);
secondCreator.AutoPopulate.Returns(true);
secondCreator.Populate(secondModel, target).Returns(secondModel);
generator.IsSupported(typeof(Guid), "Value", Arg.Is<LinkedList<object>>(x => x.Last.Value == secondModel))
.Returns(true);
generator.Generate(typeof(Guid), "Value", Arg.Is<LinkedList<object>>(x => x.Last.Value == secondModel))
.Returns(value);
var actual = (SlimModel)target.CreateWith(typeof(SlimModel));
actual.Should().BeSameAs(secondModel);
actual.Value.Should().Be(value);
}
public void CreateWithReturnsValueFromSupportedGeneratorTest()
{
var firstValue = Guid.NewGuid();
var secondValue = Guid.NewGuid();
var valueGenerators = new List<IValueGenerator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
var firstGenerator = Substitute.For<IValueGenerator>();
var secondGenerator = Substitute.For<IValueGenerator>();
valueGenerators.Add(firstGenerator);
valueGenerators.Add(secondGenerator);
buildStrategy.ValueGenerators.Returns(valueGenerators.AsReadOnly());
firstGenerator.IsSupported(typeof(Guid), null, Arg.Any<LinkedList<object>>()).Returns(false);
firstGenerator.Generate(typeof(Guid), null, Arg.Any<LinkedList<object>>()).Returns(firstValue);
firstGenerator.Priority.Returns(10);
secondGenerator.IsSupported(typeof(Guid), null, Arg.Any<LinkedList<object>>()).Returns(true);
secondGenerator.Generate(typeof(Guid), null, Arg.Any<LinkedList<object>>()).Returns(secondValue);
secondGenerator.Priority.Returns(2);
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
var actual = target.CreateWith(typeof(Guid));
actual.Should().Be(secondValue);
}
public void CreateWithReturnsValueTypeFromGeneratorTest()
{
var expected = Guid.NewGuid().ToString();
var valueGenerators = new List<IValueGenerator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
var valueGenerator = Substitute.For<IValueGenerator>();
valueGenerators.Add(valueGenerator);
buildStrategy.ValueGenerators.Returns(valueGenerators.AsReadOnly());
valueGenerator.IsSupported(typeof(string), null, Arg.Any<LinkedList<object>>()).Returns(true);
valueGenerator.Generate(typeof(string), null, Arg.Any<LinkedList<object>>()).Returns(expected);
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
var actual = target.CreateWith(typeof(string));
actual.Should().Be(expected);
}
public void PopulateAsObjectAssignsPropertyValuesToExistingInstanceTest()
{
var staff = new List<Person>();
var name = Guid.NewGuid().ToString();
var address = Guid.NewGuid().ToString();
var expected = new Company();
var valueGenerators = new List<IValueGenerator>();
var typeCreators = new List<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
var typeCreator = Substitute.For<ITypeCreator>();
var valueGenerator = Substitute.For<IValueGenerator>();
typeCreators.Add(typeCreator);
valueGenerators.Add(valueGenerator);
buildStrategy.TypeCreators.Returns(typeCreators.AsReadOnly());
buildStrategy.ValueGenerators.Returns(valueGenerators.AsReadOnly());
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
typeCreator.CanCreate(
typeof(IEnumerable<Person>),
"Staff",
Arg.Is<LinkedList<object>>(x => x.Last.Value == expected)).Returns(true);
typeCreator.Create(
typeof(IEnumerable<Person>),
"Staff",
Arg.Is<LinkedList<object>>(x => x.Last.Value == expected)).Returns(staff);
typeCreator.Populate(staff, target).Returns(staff);
valueGenerator.IsSupported(
typeof(string),
"Name",
Arg.Is<LinkedList<object>>(x => x.Last.Value == expected)).Returns(true);
valueGenerator.Generate(typeof(string), "Name", Arg.Is<LinkedList<object>>(x => x.Last.Value == expected))
.Returns(name);
valueGenerator.IsSupported(
typeof(string),
"Address",
Arg.Is<LinkedList<object>>(x => x.Last.Value == expected)).Returns(true);
valueGenerator.Generate(
typeof(string),
"Address",
Arg.Is<LinkedList<object>>(x => x.Last.Value == expected)).Returns(address);
var actual = (Company)target.Populate(expected);
actual.Should().BeSameAs(expected);
actual.Name.Should().Be(name);
actual.Address.Should().Be(address);
actual.Staff.Should().BeSameAs(staff);
}
public void PopulateThrowsExceptionWhenNotInitializedTest()
{
var value = new Person();
var target = new DefaultExecuteStrategy();
Action action = () => target.Populate(value);
action.ShouldThrow<InvalidOperationException>();
}
public void CreateWithReturnsNullWhenNoReferenceTypeCreatedTest()
{
var typeCreators = new List<ITypeCreator>();
var typeCreator = Substitute.For<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
typeCreators.Add(typeCreator);
buildStrategy.TypeCreators.Returns(typeCreators.AsReadOnly());
typeCreator.CanCreate(typeof(Stream), null, Arg.Any<LinkedList<object>>()).Returns(true);
typeCreator.Create(typeof(Stream), null, Arg.Any<LinkedList<object>>()).Returns(null);
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
var actual = target.CreateWith(typeof(Stream));
actual.Should().BeNull();
}
public void CreateWithThrowsExceptionWithNullTypeTest()
{
var buildStrategy = Substitute.For<IBuildStrategy>();
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
Action action = () => target.CreateWith(null);
action.ShouldThrow<ArgumentNullException>();
}
public void CreateWithReturnsValueFromCreatorWithNoArgumentsAndDetectConstructorEnabledTest()
{
var expected = new Person();
var typeCreators = new List<ITypeCreator>();
var typeCreator = Substitute.For<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
var resolver = Substitute.For<IConstructorResolver>();
typeCreators.Add(typeCreator);
buildStrategy.TypeCreators.Returns(typeCreators.AsReadOnly());
buildStrategy.ConstructorResolver.Returns(resolver);
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
resolver.Resolve(typeof(Person))
.Returns(typeof(Person).GetConstructors().Single(x => x.GetParameters().Length == 0));
typeCreator.CanCreate(typeof(Person), null, Arg.Any<LinkedList<object>>()).Returns(true);
typeCreator.Create(typeof(Person), null, Arg.Any<LinkedList<object>>()).Returns(expected);
typeCreator.Populate(expected, target).Returns(expected);
typeCreator.AutoPopulate.Returns(false);
typeCreator.AutoDetectConstructor.Returns(true);
var actual = target.CreateWith(typeof(Person));
actual.Should().BeSameAs(expected);
}
public void CreateWithThrowsExceptionWhenNoGeneratorOrCreatorMatchFoundForConstructorParameterTest()
{
var generators = new List<IValueGenerator>();
var creators = new List<ITypeCreator>();
var constructorResolver = new DefaultConstructorResolver();
var valueGenerator = Substitute.For<IValueGenerator>();
var typeCreator = Substitute.For<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
generators.Add(valueGenerator);
creators.Add(typeCreator);
typeCreator.CanCreate(typeof(KeyValuePair<string, Person>), null, Arg.Any<LinkedList<object>>())
.Returns(true);
typeCreator.AutoDetectConstructor.Returns(true);
typeCreator.AutoPopulate.Returns(true);
valueGenerator.IsSupported(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(false);
buildStrategy.TypeCreators.Returns(creators.AsReadOnly());
buildStrategy.ValueGenerators.Returns(generators.AsReadOnly());
buildStrategy.ConstructorResolver.Returns(constructorResolver);
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
Action action = () => target.CreateWith(typeof(KeyValuePair<string, Person>));
action.ShouldThrow<BuildException>();
}
public void CreateWithThrowsExceptionWhenGeneratingValueThrowsBuildExceptionTest()
{
var person = new Person();
var generators = new List<IValueGenerator>();
var creators = new List<ITypeCreator>();
var valueGenerator = Substitute.For<IValueGenerator>();
var typeCreator = Substitute.For<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
generators.Add(valueGenerator);
creators.Add(typeCreator);
typeCreator.CanCreate(typeof(Person), null, Arg.Any<LinkedList<object>>()).Returns(true);
typeCreator.Create(typeof(Person), null, Arg.Any<LinkedList<object>>()).Returns(person);
typeCreator.AutoPopulate.Returns(true);
valueGenerator.IsSupported(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(true);
valueGenerator.Generate(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>())
.Throws(new BuildException());
buildStrategy.TypeCreators.Returns(creators.AsReadOnly());
buildStrategy.ValueGenerators.Returns(generators.AsReadOnly());
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
Action action = () => target.CreateWith(typeof(Person));
action.ShouldThrow<BuildException>();
}
public void CreateWithThrowsExceptionWhenNoGeneratorOrCreatorMatchFoundTest()
{
var buildStrategy = Substitute.For<IBuildStrategy>();
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
Action action = () => target.CreateWith(typeof(string));
action.ShouldThrow<BuildException>();
}
public void CreateWithThrowsExceptionWhenNotInitializedTest()
{
var target = new DefaultExecuteStrategy();
Action action = () => target.CreateWith(typeof(Person));
action.ShouldThrow<InvalidOperationException>();
}
public void CreateWithThrowsExceptionWhenPropertyCannotBeCreatedTest()
{
var typeCreator = new DefaultTypeCreator();
var typeCreators = new List<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
var resolver = Substitute.For<IConstructorResolver>();
typeCreators.Add(typeCreator);
resolver.Resolve(typeof(SlimModel), Arg.Any<object[]>()).Returns(typeof(SlimModel).GetConstructors()[0]);
buildStrategy.ConstructorResolver.Returns(resolver);
buildStrategy.TypeCreators.Returns(typeCreators.AsReadOnly());
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
Action action = () => target.CreateWith(typeof(SlimModel));
action.ShouldThrow<BuildException>();
}
public void CreateWithReturnsValueFromSupportedCreationRuleWithHigherPriorityTest()
{
var firstValue = Guid.NewGuid();
var secondValue = Guid.NewGuid();
var buildStrategy =
Model.DefaultBuildStrategy.Clone()
.Add(new CreationRule(typeof(Person), "Id", 10, firstValue))
.Add(new CreationRule(typeof(Person), "Id", 20, secondValue))
.Compile();
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
var actual = (Person)target.CreateWith(typeof(Person));
actual.Id.Should().Be(secondValue);
}
public void CreateWithReturnsReferenceTypeFromCreatorTest()
{
var expected = new SlimModel();
var value = Guid.NewGuid();
var typeCreators = new List<ITypeCreator>();
var valueGenerators = new List<IValueGenerator>();
var typeCreator = Substitute.For<ITypeCreator>();
var generator = Substitute.For<IValueGenerator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
typeCreators.Add(typeCreator);
valueGenerators.Add(generator);
buildStrategy.TypeCreators.Returns(typeCreators.AsReadOnly());
buildStrategy.ValueGenerators.Returns(valueGenerators.AsReadOnly());
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
typeCreator.CanCreate(typeof(SlimModel), null, Arg.Any<LinkedList<object>>()).Returns(true);
typeCreator.Create(typeof(SlimModel), null, Arg.Any<LinkedList<object>>()).Returns(expected);
typeCreator.Populate(expected, target).Returns(expected);
typeCreator.AutoPopulate.Returns(true);
generator.IsSupported(typeof(Guid), "Value", Arg.Is<LinkedList<object>>(x => x.Last.Value == expected))
.Returns(true);
generator.Generate(typeof(Guid), "Value", Arg.Is<LinkedList<object>>(x => x.Last.Value == expected))
.Returns(value);
var actual = (SlimModel)target.CreateWith(typeof(SlimModel));
actual.Should().Be(expected);
actual.Value.Should().Be(value);
}
public void CreateWithReturnsValueFromResolvedConstructorAndBuiltParametersTest()
{
var value = Guid.NewGuid();
var expected = new ReadOnlyModel(value);
var valueGenerators = new List<IValueGenerator>();
var typeCreators = new List<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
var resolver = Substitute.For<IConstructorResolver>();
var generator = Substitute.For<IValueGenerator>();
var typeCreator = Substitute.For<ITypeCreator>();
typeCreators.Add(typeCreator);
valueGenerators.Add(generator);
resolver.Resolve(typeof(ReadOnlyModel), Arg.Any<object[]>())
.Returns(typeof(ReadOnlyModel).GetConstructors()[0]);
buildStrategy.ConstructorResolver.Returns(resolver);
buildStrategy.TypeCreators.Returns(typeCreators.AsReadOnly());
buildStrategy.ValueGenerators.Returns(valueGenerators.AsReadOnly());
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
typeCreator.CanCreate(typeof(ReadOnlyModel), null, Arg.Any<LinkedList<object>>()).Returns(true);
typeCreator.Create(typeof(ReadOnlyModel), null, Arg.Any<LinkedList<object>>(), value).Returns(expected);
typeCreator.Populate(expected, target).Returns(expected);
typeCreator.AutoPopulate.Returns(true);
typeCreator.AutoDetectConstructor.Returns(true);
generator.IsSupported(typeof(Guid), "value", Arg.Any<LinkedList<object>>()).Returns(true);
generator.Generate(typeof(Guid), "value", Arg.Any<LinkedList<object>>()).Returns(value);
var actual = (ReadOnlyModel)target.CreateWith(typeof(ReadOnlyModel));
actual.Should().Be(expected);
actual.Value.Should().Be(value);
}
public void CreateThrowsExceptionWhenPropertyCannotBeCreatedTest()
{
var typeCreator = Substitute.For<ITypeCreator>();
typeCreator.CanCreate(typeof(Address), "Address", Arg.Any<LinkedList<object>>()).Returns(true);
typeCreator.Priority.Returns(int.MaxValue);
typeCreator.AutoDetectConstructor.Returns(true);
typeCreator.AutoPopulate.Returns(true);
typeCreator.Create(typeof(Address), "Address", Arg.Any<LinkedList<object>>())
.Throws(new InvalidOperationException());
var buildStrategy = new DefaultBuildStrategyCompiler().Add(typeCreator).Compile();
var target = new DefaultExecuteStrategy<Company>();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
Action action = () => target.CreateWith();
var exception =
action.ShouldThrow<BuildException>().Where(x => x.Message != null).Where(x => x.BuildLog != null).Which;
_output.WriteLine(exception.Message);
}
public void CreateWithReturnsValueCreatedFromProvidedArgumentsTest()
{
var expected = new Person();
var args = new object[]
{
Guid.NewGuid().ToString(),
Guid.NewGuid().ToString(),
DateTime.UtcNow,
true,
Guid.NewGuid(),
Environment.TickCount
};
var typeCreators = new List<ITypeCreator>();
var typeCreator = Substitute.For<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
typeCreators.Add(typeCreator);
buildStrategy.TypeCreators.Returns(typeCreators.AsReadOnly());
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
typeCreator.CanCreate(typeof(Person), null, Arg.Any<LinkedList<object>>()).Returns(true);
typeCreator.Create(typeof(Person), null, Arg.Any<LinkedList<object>>(), args).Returns(expected);
typeCreator.Populate(expected, target).Returns(expected);
typeCreator.AutoPopulate.Returns(false);
var actual = target.CreateWith(typeof(Person), args);
actual.Should().BeSameAs(expected);
}
public void CreateWithThrowsExceptionWhenGeneratingValueFailsTest()
{
var person = new Person();
var generators = new List<IValueGenerator>();
var creators = new List<ITypeCreator>();
var valueGenerator = Substitute.For<IValueGenerator>();
var typeCreator = Substitute.For<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
generators.Add(valueGenerator);
creators.Add(typeCreator);
typeCreator.CanCreate(typeof(Person), null, Arg.Any<LinkedList<object>>()).Returns(true);
typeCreator.Create(typeof(Person), null, null, null).Returns(person);
valueGenerator.IsSupported(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(true);
valueGenerator.Generate(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>())
.Throws(new InvalidOperationException());
buildStrategy.TypeCreators.Returns(creators.AsReadOnly());
buildStrategy.ValueGenerators.Returns(generators.AsReadOnly());
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
Action action = () => target.CreateWith(typeof(Person));
var exception =
action.ShouldThrow<BuildException>().Where(x => x.Message != null).Where(x => x.BuildLog != null).Which;
_output.WriteLine(exception.Message);
}
public void CreateWithReturnsNullWhenNoValueTypeCreatedTest()
{
var valueGenerators = new List<IValueGenerator>();
var valueGenerator = Substitute.For<IValueGenerator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
valueGenerators.Add(valueGenerator);
buildStrategy.ValueGenerators.Returns(valueGenerators.AsReadOnly());
valueGenerator.IsSupported(typeof(int), null, Arg.Any<LinkedList<object>>()).Returns(true);
valueGenerator.Generate(typeof(int), null, Arg.Any<LinkedList<object>>()).Returns(null);
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
var actual = target.CreateWith(typeof(int));
actual.Should().BeNull();
}
public void CreatePopulatesReadOnlyReferencePropertiesTest()
{
var configuration = Model.BuildStrategy;
var buildLog = configuration.GetBuildLog();
var target = new DefaultExecuteStrategy<ReadOnlyParent>();
target.Initialize(configuration, buildLog);
var actual = target.Create();
actual.Company.Address.Should().NotBeNullOrWhiteSpace();
actual.AssignablePeople.Should().NotBeEmpty();
actual.People.Should().NotBeEmpty();
actual.RestrictedPeople.Should().BeEmpty();
actual.Unassigned.Should().BeNull();
}
public void PopulateThrowsExceptionWithNullInstanceTest()
{
var target = new DefaultExecuteStrategy();
Action action = () => target.Populate(null);
action.ShouldThrow<ArgumentNullException>();
}
public void IsCreatedWithBuildChainInstanceTest()
{
var target = new DefaultExecuteStrategy();
target.BuildChain.Should().NotBeNull();
}
public void CreateWithDoesNotBuildPropertiesWhenTypeCreatorDisablesAutoPopulateTest()
{
var model = new SlimModel();
var typeCreators = new List<ITypeCreator>();
var buildLog = new DefaultBuildLog();
var typeCreator = Substitute.For<ITypeCreator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
typeCreators.Add(typeCreator);
buildStrategy.GetBuildLog().Returns(buildLog);
buildStrategy.TypeCreators.Returns(typeCreators.AsReadOnly());
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
typeCreator.CanCreate(typeof(SlimModel), null, Arg.Any<LinkedList<object>>()).Returns(true);
typeCreator.Create(typeof(SlimModel), null, Arg.Any<LinkedList<object>>()).Returns(model);
typeCreator.Priority.Returns(1);
typeCreator.AutoPopulate.Returns(false);
typeCreator.Populate(model, target).Returns(model);
var actual = (SlimModel)target.CreateWith(typeof(SlimModel));
actual.Should().BeSameAs(model);
actual.Value.Should().BeEmpty();
}
public void InitializeStoresConfigurationAndBuildLogTest()
{
var configuration = Substitute.For<IBuildConfiguration>();
var buildLog = Substitute.For<IBuildLog>();
var target = new DefaultExecuteStrategy();
target.Initialize(configuration, buildLog);
target.Configuration.Should().BeSameAs(configuration);
target.Log.Should().BeSameAs(buildLog);
}
public void IsCreatedWithNullBuildConfigurationAndBuildLogTest()
{
var target = new DefaultExecuteStrategy();
target.Configuration.Should().BeNull();
target.Log.Should().BeNull();
target.BuildChain.Should().NotBeNull();
}
public void InitializeThrowsExceptionWithNullBuildLogTest()
{
var configuration = Substitute.For<IBuildConfiguration>();
var target = new DefaultExecuteStrategy();
Action action = () => target.Initialize(configuration, null);
action.ShouldThrow<ArgumentNullException>();
}
