public void ReturnsNewOrUpdatedGameUsingFactory()
{
var nullGame = ConstantRulesFactory.CreateConstantRule <Game>("null");
var nullGameCheckRule =
ValidationRulesFactory.CreateValidationRule <Game>(LogicalOperatorAtTheRootLevel.Equal, nullGame);
var newGameRule = MethodCallRulesFactory.CreateStaticMethodCallRule <Game>("CreateGame", "ModelForUnitTests.Game", null);
var selfReturnRule = SelfReturnRuleFactory.CreateSelfReturnRule <Game>();
var gameObjectRule = ConditionalRulesFactory.CreateConditionalFuncRule <Game, Game>(nullGameCheckRule, newGameRule,
selfReturnRule);
var assignRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>(gameObjectRule);
var nameConstRule = ConstantRulesFactory.CreateConstantRule <string>("some fancy name");
var nameChangeRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>(g => g.Name, nameConstRule);
var rankConstRule = ConstantRulesFactory.CreateConstantRule <int>("1000");
var rankingChangeRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>(g => g.Ranking, rankConstRule);
var descConstRule = ConstantRulesFactory.CreateConstantRule <string>("some cool description");
var descriptionChangeRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>(g => g.Description, descConstRule);
IList <Rule> rules = new List <Rule>
{
assignRule,
nameChangeRule,
rankingChangeRule,
descriptionChangeRule,
selfReturnRule
};
var blockRule = BlockRulesFactory.CreateFuncBlockRule <Game, Game>(rules);
var compileResult = blockRule.Compile();
compileResult.Should().BeTrue();
var game = blockRule.Execute(null);
game.Name.Should().Be("some fancy name");
game.Ranking.Should().Be(1000);
game.Description.Should().Be("some cool description");
game.Rating.Should().BeNullOrEmpty();
_testOutputHelper.WriteLine($"{game}");
var newGame = new Game {
Rating = "high"
};
// newGame is not same as game object
ReferenceEquals(game, newGame).Should().BeFalse();
game = blockRule.Execute(newGame);
// this call shall return the same newGame object with updated values
ReferenceEquals(game, newGame).Should().BeTrue();
game.Rating.Should().Be("high");
_testOutputHelper.WriteLine($"newGame: {game}");
}
public void IntSelfReturnUsingFactory(int someValue)
{
var rule = SelfReturnRuleFactory.CreateSelfReturnRule <int>();
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"selfReturnRule for Int:{Environment.NewLine}" +
$"{rule.ExpressionDebugView()}");
var value = rule.Get(someValue);
value.Should().Be(someValue);
}
public void CreateASelfReturnNullableIntRuleUsingFactory()
{
var rule = SelfReturnRuleFactory.CreateSelfReturnRule <int?>();
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"rule: {rule}");
var result = rule.Get(5);
result.Should().Be(5);
result = rule.Get(null);
result.Should().BeNull();
}
public void StringSelfReturnUsingFactory(string someValue)
{
var rule = SelfReturnRuleFactory.CreateSelfReturnRule <string>();
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"selfReturnRule for String:{Environment.NewLine}" +
$"{rule.ExpressionDebugView()}");
var value = rule.Get(someValue);
value.Should().Be(someValue);
var referenceEquals = ReferenceEquals(someValue, value);
referenceEquals.Should().BeTrue();
}
public void CreateASelfReturnStringRuleUsingFactory()
{
var rule = SelfReturnRuleFactory.CreateSelfReturnRule <string>();
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"rule: {rule}");
var result = rule.Get("one");
result.Should().Be("one");
result = rule.Get(null);
result.Should().BeNull();
result = rule.Get("two");
result.Should().Be("two");
}
public void IfValueContainsReturnDiffValue2UsingFactory(string searchValue, string expectedValue)
{
var collectionToSearch = new List <string> {
"one", "two", "three", "four", "five", "six"
};
var containsValueRule = ContainsValueRuleFactory.CreateContainsValueRule(collectionToSearch,
"System.StringComparer", "OrdinalIgnoreCase");
var trueRule = ConstantRulesFactory.CreateConstantRule <string, string>("six-six-six");
var falseRule = SelfReturnRuleFactory.CreateSelfReturnRule <string>();
var valueReplacementIfBad = ConditionalRulesFactory.CreateConditionalFuncRule <string, string>(containsValueRule,
trueRule, falseRule);
var compileResult = valueReplacementIfBad.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(valueReplacementIfBad)}:{Environment.NewLine}" +
$"{valueReplacementIfBad.ExpressionDebugView()}");
var ruleResult = valueReplacementIfBad.Execute(searchValue);
_testOutputHelper.WriteLine($"expected: {expectedValue} - actual: {ruleResult}");
ruleResult.Should().Be(expectedValue);
}
