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}"); }