public void CompileThrowsExceptionWithNullConstructorResolverTest()
{
var target = new BuildStrategyCompiler();
Action action = () => target.Compile();
action.ShouldThrow<InvalidOperationException>();
}
public void AddCreationRuleAddsRuleToCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddCreationRule<DummyCreationRule>();
var actual = target.CreationRules.Single();
actual.Should().BeOfType<DummyCreationRule>();
}
public void AddCreationRuleWithExpressionThrowsExceptionWithNullExpressionTest()
{
var priority = Environment.TickCount;
var value = Guid.NewGuid().ToString();
var target = new BuildStrategyCompiler();
Action action = () => target.AddCreationRule((Expression<Func<Person, object>>) null, priority, value);
action.ShouldThrow<ArgumentNullException>();
}
public void CreatesDefaultsForPropertiesTest()
{
var target = new BuildStrategyCompiler();
target.ConstructorResolver.Should().BeNull();
target.CreationRules.Should().NotBeNull();
target.ExecuteOrderRules.Should().NotBeNull();
target.IgnoreRules.Should().NotBeNull();
target.TypeCreators.Should().NotBeNull();
target.ValueGenerators.Should().NotBeNull();
target.PostBuildActions.Should().NotBeNull();
}
public void CompileReturnsNewBuildStrategyTest()
{
var constructorResolver = Substitute.For<IConstructorResolver>();
var creationRules = new List<CreationRule>
{
new CreationRule(typeof(string), "Test", int.MaxValue, "Stuff")
};
var typeCreators = new List<ITypeCreator>
{
new DefaultTypeCreator()
};
var valueGenerators = new List<IValueGenerator>
{
new AddressValueGenerator()
};
var ignoreRules = new List<IgnoreRule>
{
new IgnoreRule(typeof(Person), "FirstName")
};
var executeOrderRules = new List<ExecuteOrderRule>
{
new ExecuteOrderRule(typeof(Person), "LastName", int.MinValue)
};
var postBuildActions = new List<IPostBuildAction>
{
Substitute.For<IPostBuildAction>()
};
var target = new BuildStrategyCompiler
{
ConstructorResolver = constructorResolver
};
target.CreationRules.Add(creationRules[0]);
target.TypeCreators.Add(typeCreators[0]);
target.ValueGenerators.Add(valueGenerators[0]);
target.IgnoreRules.Add(ignoreRules[0]);
target.ExecuteOrderRules.Add(executeOrderRules[0]);
target.PostBuildActions.Add(postBuildActions[0]);
var actual = target.Compile();
actual.ConstructorResolver.Should().Be(constructorResolver);
actual.CreationRules.ShouldBeEquivalentTo(creationRules);
actual.TypeCreators.ShouldBeEquivalentTo(typeCreators);
actual.ValueGenerators.ShouldBeEquivalentTo(valueGenerators);
actual.IgnoreRules.ShouldBeEquivalentTo(ignoreRules);
actual.ExecuteOrderRules.ShouldBeEquivalentTo(executeOrderRules);
actual.PostBuildActions.ShouldBeEquivalentTo(postBuildActions);
}
public void AddCreationRuleWithExpressionAddsRuleToCompilerTest()
{
var priority = Environment.TickCount;
var value = Guid.NewGuid().ToString();
var target = new BuildStrategyCompiler();
target.AddCreationRule<Person>(x => x.FirstName, priority, value);
var rule = target.CreationRules.Single();
rule.Priority.Should().Be(priority);
var actual = rule.Create(typeof(Person), nameof(Person.FirstName), null);
actual.Should().Be(value);
}
public void RemoveIgnoreRuleRemovesRulesFromCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddIgnoreRule<DummyIgnoreRule>();
target.RemoveIgnoreRule<DummyIgnoreRule>();
target.IgnoreRules.Should().BeEmpty();
}
public void RemoveExecuteOrderRuleRemovesRulesFromCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddExecuteOrderRule<DummyExecuteOrderRule>();
target.RemoveExecuteOrderRule<DummyExecuteOrderRule>();
target.ExecuteOrderRules.Should().BeEmpty();
}
public void RemoveCreationRuleRemovesRulesFromCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddCreationRule<DummyCreationRule>();
target.RemoveCreationRule<DummyCreationRule>();
target.CreationRules.Should().BeEmpty();
}
public void AddWithValueGeneratorAddsRuleToCompilerTest()
{
var rule = new StringValueGenerator();
var target = new BuildStrategyCompiler();
target.Add(rule);
target.ValueGenerators.Should().Contain(rule);
}
public void AddIgnoreRuleWithExpressionAddsRuleToCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddIgnoreRule<Person>(x => x.FirstName);
var rule = target.IgnoreRules.Single();
rule.TargetType.Should().Be<Person>();
rule.PropertyName.Should().Be(nameof(Person.FirstName));
}
public void SetConstructorResolverAssignsResolverToCompilerTest()
{
var target = new BuildStrategyCompiler();
target.SetConstructorResolver<DefaultConstructorResolver>();
var actual = target.ConstructorResolver;
actual.Should().BeOfType<DefaultConstructorResolver>();
}
public void RemoveValueGeneratorRemovesRulesFromCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddValueGenerator<StringValueGenerator>();
target.RemoveValueGenerator<StringValueGenerator>();
target.ValueGenerators.Should().BeEmpty();
}
public void SetConstructorResolverWithResolverAssignsResolverToCompilerTest()
{
var resolver = new DefaultConstructorResolver();
var target = new BuildStrategyCompiler();
target.SetConstructorResolver(resolver);
target.ConstructorResolver.Should().Be(resolver);
}
public void AddWithExecuteOrderRuleAddsRuleToCompilerTest()
{
var rule = new ExecuteOrderRule(typeof(Person), "FirstName", Environment.TickCount);
var target = new BuildStrategyCompiler();
target.Add(rule);
target.ExecuteOrderRules.Should().Contain(rule);
}
public void AddWithCreationRuleAddsRuleToCompilerTest()
{
var rule = new CreationRule(typeof(Person), "FirstName", Environment.TickCount, (object) null);
var target = new BuildStrategyCompiler();
target.Add(rule);
target.CreationRules.Should().Contain(rule);
}
public void AddValueGeneratorAddsRuleToCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddValueGenerator<StringValueGenerator>();
var actual = target.ValueGenerators.Single();
actual.Should().BeOfType<StringValueGenerator>();
}
public void AddTypeCreatorAddsRuleToCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddTypeCreator<DefaultTypeCreator>();
var actual = target.TypeCreators.Single();
actual.Should().BeOfType<DefaultTypeCreator>();
}
public void AddPostBuildActionAddsRuleToCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddPostBuildAction<DummyPostBuildAction>();
var actual = target.PostBuildActions.Single();
actual.Should().BeOfType<DummyPostBuildAction>();
}
public void AddIgnoreRuleWithExpressionThrowsExceptionWithNullExpressionTest()
{
var target = new BuildStrategyCompiler();
Action action = () => target.AddIgnoreRule((Expression<Func<Person, object>>) null);
action.ShouldThrow<ArgumentNullException>();
}
public void RemovePostBuildActionRemovesRulesFromCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddPostBuildAction<DummyPostBuildAction>();
target.RemovePostBuildAction<DummyPostBuildAction>();
target.PostBuildActions.Should().BeEmpty();
}
public void RemoveTypeCreatorRemovesRulesFromCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddTypeCreator<DefaultTypeCreator>();
target.RemoveTypeCreator<DefaultTypeCreator>();
target.TypeCreators.Should().BeEmpty();
}
public void AddExecuteOrderRuleWithExpressionAddsRuleToCompilerTest()
{
var priority = Environment.TickCount;
var target = new BuildStrategyCompiler();
target.AddExecuteOrderRule<Person>(x => x.FirstName, priority);
var rule = target.ExecuteOrderRules.Single();
rule.Priority.Should().Be(priority);
var actual = rule.IsMatch(typeof(Person), nameof(Person.FirstName));
actual.Should().BeTrue();
}
public void ScanModulesPopulatesCompilerWithDetectedConfigurationTest()
{
var target = new BuildStrategyCompiler();
target.ScanModules();
target.ExecuteOrderRules.Should().ContainItemsAssignableTo<DummyExecuteOrderRule>();
target.IgnoreRules.Should().ContainItemsAssignableTo<DummyIgnoreRule>();
target.PostBuildActions.Should().ContainItemsAssignableTo<DummyPostBuildAction>();
target.CreationRules.Should().ContainItemsAssignableTo<DummyCreationRule>();
target.TypeCreators.Should().ContainItemsAssignableTo<DummyTypeCreator>();
target.ValueGenerators.Should().ContainItemsAssignableTo<DummyValueGenerator>();
}
public void AddWithTypeCreatorAddsRuleToCompilerTest()
{
var rule = new DefaultTypeCreator();
var target = new BuildStrategyCompiler();
target.Add(rule);
target.TypeCreators.Should().Contain(rule);
}
public void AddWithIgnoreRuleAddsRuleToCompilerTest()
{
var rule = new IgnoreRule(typeof(Person), "FirstName");
var target = new BuildStrategyCompiler();
target.Add(rule);
target.IgnoreRules.Should().Contain(rule);
}
public void AddExecuteOrderRuleWithExpressionThrowsExceptionWithNullExpressionTest()
{
var priority = Environment.TickCount;
var target = new BuildStrategyCompiler();
Action action = () => target.AddExecuteOrderRule((Expression<Func<Person, object>>) null, priority);
action.ShouldThrow<ArgumentNullException>();
}
public void AddExecuteOrderRuleAddsRuleToCompilerTest()
{
var target = new BuildStrategyCompiler();
target.AddExecuteOrderRule<DummyExecuteOrderRule>();
var actual = target.ExecuteOrderRules.Single();
actual.Should().BeOfType<DummyExecuteOrderRule>();
}
public void AddWithPostBuildActionAddsRuleToCompilerTest()
{
var postBuildAction = new DummyPostBuildAction();
var target = new BuildStrategyCompiler();
target.Add(postBuildAction);
target.PostBuildActions.Should().Contain(postBuildAction);
}
