public void ConditionalWithConstantRuleUsingFactory(string valueToCheck, string expectedOutput)
{
var trueRule =
ConstantRulesFactory.CreateConstantRule <string, string>("element is present in the collection");
var falseRule =
ConstantRulesFactory.CreateConstantRule <string, string>("element is not present in the collection");
var searchList = new List <string> {
"one", "two", "three", "four", "five", "six"
};
var containsRule =
ContainsValueRuleFactory.CreateContainsValueRule(searchList, "System.StringComparer",
"OrdinalIgnoreCase");
var containsTextRule =
ConditionalRulesFactory.CreateConditionalFuncRule <string, string>(containsRule, trueRule, falseRule);
var compileResult = containsTextRule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(containsTextRule)}:{Environment.NewLine}" +
$"{containsTextRule.ExpressionDebugView()}");
var ruleResult = containsTextRule.Execute(valueToCheck);
_testOutputHelper.WriteLine($"expected: {expectedOutput} - actual: {ruleResult}");
ruleResult.Should().BeEquivalentTo(expectedOutput);
}
public void CallAStringMethodOnDescriptionObjectUsingFactory()
{
// Description is a string - Call Contains method on Description
// compiles to: Param_0.Description.Contains("cool")
var const1 = ConstantRulesFactory.CreateConstantRule <string>("cool");
var gameNameContainsKeyWordCool = MethodCallRulesFactory.CreateMethodCallRule <Game, bool>("Contains",
null, (g => g.Description), new List <Rule> {
const1
});
var compileResult = gameNameContainsKeyWordCool.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(gameNameContainsKeyWordCool)}:{Environment.NewLine}" +
$"{gameNameContainsKeyWordCool.ExpressionDebugView()}");
// check to see if _game1 description contains keyword "cool"
var executeResult = gameNameContainsKeyWordCool.Execute(_game1);
executeResult.Should().BeFalse();
// check to see if _game2 description contains keyword "cool"
executeResult = gameNameContainsKeyWordCool.Execute(_game2);
executeResult.Should().BeTrue();
}
public void UpdateStringRefUsingFactory()
{
var sourceDataRule = ConstantRulesFactory.CreateConstantRule <string>("something");
var rule = UpdateValueRulesFactory.CreateUpdateRefValueRule <string>(sourceDataRule);
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"UpdateRefValueRule<string>:{Environment.NewLine}" +
$"{rule.ExpressionDebugView()}");
var string1 = "one";
rule.RefUpdate(ref string1);
string1.Should().Be("something");
// source value shall come as argument
var rule2 = UpdateValueRulesFactory.CreateUpdateRefValueRule <string>();
compileResult = rule2.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"UpdateRefValueRule<string, string>:{Environment.NewLine}" +
$"{rule2.ExpressionDebugView()}");
string1 = null;
rule2.RefUpdate(ref string1, "some other value");
string1.Should().Be("some other value");
}
public void UpdateIntRefUsingFactory()
{
var sourceDataRule = ConstantRulesFactory.CreateConstantRule <int>("99");
var rule = UpdateValueRulesFactory.CreateUpdateRefValueRule <int>(sourceDataRule);
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{rule.ExpressionDebugView()}");
var myInt = 0;
rule.RefUpdate(ref myInt);
myInt.Should().Be(99);
var rule2 = UpdateValueRulesFactory.CreateUpdateRefValueRule <int>();
compileResult = rule2.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"UpdateRefValueRule<int, int>:{Environment.NewLine}" +
$"{rule2.ExpressionDebugView()}");
rule2.RefUpdate(ref myInt, -99);
myInt.Should().Be(-99);
}
public void CallCreateGameStaticMethod3UsingFactory()
{
//var game = Game.CreateGame("game", "description", 1, true);
var methodParams = new List <Rule>
{
ConstantRulesFactory.CreateConstantRule <string>("game"),
ConstantRulesFactory.CreateConstantRule <string>("description"),
ConstantRulesFactory.CreateConstantRule <int>("1"),
ConstantRulesFactory.CreateConstantRule <bool>("true")
};
var rule = MethodCallRulesFactory.CreateStaticMethodCallRule <Game>("CreateGame",
"ModelForUnitTests.Game", methodParams);
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"rule: {Environment.NewLine}" +
$"{rule.ExpressionDebugView()}");
var game = rule.Execute();
game.Should().NotBeNull();
game.Name.Should().Be("game");
_testOutputHelper.WriteLine($"{game}");
}
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 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 ConditionalRuleToUpdateNameUsingFactory()
{
var trueRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>(g => g.Name,
ConstantRulesFactory.CreateConstantRule <string>("updated name"));
var methodParams = new List <Rule>
{
ConstantRulesFactory.CreateConstantRule <string>("some name"),
ConstantRulesFactory.CreateConstantRule <StringComparison>("CurrentCultureIgnoreCase")
};
var methodCallRule = MethodCallRulesFactory.CreateMethodCallRule <Game, bool>("Equals", null,
g => g.Name, methodParams);
var conditionalUpdateValue =
ConditionalRulesFactory.CreateConditionalIfThActionRule <Game>(methodCallRule, trueRule);
var compileResult = conditionalUpdateValue.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(conditionalUpdateValue)}:{Environment.NewLine}" +
$"{conditionalUpdateValue.ExpressionDebugView()}");
var game = new Game {
Name = "some name"
};
_testOutputHelper.WriteLine($"before game.Name: {game.Name}");
conditionalUpdateValue.Execute(game);
_testOutputHelper.WriteLine($"after game.Name: {game.Name}");
game.Name.Should().Be("updated name");
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var rule = ConstantRulesFactory.CreateConstantRule <string>("value");
var compile = rule.Compile();
var result = rule.Get();
//var foo = GetSomeNullValue();
}
public void CreateConstantRuleTest5UsingFactory()
{
var rule = ConstantRulesFactory.CreateConstantRule <int, bool?>("false");
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(rule)}:{Environment.NewLine}" +
$"{rule.ExpressionDebugView()}");
var value = rule.Get(int.MinValue);
value.Should().Be(false);
}
public void CreateConstantRuleTest2UsingFactory()
{
var rule = ConstantRulesFactory.CreateConstantRule <double>("99.1");
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(rule)}:{Environment.NewLine}" +
$"{rule.ExpressionDebugView()}");
var value = rule.Get();
_testOutputHelper.WriteLine($"expected: 99.1 - actual: {value}");
value.Should().Be(99.1);
}
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 CreateConstantRuleTest3UsingFactory()
{
var stringValue = "55";
var rule = ConstantRulesFactory.CreateConstantRule <int, string>(stringValue);
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(rule)}:{Environment.NewLine}" +
$"{rule.ExpressionDebugView()}");
var value = rule.Get(int.MinValue);
_testOutputHelper.WriteLine($"expected: {stringValue} - actual: {value}");
value.Should().BeOfType <string>().And.Be(stringValue);
}
public void UpdatePropertyFromAnotherRuleUsingFactory()
{
var game = new Game {
Name = "game name"
};
var const1 = ConstantRulesFactory.CreateConstantRule <string>("name from constant rule");
var nameChangeRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>((g => g.Name), const1);
var compileResult = nameChangeRule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(nameChangeRule)}:{Environment.NewLine}" +
$"{nameChangeRule.ExpressionDebugView()}");
_testOutputHelper.WriteLine($"before game.Name: {game.Name}");
nameChangeRule.UpdateFieldOrPropertyValue(game);
game.Name.Should().Be("name from constant rule");
_testOutputHelper.WriteLine($"after game.Name: {game.Name}");
}
public void CheckToSeeIfPlayerExistsInAGameUsingFactory(int id, bool expectedResult)
{
// call HasPlayer method on the game object
// compiles to: Param_0.HasPlayer(1000)
var const1 = ConstantRulesFactory.CreateConstantRule <int>(id.ToString());
var gameHasPlayerWithCertainId =
MethodCallRulesFactory.CreateMethodCallRule <Game, bool>("HasPlayer", null, null,
new List <Rule> {
const1
});
var compileResult = gameHasPlayerWithCertainId.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(gameHasPlayerWithCertainId)}:{Environment.NewLine}" +
$"{gameHasPlayerWithCertainId.ExpressionDebugView()}");
var executeResult = gameHasPlayerWithCertainId.Execute(_game1);
executeResult.Should().Be(expectedResult);
}
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 CallEqualsMethodOnNameUsingConstantRuleUsingFactory(string param1, bool expectedResult)
{
// call Equals method on Name string object
// compiles to: Param_0.Name.Equals("Game 1", CurrentCultureIgnoreCase)
var param1Const = ConstantRulesFactory.CreateConstantRule <string>(param1);
var param2Const = ConstantRulesFactory.CreateConstantRule <StringComparison>("CurrentCultureIgnoreCase");
var nameEqualsRule = MethodCallRulesFactory.CreateMethodCallRule <Game, bool>("Equals", null, (g => g.Name),
new List <Rule> {
param1Const, param2Const
});
var compileResult = nameEqualsRule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(nameEqualsRule)}:{Environment.NewLine}" +
$"{nameEqualsRule.ExpressionDebugView()}");
var executeResult = nameEqualsRule.Execute(_game1);
executeResult.Should().Be(expectedResult);
executeResult = nameEqualsRule.Execute(_game2);
executeResult.Should().Be(!expectedResult);
}
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);
}
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();
}
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);
}
}
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);
}
