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 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 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 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 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 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 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 CreateThrowsExceptionWhenNotInitialized()
{
var sut = new DefaultExecuteStrategy();
Action action = () => sut.Create(typeof(Person));
action.Should().Throw <BuildException>();
}
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 CreateDoesNotEvaluateNullPostBuildActions()
{
var defaultConfiguration = Model.UsingDefaultConfiguration();
var sut = new DefaultExecuteStrategy();
sut.Initialize(defaultConfiguration);
var actual = sut.Create(typeof(SimpleConstructor));
actual.Should().NotBeNull();
}
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 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 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 CreateReturnsValueFromProcessorWithPropertyPopulation()
{
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.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, 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);
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);
}
public void CreateThrowsExceptionWhenProcessorReturnsNull()
{
var buildHistory = new BuildHistory();
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);
sut.Initialize(buildConfiguration);
Action action = () => sut.Create(typeof(SlimModel));
action.Should().Throw <BuildException>();
}
public void CreatesPropertyOfSameTypeWithCreatedInstanceTest()
{
var configuration = Model.BuildStrategy;
var buildLog = configuration.GetBuildLog();
var target = new DefaultExecuteStrategy<ReadOnlyParent>();
target.Initialize(configuration, buildLog);
var actual = (Looper)target.Create(typeof(Looper));
actual.Should().NotBeNull();
actual.Stuff.Should().NotBeNullOrWhiteSpace();
actual.Other.Should().BeSameAs(actual);
}
public void PopulatePushesInstanceIntoBuildChainWhileCreatingTest()
{
var instance = new SlimModel();
var testPassed = false;
var creator = Substitute.For<ITypeCreator>();
var generator = Substitute.For<IValueGenerator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
buildStrategy.CreationRules.Returns(new List<CreationRule>().AsReadOnly());
buildStrategy.ValueGenerators.Returns(
new List<IValueGenerator>
{
generator
}.AsReadOnly());
buildStrategy.TypeCreators.Returns(
new List<ITypeCreator>
{
creator
}.AsReadOnly());
creator.CanCreate(typeof(SlimModel), null, Arg.Any<LinkedList<object>>()).Returns(true);
creator.Create(typeof(SlimModel), null, Arg.Any<LinkedList<object>>()).Returns(instance);
creator.AutoPopulate.Returns(true);
generator.When(
x =>
x.Generate(
typeof(Guid),
nameof(SlimModel.Value),
Arg.Is<LinkedList<object>>(y => y.Last.Value == instance))).Do(
x =>
{
target.BuildChain.Should().HaveCount(1);
target.BuildChain.First().Should().BeOfType<SlimModel>();
testPassed = true;
});
generator.IsSupported(
typeof(Guid),
nameof(SlimModel.Value),
Arg.Is<LinkedList<object>>(x => x.Last.Value == instance)).Returns(true);
target.Create(typeof(SlimModel));
testPassed.Should().BeTrue();
}
public void PopulatePushesNestedInstanceIntoBuildChainWhileCreatingTest()
{
var office = new Office();
var address = new Address();
var testPassed = false;
var creator = Substitute.For<ITypeCreator>();
var generator = Substitute.For<IValueGenerator>();
var buildStrategy = Substitute.For<IBuildStrategy>();
var target = new DefaultExecuteStrategy();
target.Initialize(buildStrategy, buildStrategy.GetBuildLog());
buildStrategy.CreationRules.Returns(new List<CreationRule>().AsReadOnly());
buildStrategy.ValueGenerators.Returns(
new List<IValueGenerator>
{
generator
}.AsReadOnly());
buildStrategy.TypeCreators.Returns(
new List<ITypeCreator>
{
creator
}.AsReadOnly());
creator.CanCreate(Arg.Any<Type>(), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(true);
creator.Create(typeof(Office), null, Arg.Any<LinkedList<object>>()).Returns(office);
creator.Create(typeof(Address), "Address", Arg.Is<LinkedList<object>>(x => x.Last.Value == office))
.Returns(address);
creator.AutoPopulate.Returns(true);
generator.When(
x =>
x.Generate(
typeof(string),
Arg.Any<string>(),
Arg.Is<LinkedList<object>>(y => y.Last.Value == address))).Do(
x =>
{
target.BuildChain.Should().HaveCount(2);
target.BuildChain.First.Value.Should().Be(office);
target.BuildChain.Last.Value.Should().Be(address);
testPassed = true;
});
generator.IsSupported(typeof(string), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(true);
generator.Generate(typeof(string), Arg.Any<string>(), Arg.Any<LinkedList<object>>())
.Returns(Guid.NewGuid().ToString());
target.Create(typeof(Office));
testPassed.Should().BeTrue();
}
public void CreateThrowsExceptionWhenNotInitializedTest()
{
var target = new DefaultExecuteStrategy();
Action action = () => target.Create(typeof(Person));
action.ShouldThrow<InvalidOperationException>();
}
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 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 CreatesCircularReferenceWithInstanceFromBuildChainTest()
{
var configuration = Model.BuildStrategy;
var buildLog = configuration.GetBuildLog();
var target = new DefaultExecuteStrategy<ReadOnlyParent>();
target.Initialize(configuration, buildLog);
var actual = (Top)target.Create(typeof(Top));
actual.Should().NotBeNull();
actual.Value.Should().NotBeNullOrWhiteSpace();
actual.Next.Should().NotBeNull();
actual.Next.Value.Should().NotBeNullOrWhiteSpace();
actual.Next.End.Should().NotBeNull();
actual.Next.End.Value.Should().NotBeNullOrWhiteSpace();
actual.Next.End.Root.Should().BeSameAs(actual);
}
