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