public void RuleToCheckIfAnIntegerMatchesRuleValueOrNotUsingFactory()
{
var constRule = ConstantRulesFactory.CreateConstantRule <int>("5");
var numberShouldBe5Rule =
ValidationRulesFactory.CreateValidationRule <int>(
LogicalOperatorAtTheRootLevel.Equal, constRule);
var compileResult = numberShouldBe5Rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(numberShouldBe5Rule)}:{Environment.NewLine}{numberShouldBe5Rule.ExpressionDebugView()}");
var numberShouldNotBe5Rule =
ValidationRulesFactory.CreateValidationRule <int>(
LogicalOperatorAtTheRootLevel.NotEqual, constRule);
compileResult = numberShouldNotBe5Rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(numberShouldNotBe5Rule)}:{Environment.NewLine}" +
$"{numberShouldNotBe5Rule.ExpressionDebugView()}");
var ruleExecuteResult = numberShouldBe5Rule.IsValid(5);
ruleExecuteResult.Should().BeTrue();
_testOutputHelper.WriteLine($"with 5 {nameof(numberShouldBe5Rule)} execute result: {ruleExecuteResult}");
ruleExecuteResult = numberShouldBe5Rule.IsValid(6);
ruleExecuteResult.Should().BeFalse();
ruleExecuteResult = numberShouldNotBe5Rule.IsValid(6);
ruleExecuteResult.Should().BeTrue();
_testOutputHelper.WriteLine($"with 6 {nameof(numberShouldNotBe5Rule)} execute result: {ruleExecuteResult}");
ruleExecuteResult = numberShouldNotBe5Rule.IsValid(5);
ruleExecuteResult.Should().BeFalse();
}
public void ConditionalRuleLookAtOneValueUpdateAnotherUsingFactory()
{
var const1 = ConstantRulesFactory.CreateConstantRule <int>("999");
var trueRule = UpdateValueRulesFactory.CreateUpdateValueRule <Player>(p => p.CurrentCoOrdinates.X, const1);
var const2 = ConstantRulesFactory.CreateConstantRule <string>("ab");
var validationRule = ValidationRulesFactory.CreateValidationRule <Player>(p => p.Country.CountryCode,
LogicalOperatorAtTheRootLevel.Equal, const2);
var conditionalUpdate =
ConditionalRulesFactory.CreateConditionalIfThActionRule <Player>(validationRule, trueRule);
var compileResult = conditionalUpdate.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(conditionalUpdate)}:{Environment.NewLine}" +
$"{conditionalUpdate.ExpressionDebugView()}");
var player = new Player
{
Country = new Country {
CountryCode = "ab"
},
CurrentCoOrdinates = new CoOrdinate {
X = 1, Y = 1
}
};
conditionalUpdate.Execute(player);
player.CurrentCoOrdinates.X.Should().Be(999);
_testOutputHelper.WriteLine($"expected: 999 - actual: {player.CurrentCoOrdinates.X}");
}
public static IList <IValidationRule <T> > EmailAddressRequestValidator <T>(this IList <IValidationRule <T> > rules, bool isRequired = true)
where T : IRequest, IHaveEmail
{
var validations = ValidationRulesFactory.GetEmailList <T>(isRequired);
var rulesList = rules as List <IValidationRule <T> >;
rulesList?.AddRange(validations);
return(rulesList);
}
public static IList <IValidationRule <T> > PhoneNumberValidators <T>(this IList <IValidationRule <T> > rules, bool isPhoneNumberRequired = true, bool isPhoneExtensionRequired = false)
where T : IRequest, IHavePhone
{
var validations = ValidationRulesFactory.GetPhoneList <T>(isPhoneNumberRequired, isPhoneExtensionRequired);
var rulesList = rules as List <IValidationRule <T> >;
rulesList?.AddRange(validations);
return(rulesList);
}
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 ValidationRuleWithOrElseChildrenValidationRulesUsingFactory()
{
var nullGame = ConstantRulesFactory.CreateConstantRule <Game>("null");
var child1 =
ValidationRulesFactory.CreateValidationRule <Game>(LogicalOperatorAtTheRootLevel.Equal, nullGame);
var nullString = ConstantRulesFactory.CreateConstantRule <string>("null");
var grandChild1 =
ValidationRulesFactory.CreateValidationRule <Game>(g => g.Name, LogicalOperatorAtTheRootLevel.NotEqual,
nullString);
var int3Const = ConstantRulesFactory.CreateConstantRule <int>("3");
var grandChild2 = ValidationRulesFactory.CreateValidationRule <Game>(g => g.Name.Length,
LogicalOperatorAtTheRootLevel.GreaterThan, int3Const);
var child2 = ValidationRulesFactory.CreateValidationRule <Game>(ChildrenBindingOperator.AndAlso,
new List <Rule> {
grandChild1, grandChild2
});
var gameIsNullOrNameIsGreaterThan3CharsRule =
ValidationRulesFactory.CreateValidationRule <Game>(ChildrenBindingOperator.OrElse,
new List <Rule> {
child1, child2
});
var compileResult = gameIsNullOrNameIsGreaterThan3CharsRule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(gameIsNullOrNameIsGreaterThan3CharsRule)}:{Environment.NewLine}" +
$"{gameIsNullOrNameIsGreaterThan3CharsRule.ExpressionDebugView()}");
var validationResult = gameIsNullOrNameIsGreaterThan3CharsRule.IsValid(_game);
validationResult.Should().BeTrue();
validationResult = gameIsNullOrNameIsGreaterThan3CharsRule.IsValid(null);
validationResult.Should().BeTrue();
validationResult = gameIsNullOrNameIsGreaterThan3CharsRule.IsValid(new Game {
Name = null
});
validationResult.Should().BeFalse();
validationResult = gameIsNullOrNameIsGreaterThan3CharsRule.IsValid(new Game {
Name = "a"
});
validationResult.Should().BeFalse();
}
public void ValidationRuleWithTwoTypesUsingFactory()
{
var twoPlayersScoreRule = ValidationRulesFactory.CreateValidationRule <Player, Player>(
LogicalOperatorAtTheRootLevel.GreaterThan,
(p => p.CurrentScore), (p => p.CurrentScore));
var compileResult = twoPlayersScoreRule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(twoPlayersScoreRule)}:{Environment.NewLine}{twoPlayersScoreRule.ExpressionDebugView()}");
var validationResult = twoPlayersScoreRule.IsValid(_game.Players[0], _game.Players[1]);
validationResult.Should().BeTrue();
validationResult = twoPlayersScoreRule.IsValid(_game.Players[1], _game.Players[0]);
validationResult.Should().BeFalse();
}
public void ApplyRuleToSubFieldOrPropertyUsingFactory()
{
var constRule = ConstantRulesFactory.CreateConstantRule <int>("3");
var nameLengthGreaterThan3Rule = ValidationRulesFactory.CreateValidationRule <Game>((g => g.Name.Length),
LogicalOperatorAtTheRootLevel.GreaterThan, constRule);
var compileResult = nameLengthGreaterThan3Rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(nameLengthGreaterThan3Rule)}:{Environment.NewLine}" +
$"{nameLengthGreaterThan3Rule.ExpressionDebugView()}");
var validationResult = nameLengthGreaterThan3Rule.IsValid(_game);
validationResult.Should().BeTrue();
var someGameWithShortName = new Game {
Name = "foo"
};
validationResult = nameLengthGreaterThan3Rule.IsValid(someGameWithShortName);
validationResult.Should().BeFalse();
}
public void RuleToCheckIfRootObjectIsNullOrNotUsingFactory()
{
var constRule = ConstantRulesFactory.CreateConstantRule <Game>("null");
var checkForNotNullRule =
ValidationRulesFactory.CreateValidationRule <Game>(
LogicalOperatorAtTheRootLevel.NotEqual, constRule);
var compileResult = checkForNotNullRule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(checkForNotNullRule)}:{Environment.NewLine}{checkForNotNullRule.ExpressionDebugView()}");
var checkForNullRule =
ValidationRulesFactory.CreateValidationRule <Game>(
LogicalOperatorAtTheRootLevel.Equal, constRule);
compileResult = checkForNullRule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(checkForNullRule)}:{Environment.NewLine}{checkForNullRule.ExpressionDebugView()}");
var ruleExecuteResult = checkForNotNullRule.IsValid(_game);
ruleExecuteResult.Should().BeTrue();
_testOutputHelper.WriteLine($"with non-null parameter validationResult = {ruleExecuteResult}; expecting true");
ruleExecuteResult = checkForNotNullRule.IsValid(null);
ruleExecuteResult.Should().BeFalse();
_testOutputHelper.WriteLine($"with null parameter validationResult = {ruleExecuteResult}; expecting false");
ruleExecuteResult = checkForNullRule.IsValid(_game);
ruleExecuteResult.Should().BeFalse();
_testOutputHelper.WriteLine($"with non-null parameter validationResult = {ruleExecuteResult}; expecting false");
ruleExecuteResult = checkForNullRule.IsValid(null);
ruleExecuteResult.Should().BeTrue();
_testOutputHelper.WriteLine($"with null parameter validationResult = {ruleExecuteResult}; expecting true");
}
public void ValidationRuleWithOneNotChildUsingFactory()
{
var constRule = ConstantRulesFactory.CreateConstantRule <Game>("null");
var child1 =
ValidationRulesFactory.CreateValidationRule <Game>(LogicalOperatorAtTheRootLevel.NotEqual, constRule);
var gameNullRuleByUsingNotWithNotEqualToNullChild =
ValidationRulesFactory.CreateValidationRule <Game>(ChildrenBindingOperator.Not, new List <Rule> {
child1
});
var compileResult = gameNullRuleByUsingNotWithNotEqualToNullChild.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(gameNullRuleByUsingNotWithNotEqualToNullChild)}:{Environment.NewLine}" +
$"{gameNullRuleByUsingNotWithNotEqualToNullChild.ExpressionDebugView()}");
var validationResult = gameNullRuleByUsingNotWithNotEqualToNullChild.IsValid(_game);
validationResult.Should().BeFalse();
validationResult = gameNullRuleByUsingNotWithNotEqualToNullChild.IsValid(null);
validationResult.Should().BeTrue();
}
public void CreateValidationRuleTest1UsingFactory()
{
var constRule = ConstantRulesFactory.CreateConstantRule <int>(value: "100");
var rule = ValidationRulesFactory.CreateValidationRule <Game>((g => g.Ranking),
LogicalOperatorAtTheRootLevel.LessThan,
constRule);
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(rule)}:{Environment.NewLine}" +
$"{rule.ExpressionDebugView()}");
var game = new Game {
Ranking = 98
};
var result = rule.IsValid(game);
result.Should().BeTrue();
game.Ranking = 100;
result = rule.IsValid(game);
result.Should().BeFalse();
}
static void Main(string[] args)
{
Console.WriteLine("Sample4RuleCreateMadeEasy - simple tutorial - quick start how-to");
//var orderCustomerAndProductCannotBeNullRule = new ValidationRule<Order>
//{
// OperatorToUse = "AndAlso",
// RuleError = new RuleError { Code = "c2", Message = "Customer and/or Product can't be null"},
// ChildrenRules =
// {
// new ValidationRule<Order>
// {
// OperatorToUse = "NotEqual",
// ObjectToValidate = "Customer",
// ValueToValidateAgainst = new ConstantRule<Customer>{Value = "null"}
// },
// new ValidationRule<Order>
// {
// OperatorToUse = "NotEqual",
// ObjectToValidate = "Product",
// ValueToValidateAgainst = new ConstantRule<Product>{Value = "null"}}
// }
//};
var nullCustomer = ConstantRulesFactory.CreateConstantRule <Customer>("null");
var nullProduct = ConstantRulesFactory.CreateConstantRule <Product>("null");
var child1Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer,
LogicalOperatorAtTheRootLevel.NotEqual, nullCustomer);
var child2Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Product,
LogicalOperatorAtTheRootLevel.NotEqual, nullProduct);
var orderCustomerAndProductCannotBeNullRule =
ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.AndAlso,
new List <Rule> {
child1Rule, child2Rule
});
orderCustomerAndProductCannotBeNullRule.RuleError = new RuleError
{
Code = "c2", Message = "Customer and/or Product can't be null"
};
var compiledResult = orderCustomerAndProductCannotBeNullRule.Compile();
Debug.WriteLine($"compiledResult: {compiledResult}"); // true
var order = new Order();
var isValidOrder = orderCustomerAndProductCannotBeNullRule.IsValid(order);
if (!isValidOrder)
{
Debug.WriteLine($"orderCustomerAndProductCannotBeNullRule not valid: " +
$"{orderCustomerAndProductCannotBeNullRule.RuleError}");
}
// add a customer object
order.Customer = new Customer();
isValidOrder = orderCustomerAndProductCannotBeNullRule.IsValid(order);
if (!isValidOrder)
{
Debug.WriteLine($"orderCustomerAndProductCannotBeNullRule not valid: " +
$"{orderCustomerAndProductCannotBeNullRule.RuleError}");
}
// add a product object
order.Product = new Product();
isValidOrder = orderCustomerAndProductCannotBeNullRule.IsValid(order);
if (!isValidOrder)
{
Debug.WriteLine($"orderCustomerAndProductCannotBeNullRule not valid: " +
$"{orderCustomerAndProductCannotBeNullRule.RuleError}");
}
var converter = new JsonConverterForRule();
var jsonDoc = JsonConvert.SerializeObject(orderCustomerAndProductCannotBeNullRule, Formatting.Indented, converter);
Debug.WriteLine($"orderCustomerAndProductCannotBeNullRule converted to Json:{Environment.NewLine}{jsonDoc}");
// this shall throw a null exception
//orderCustomerAndProductCannotBeNullRule.IsValid(null);
}
private static void LoadAndCompileRules()
{
var nullOrder = ConstantRulesFactory.CreateConstantRule <Order>("null");
var orderRule =
ValidationRulesFactory.CreateValidationRule <Order>(LogicalOperatorAtTheRootLevel.NotEqual, nullOrder);
orderRule.RuleError = new RuleError {
Code = "c1", Message = "order can't be null"
};
if (orderRule.Compile())
{
OrderRules.Add(orderRule);
}
var nullCustomer = ConstantRulesFactory.CreateConstantRule <Customer>("null");
var nullProduct = ConstantRulesFactory.CreateConstantRule <Product>("null");
var child1Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer,
LogicalOperatorAtTheRootLevel.NotEqual, nullCustomer);
var child2Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Product,
LogicalOperatorAtTheRootLevel.NotEqual, nullProduct);
var orderCustomerAndProductCannotBeNullRule =
ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.AndAlso,
new List <Rule> {
child1Rule, child2Rule
});
orderCustomerAndProductCannotBeNullRule.RuleError =
new RuleError {
Code = "c2", Message = "Customer and/or Product can't be null"
};
if (orderCustomerAndProductCannotBeNullRule.Compile())
{
OrderRules.Add(orderCustomerAndProductCannotBeNullRule);
}
var nullStrRule = ConstantRulesFactory.CreateConstantRule <string>("null");
var child3Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer.FirstName,
LogicalOperatorAtTheRootLevel.NotEqual, nullStrRule);
var len2Rule = ConstantRulesFactory.CreateConstantRule <int>("2");
var child4Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer.FirstName.Length,
LogicalOperatorAtTheRootLevel.GreaterThan, len2Rule);
var orderCustomerFirstNameRule =
ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.AndAlso,
new List <Rule> {
child3Rule, child4Rule
});
orderCustomerFirstNameRule.RuleError = new RuleError
{
Code = "c3",
Message = "first name can't be null/empty and has to be 3+ chars long"
};
if (orderCustomerFirstNameRule.Compile())
{
OrderRules.Add(orderCustomerFirstNameRule);
}
var child5Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer.LastName,
LogicalOperatorAtTheRootLevel.NotEqual, nullStrRule);
var len3Rule = ConstantRulesFactory.CreateConstantRule <int>("3");
var child6Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer.LastName.Length,
LogicalOperatorAtTheRootLevel.GreaterThan, len3Rule);
var orderCustomerLastNameRule =
ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.AndAlso,
new List <Rule> {
child5Rule, child6Rule
});
orderCustomerLastNameRule.RuleError = new RuleError
{
Code = "c4",
Message = "last name can't be null/empty and has to be 4+ chars long"
};
if (orderCustomerLastNameRule.Compile())
{
OrderRules.Add(orderCustomerLastNameRule);
}
var zeroRule = ConstantRulesFactory.CreateConstantRule <int>("0");
var child7Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Product.Id,
LogicalOperatorAtTheRootLevel.GreaterThan, zeroRule);
var child81Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Product.Name,
LogicalOperatorAtTheRootLevel.NotEqual, nullStrRule);
var len4Rule = ConstantRulesFactory.CreateConstantRule <int>("4");
var child82Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Product.Name.Length,
LogicalOperatorAtTheRootLevel.GreaterThan, len4Rule);
var child8Rule = ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.AndAlso,
new List <Rule> {
child81Rule, child82Rule
});
var orderProductIdPositiveOrNameGreaterThan5 =
ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.OrElse, new List <Rule> {
child7Rule, child8Rule
});
orderProductIdPositiveOrNameGreaterThan5.RuleError = new RuleError
{
Code = "c5",
Message = "product id must be greater than zero or name has to be 5+ chars"
};
if (orderProductIdPositiveOrNameGreaterThan5.Compile())
{
OrderRules.Add(orderProductIdPositiveOrNameGreaterThan5);
}
}
