public void UpdateStringRef2ToAndFromJson()
{
// source value shall come as argument
var ruleBefore = new UpdateRefValueRule <string>();
var ruleJsonConverter = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(ruleBefore, ruleJsonConverter);
_testOutputHelper.WriteLine($"ruleJson:{Environment.NewLine}{ruleJson}");
// read from json
var ruleAfter = JsonConvert.DeserializeObject <Rule>(ruleJson, ruleJsonConverter);
var compileResult = ruleAfter.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"UpdateRefValueRule<string, string>:{Environment.NewLine}" +
$"{ruleAfter.ExpressionDebugView()}");
string string1 = null;
((UpdateRefValueRule <string>)ruleAfter).RefUpdate(ref string1, "some other value");
string1.Should().Be("some other value");
}
public void CreateComparerOnTheFlyUsingReflectionToAndFromJson()
{
var containsRule = new ContainsValueRule <string>
{
EqualityComparerClassName = "System.StringComparer",
EqualityComparerPropertyName = "OrdinalIgnoreCase",
CollectionToSearch = { "one", "two", "three", "four", "five", "six" }
};
var converter = new JsonConverterForRule();
// convert to json
var json = JsonConvert.SerializeObject(containsRule, Formatting.Indented, converter);
_testOutputHelper.WriteLine($"rule in json:{Environment.NewLine}{json}");
// bring back from json
var ruleFromJson = JsonConvert.DeserializeObject <ContainsValueRule <string> >(json, converter);
var compileResult = ruleFromJson.Compile();
compileResult.Should().BeTrue();
var a1 = ruleFromJson.ContainsValue("One");
a1.Should().BeTrue();
var a2 = ruleFromJson.ContainsValue("tWo");
a2.Should().BeTrue();
var a7 = ruleFromJson.ContainsValue("seven");
a7.Should().BeFalse();
}
public void UpdateStringRefToAndFromJson()
{
// source value is fixed with a constant rule
var ruleBefore = new UpdateRefValueRule <string>
{
SourceDataRule = new ConstantRule <string> {
Value = "something"
}
};
var ruleJsonConverter = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(ruleBefore, ruleJsonConverter);
_testOutputHelper.WriteLine($"ruleJson:{Environment.NewLine}{ruleJson}");
// read from json
var ruleAfter = JsonConvert.DeserializeObject <Rule>(ruleJson, ruleJsonConverter);
var compileResult = ruleAfter.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"UpdateRefValueRule<string>:{Environment.NewLine}" +
$"{ruleAfter.ExpressionDebugView()}");
var string1 = "one";
((UpdateRefValueRule <string>)ruleAfter).RefUpdate(ref string1);
string1.Should().Be("something");
}
private static bool LoadFromFile()
{
if (!File.Exists(_ruleFileName))
{
return(false);
}
var jsonConverter = new JsonConverterForRule();
using (var stream = File.OpenText(_ruleFileName))
{
var line = stream.ReadLine();
while (!string.IsNullOrEmpty(line))
{
var jsonRule = JsonConvert.DeserializeObject <Rule>(line, jsonConverter);
if (jsonRule.Compile())
{
OrderRules.Add(jsonRule);
}
line = stream.ReadLine();
}
}
return(true);
}
public void GameSelfReturnToAndFromJson()
{
var ruleBefore = new SelfReturnRule <Game>();
var customJsonConverter = new JsonConverterForRule();
// serialize to json
var ruleJson = JsonConvert.SerializeObject(ruleBefore, customJsonConverter);
_testOutputHelper.WriteLine($"{nameof(ruleJson)}:{Environment.NewLine}{ruleJson}");
// de-hydrate from json
var ruleAfter = JsonConvert.DeserializeObject <SelfReturnRule <Game> >(ruleJson, customJsonConverter);
var compileResult = ruleAfter.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"selfReturnRule for Game:{Environment.NewLine}" +
$"{ruleAfter.ExpressionDebugView()}");
var someGame = new Game();
var value = ruleAfter.Get(someGame);
value.Should().Be(someGame);
// both objects should be pointing to same objects
var referenceEquals = ReferenceEquals(someGame, value);
referenceEquals.Should().BeTrue();
}
public void CallStaticVoidMethod2ToAndFromJson()
{
var ruleBefore = MethodCallRulesFactory.CreateStaticVoidMethodCallRule("SomeVoidStaticMethod", "ModelForUnitTests.Game",
new List <Rule> {
new ConstantRule <int> {
Value = "99"
}
});
var jsonConverterForRule = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(ruleBefore, jsonConverterForRule);
_testOutputHelper.WriteLine($"ruleJson:{Environment.NewLine}{ruleJson}");
// read from json
var ruleAfter = JsonConvert.DeserializeObject <Rule>(ruleJson, jsonConverterForRule);
var compileResult = ruleAfter.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"rule: {Environment.NewLine}" +
$"{ruleAfter.ExpressionDebugView()}");
Game.SomeStaticIntValue = 0;
(ruleAfter as StaticVoidMethodCallRule)?.Execute();
Game.SomeStaticIntValue.Should().Be(99);
}
public void CallCreateGameStaticMethod2ToAndFromJson()
{
//var game = Game.CreateGame("cool game");
var ruleBefore = new StaticMethodCallRule <Game>
{
MethodClassName = "ModelForUnitTests.Game",
MethodToCall = "CreateGame",
MethodParameters = { new ConstantRule <string> {
Value = "cool game"
} }
};
var jsonConverterForRule = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(ruleBefore, jsonConverterForRule);
_testOutputHelper.WriteLine($"ruleJson:{Environment.NewLine}{ruleJson}");
// read from json
var ruleAfter = JsonConvert.DeserializeObject <Rule>(ruleJson, jsonConverterForRule);
var compileResult = ruleAfter.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"rule: {Environment.NewLine}" +
$"{ruleAfter.ExpressionDebugView()}");
var game = ((StaticMethodCallRule <Game>)ruleAfter).Execute();
game.Should().NotBeNull();
game.Name.Should().Be("cool game");
}
public void UpdateIntRefToAndFromJson()
{
var rule = new UpdateRefValueRule <int>
{
SourceDataRule = new ConstantRule <int> {
Value = "99"
}
};
var compileResult = rule.Compile();
compileResult.Should().BeTrue();
var myInt = 0;
rule.RefUpdate(ref myInt);
myInt.Should().Be(99);
var jsonConverterForRule = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(rule, jsonConverterForRule);
_testOutputHelper.WriteLine($"ruleJson:{Environment.NewLine}{ruleJson}");
// new rule from Json
var newRule = JsonConvert.DeserializeObject <UpdateRefValueRule <int> >(ruleJson, jsonConverterForRule);
var compileResult2 = newRule.Compile();
compileResult2.Should().BeTrue();
var myInt2 = 0;
newRule.RefUpdate(ref myInt2);
myInt2.Should().Be(99);
var rule2 = new UpdateRefValueRule <int>();
compileResult = rule2.Compile();
compileResult.Should().BeTrue();
rule2.RefUpdate(ref myInt, -99);
myInt.Should().Be(-99);
// convert to json
var ruleJson2 = JsonConvert.SerializeObject(rule2, jsonConverterForRule);
_testOutputHelper.WriteLine($"ruleJson2:{Environment.NewLine}{ruleJson2}");
// new rule from json
var newRule2 = JsonConvert.DeserializeObject <UpdateRefValueRule <int> >(ruleJson2, jsonConverterForRule);
var compileResult3 = newRule2.Compile();
compileResult3.Should().BeTrue();
newRule2.RefUpdate(ref myInt2, -99);
myInt2.Should().Be(-99);
}
// save as new-line json format; just because I wanted to
private static void SaveRulesToFile()
{
var jsonConverter = new JsonConverterForRule();
using (var file = new StreamWriter(_ruleFileName))
foreach (var orderRule in OrderRules)
{
var json = JsonConvert.SerializeObject(orderRule, jsonConverter);
file.WriteLine(json);
}
}
public void ReturnsUpdatedGameToAndFromJson()
{
var nameChangeRule = new UpdateValueRule <Game>
{
ObjectToUpdate = "Name",
SourceDataRule = new ConstantRule <string> {
Value = "some fancy name"
}
};
var rankingChangeRule = new UpdateValueRule <Game>
{
ObjectToUpdate = "Ranking",
SourceDataRule = new ConstantRule <int> {
Value = "1000"
}
};
var descriptionChangeRule = new UpdateValueRule <Game>
{
ObjectToUpdate = "Description",
SourceDataRule = new ConstantRule <string> {
Value = "some cool description"
}
};
var selfReturnRule = new SelfReturnRule <Game>();
var blockRule = new FuncBlockRule <Game, Game>();
blockRule.Rules.Add(nameChangeRule);
blockRule.Rules.Add(rankingChangeRule);
blockRule.Rules.Add(descriptionChangeRule);
blockRule.Rules.Add(selfReturnRule);
var jsonConverterForRule = new JsonConverterForRule();
var json = JsonConvert.SerializeObject(blockRule, Formatting.Indented, jsonConverterForRule);
_testOutputHelper.WriteLine(json);
var blockRule2 = JsonConvert.DeserializeObject <FuncBlockRule <Game, Game> >(json, jsonConverterForRule);
var compileResult = blockRule2.Compile();
compileResult.Should().BeTrue();
var game = blockRule2.Execute(new Game());
game.Name.Should().Be("some fancy name");
game.Ranking.Should().Be(1000);
game.Description.Should().Be("some cool description");
_testOutputHelper.WriteLine($"{game}");
}
public void EmptyBlockRuleThrowsExceptionToAndFromJson()
{
var emptyBlockRule = new FuncBlockRule <object, object>();
var converter = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(emptyBlockRule, converter);
_testOutputHelper.WriteLine(ruleJson);
// re-hydrate from json
var ruleFromJson = JsonConvert.DeserializeObject <FuncBlockRule <object, object> >(ruleJson, converter);
var exception = Assert.Throws <RuleEngineException>(() => ruleFromJson.Compile());
exception.Message.Should().Be("last rule must return a value of System.Object");
}
public void IfValueContainsReturnDiffValue2ToAndFromJson(string searchValue, string expectedValue)
{
var valueReplacementIfBad = new ConditionalFuncRule <string, string>
{
ConditionRule = new ContainsValueRule <string>
{
EqualityComparerClassName = "System.StringComparer",
EqualityComparerPropertyName = "OrdinalIgnoreCase",
CollectionToSearch = { "one", "two", "three", "four", "five", "six" }
},
TrueRule = new ConstantRule <string, string> {
Value = "six-six-six"
},
FalseRule = new SelfReturnRule <string>()
};
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);
var converter = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(valueReplacementIfBad, converter);
_testOutputHelper.WriteLine(ruleJson);
// re-hydrate
var ruleFromJson = JsonConvert.DeserializeObject <ConditionalFuncRule <string, string> >(ruleJson, converter);
var compileResult2 = ruleFromJson.Compile();
compileResult2.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(ruleFromJson)}:{Environment.NewLine}" +
$"{ruleFromJson.ExpressionDebugView()}");
var ruleResult2 = ruleFromJson.Execute(searchValue);
_testOutputHelper.WriteLine($"expected: {expectedValue} - actual: {ruleResult2}");
ruleResult2.Should().Be(expectedValue);
}
public void ExceptionWhenLastRuleReturnsNoValueToAndFromJson()
{
var someRule = new ConditionalIfThActionRule <object>();
var someBlockRule = new FuncBlockRule <object, object>();
someBlockRule.Rules.Add(someRule);
var converter = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(someBlockRule, Formatting.Indented, converter);
_testOutputHelper.WriteLine(ruleJson);
// re-hydrate from json
var ruleFromJson = JsonConvert.DeserializeObject <FuncBlockRule <object, object> >(ruleJson, converter);
var exception = Assert.Throws <RuleEngineException>(() => ruleFromJson.Compile());
exception.Message.Should().Be("last rule must return a value of System.Object");
}
public void CallToUpperToAndFromJson()
{
var rule = new MethodCallRule <string, string> {
MethodToCall = "ToUpper"
};
var converter = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(rule, Formatting.Indented, converter);
_testOutputHelper.WriteLine($"ruleJson:{Environment.NewLine}{ruleJson}");
// re-hydrate from json
var ruleFromJson = JsonConvert.DeserializeObject <MethodCallRule <string, string> >(ruleJson, converter);
var compileResult = ruleFromJson.Compile();
compileResult.Should().BeTrue();
var foo = "foo";
var FOO = ruleFromJson.Execute(foo);
FOO.Should().Be("FOO");
}
public void IntSelfReturnToAndFromJson(int someValue)
{
var ruleBefore = new SelfReturnRule <int>();
var customJsonConverter = new JsonConverterForRule();
// serialize to json
var ruleJson = JsonConvert.SerializeObject(ruleBefore, customJsonConverter);
_testOutputHelper.WriteLine($"{nameof(ruleJson)}:{Environment.NewLine}{ruleJson}");
// de-hydrate from json
var ruleAfter = JsonConvert.DeserializeObject <SelfReturnRule <int> >(ruleJson, customJsonConverter);
var compileResult = ruleAfter.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"selfReturnRule2 for Int:{Environment.NewLine}" +
$"{ruleAfter.ExpressionDebugView()}");
var value = ruleAfter.Get(someValue);
value.Should().Be(someValue);
}
public void FuncBlockRuleReturnsLastRuleResultToAndFromJson()
{
var ruleReturning5 = new ConstantRule <int, int> {
Value = "5"
};
var blockRule = new FuncBlockRule <int, int>();
blockRule.Rules.Add(ruleReturning5);
var converter = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(blockRule, Formatting.Indented, converter);
_testOutputHelper.WriteLine(ruleJson);
// re-hydrate from json
var ruleFromJson = JsonConvert.DeserializeObject <FuncBlockRule <int, int> >(ruleJson, converter);
var compileResult2 = ruleFromJson.Compile();
compileResult2.Should().BeTrue();
var five = ruleFromJson.Execute(99);
five.Should().Be(5);
}
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);
}
public void ReturnsNewOrUpdatedGameToAndFromJson()
{
var nullGame = new ConstantRule <Game> {
Value = "null"
};
var nullGameCheckRule = new ValidationRule <Game>
{
ValueToValidateAgainst = nullGame,
OperatorToUse = "Equal"
};
var newGameRule = new StaticMethodCallRule <Game>
{
MethodClassName = "ModelForUnitTests.Game",
MethodToCall = "CreateGame"
};
var selfReturnRule = new SelfReturnRule <Game>();
var gameObjectRule = new ConditionalFuncRule <Game, Game>
{
ConditionRule = nullGameCheckRule,
TrueRule = newGameRule,
FalseRule = selfReturnRule
};
var assignRule = new UpdateValueRule <Game> {
SourceDataRule = gameObjectRule
};
var nameChangeRule = new UpdateValueRule <Game>
{
ObjectToUpdate = "Name",
SourceDataRule = new ConstantRule <string> {
Value = "some fancy name"
}
};
var rankingChangeRule = new UpdateValueRule <Game>
{
ObjectToUpdate = "Ranking",
SourceDataRule = new ConstantRule <int> {
Value = "1000"
}
};
var descriptionChangeRule = new UpdateValueRule <Game>
{
ObjectToUpdate = "Description",
SourceDataRule = new ConstantRule <string> {
Value = "some cool description"
}
};
var blockRule = new FuncBlockRule <Game, Game>();
blockRule.Rules.Add(assignRule);
blockRule.Rules.Add(nameChangeRule);
blockRule.Rules.Add(rankingChangeRule);
blockRule.Rules.Add(descriptionChangeRule);
blockRule.Rules.Add(selfReturnRule);
var jsonConverterForRule = new JsonConverterForRule();
var json = JsonConvert.SerializeObject(blockRule, Formatting.Indented, jsonConverterForRule);
_testOutputHelper.WriteLine(json);
var blockRule2 = JsonConvert.DeserializeObject <FuncBlockRule <Game, Game> >(json, jsonConverterForRule);
var compileResult = blockRule2.Compile();
compileResult.Should().BeTrue();
var game = blockRule2.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 = blockRule2.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 ConditionalRuleWithBlockUsingFactory()
{
var sourceNameRule = ConstantRulesFactory.CreateConstantRule <string>("some fancy name");
var nameChangeRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>(g => g.Name, sourceNameRule);
var sourceRankRule = ConstantRulesFactory.CreateConstantRule <int>("1000");
var rankingChangeRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>(g => g.Ranking, sourceRankRule);
var sourceDescRule = ConstantRulesFactory.CreateConstantRule <string>("some cool description");
var descriptionChangeRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>(g => g.Description, sourceDescRule);
var subRules = new List <Rule>
{
nameChangeRule,
rankingChangeRule,
descriptionChangeRule
};
var blockRule = BlockRulesFactory.CreateActionBlockRule <Game>(subRules);
var param1Const = ConstantRulesFactory.CreateConstantRule <string>("some name");
var param2Const = ConstantRulesFactory.CreateConstantRule <StringComparison>("CurrentCultureIgnoreCase");
var nameEqualsRule = MethodCallRulesFactory.CreateMethodCallRule <Game, bool>("Equals", null, (g => g.Name),
new List <Rule> {
param1Const, param2Const
});
var conditionalUpdateValue =
ConditionalRulesFactory.CreateConditionalIfThActionRule <Game>(nameEqualsRule, blockRule);
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("some fancy name");
_testOutputHelper.WriteLine($"{game}");
var jsonConverterForRule = new JsonConverterForRule();
var json = JsonConvert.SerializeObject(conditionalUpdateValue, jsonConverterForRule);
_testOutputHelper.WriteLine(json);
var conditionalUpdateValue2 = JsonConvert.DeserializeObject <Rule>(json, jsonConverterForRule);
compileResult = conditionalUpdateValue2.Compile();
compileResult.Should().BeTrue();
var game2 = new Game {
Name = "some name"
};
_testOutputHelper.WriteLine($"before game2.Name: {game2.Name}");
(conditionalUpdateValue2 as ConditionalIfThActionRule <Game>)?.Execute(game2);
_testOutputHelper.WriteLine($"after game2.Name: {game2.Name}");
game.Name.Should().Be("some fancy name");
_testOutputHelper.WriteLine($"{game2}");
}
public void ConditionalRuleWithBlockToAndFromJson()
{
var nameChangeRule = new UpdateValueRule <Game>
{
ObjectToUpdate = "Name",
SourceDataRule = new ConstantRule <string> {
Value = "some fancy name"
}
};
var rankingChangeRule = new UpdateValueRule <Game>
{
ObjectToUpdate = "Ranking",
SourceDataRule = new ConstantRule <int> {
Value = "1000"
}
};
var descriptionChangeRule = new UpdateValueRule <Game>
{
ObjectToUpdate = "Description",
SourceDataRule = new ConstantRule <string> {
Value = "some cool description"
}
};
var blockRule = new ActionBlockRule <Game>();
blockRule.Rules.Add(nameChangeRule);
blockRule.Rules.Add(rankingChangeRule);
blockRule.Rules.Add(descriptionChangeRule);
var conditionalUpdateValue = new ConditionalIfThActionRule <Game>
{
ConditionRule = new MethodCallRule <Game, bool>
{
ObjectToCallMethodOn = "Name",
MethodToCall = "Equals",
MethodParameters = { new ConstantRule <string> {
Value = "some name"
},
new ConstantRule <StringComparison> {
Value = "CurrentCultureIgnoreCase"
} }
},
TrueRule = blockRule
};
var converter = new JsonConverterForRule();
// convert to json
var ruleJson = JsonConvert.SerializeObject(conditionalUpdateValue, Formatting.Indented, converter);
_testOutputHelper.WriteLine($"{nameof(ruleJson)}:{Environment.NewLine}{ruleJson}");
// re-hydrate from json
var ruleFromJson = JsonConvert.DeserializeObject <ConditionalIfThActionRule <Game> >(ruleJson, converter);
var compileResult = ruleFromJson.Compile();
compileResult.Should().BeTrue();
var game = new Game {
Name = "some name"
};
_testOutputHelper.WriteLine($"before game.Name: {game.Name}");
ruleFromJson.Execute(game);
_testOutputHelper.WriteLine($"after game.Name: {game.Name}");
game.Name.Should().Be("some fancy name");
game.Ranking.Should().Be(1000);
game.Description.Should().Be("some cool description");
_testOutputHelper.WriteLine($"{game}");
}
