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 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 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 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 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 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 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 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 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 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 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 CreateDoesNotEvaluateNullPostBuildActions() { var defaultConfiguration = Model.UsingDefaultConfiguration(); var sut = new DefaultExecuteStrategy(); sut.Initialize(defaultConfiguration); var actual = sut.Create(typeof(SimpleConstructor)); actual.Should().NotBeNull(); }
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 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 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 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 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 PopulateAssignsPropertyValuesToExistingInstance() { var buildHistory = new BuildHistory(); var model = new SlimModel(); var expected = Guid.NewGuid(); var properties = typeof(SlimModel).GetProperties(); var propertyInfo = properties.Single(); 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(properties); processor.GetBuildCapability(sut, BuildRequirement.Create, propertyInfo) .Returns(valueCapability); valueCapability.CreateProperty(sut, propertyInfo, Arg.Any <object?[]?>()) .Returns(expected); processor.GetBuildCapability(sut, BuildRequirement.Populate, typeof(Guid)) .Returns(valueCapability); typeCapability.Populate(sut, model).Returns(model); sut.Initialize(buildConfiguration); var actual = (SlimModel)sut.Populate(model); actual.Value.Should().Be(expected); }
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 CreateParametersReturnsNullWhenNoOrderedParametersReturned() { var buildHistory = new BuildHistory(); var method = typeof(SlimModel).GetConstructors().First(); var parameters = Array.Empty <ParameterInfo>(); var processor = Substitute.For <IBuildProcessor>(); var parameterResolver = Substitute.For <IParameterResolver>(); var buildConfiguration = Substitute.For <IBuildConfiguration>(); parameterResolver.GetOrderedParameters(buildConfiguration, method).Returns(parameters); buildConfiguration.ParameterResolver.Returns(parameterResolver); var sut = new DefaultExecuteStrategy(buildHistory, _buildLog, processor); sut.Initialize(buildConfiguration); var actual = sut.CreateParameters(method); actual.Should().BeNull(); }
public void CreateParametersReturnsOriginalParameterOrderCreatedInOrderOfPriority() { var buildHistory = new BuildHistory(); var method = typeof(OrderedConstructorParameters).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.Is <ParameterInfo>(x => x.ParameterType == typeof(string)), null) .Returns("first", "second", "third", "fourth"); parameterCapability .CreateParameter(sut, Arg.Is <ParameterInfo>(x => x.ParameterType == typeof(Gender)), null) .Returns(Gender.Female); 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(5); actual[0].Should().Be("second"); actual[1].Should().Be("first"); actual[2].Should().Be("fourth"); actual[3].Should().Be("third"); actual[4].Should().Be(Gender.Female); }
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 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 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 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 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 PopulateOnlySetsPublicPropertiesTest() { var expected = new PropertyScopes(); var value = Guid.NewGuid(); var valueGenerators = new List<IValueGenerator>(); var buildStrategy = Substitute.For<IBuildStrategy>(); var valueGenerator = Substitute.For<IValueGenerator>(); valueGenerators.Add(valueGenerator); buildStrategy.ValueGenerators.Returns(valueGenerators.AsReadOnly()); var target = new DefaultExecuteStrategy(); target.Initialize(buildStrategy, buildStrategy.GetBuildLog()); valueGenerator.IsSupported(typeof(Guid), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(true); valueGenerator.Generate(typeof(Guid), Arg.Any<string>(), Arg.Any<LinkedList<object>>()).Returns(value); var actual = (PropertyScopes)target.Populate(expected); actual.Should().BeSameAs(expected); actual.Public.Should().Be(value); actual.InternalSet.Should().BeEmpty(); actual.ReadOnly.Should().BeEmpty(); PropertyScopes.GlobalValue.Should().BeEmpty(); }
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 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 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 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 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 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 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 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 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 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 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 PopulateSkipsPropertiesMarkedWithIgnoreRuleWithTypeMatchesBaseClassTest() { var staff = new List<Person>(); var name = Guid.NewGuid().ToString(); var expected = new SpecificCompany(); var ignoreRule = new IgnoreRule(typeof(Company), "Name"); var valueGenerators = new List<IValueGenerator>(); var typeCreators = new List<ITypeCreator>(); var ignoreRules = new List<IgnoreRule> { ignoreRule }; 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()); buildStrategy.IgnoreRules.Returns(ignoreRules.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), Arg.Any<string>(), Arg.Is<LinkedList<object>>(x => x.Last.Value == expected)).Returns(true); valueGenerator.Generate( typeof(string), Arg.Any<string>(), Arg.Is<LinkedList<object>>(x => x.Last.Value == expected)).Returns(name); var actual = (SpecificCompany)target.Populate(expected); actual.Should().BeSameAs(expected); actual.Name.Should().BeNullOrEmpty(); actual.Staff.Should().BeSameAs(staff); }
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 PopulatePushesInstanceIntoBuildChainWhilePopulatingTest() { var instance = new SlimModel(); var testPassed = false; 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()); 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.Should().Contain(instance); testPassed = true; }); generator.IsSupported( typeof(Guid), nameof(SlimModel.Value), Arg.Is<LinkedList<object>>(x => x.Last.Value == instance)).Returns(true); target.Populate(instance); testPassed.Should().BeTrue(); }
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 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 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 InitializeThrowsExceptionWithNullBuildLogTest() { var configuration = Substitute.For<IBuildConfiguration>(); var target = new DefaultExecuteStrategy(); Action action = () => target.Initialize(configuration, null); action.ShouldThrow<ArgumentNullException>(); }
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); }