public void ConstantRuleOfTypeDoubleThatReturnsWhatIsSetAsValueStringToAndFromJson()
{
var rule = new ConstantRule <double> {
Value = "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);
// convert to json
var ruleJson = JsonConvert.SerializeObject(rule, new JsonConverterForRule());
_testOutputHelper.WriteLine($"{nameof(ruleJson)}:{Environment.NewLine}{ruleJson}");
// re-hydrate from json
var ruleFromJson = JsonConvert.DeserializeObject <Rule>(ruleJson, new JsonConverterForRule());
compileResult = ruleFromJson.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(ruleFromJson)}:{Environment.NewLine}" +
$"{ruleFromJson.ExpressionDebugView()}");
value = ((ConstantRule <double>)ruleFromJson).Get();
_testOutputHelper.WriteLine($"{nameof(ruleFromJson)}.... expected: 99.1 - actual: {value}");
value.Should().Be(99.1);
}
/// <summary>
/// Parses the validation rule definitions
/// </summary>
/// <param name="ruleDefinitions">The definitions for the validation rules</param>
/// <returns>The list of IRule instances</returns>
private static Dictionary <int, IRule> ParseRules(string[] ruleDefinitions)
{
var rules = new Dictionary <int, IRule>();
foreach (string rule in ruleDefinitions)
{
var parts = rule.Split(':');
int num = int.Parse(parts[0]);
if (parts[1].Contains('"'))
{
rules[num] = new ConstantRule(parts[1].Trim().Trim('"')[0]);
}
else if (parts[1].Contains('|'))
{
var orRule = new OrRule();
parts = parts[1].Split('|');
orRule.Left = ParseSequence(parts[0]);
orRule.Right = ParseSequence(parts[1]);
rules[num] = orRule;
}
else
{
rules[num] = ParseSequence(parts[1]);
}
}
return(rules);
}
public void ConstantRuleOfTypeIntNullableBoolReturnsFalseToAndFromJson()
{
var rule = new ConstantRule <int, bool?> {
Value = "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);
// convert to json
var ruleJson = JsonConvert.SerializeObject(rule, new JsonConverterForRule());
_testOutputHelper.WriteLine($"{nameof(ruleJson)}:{Environment.NewLine}{ruleJson}");
// re-hydrate from json
var ruleFromJson = JsonConvert.DeserializeObject <Rule>(ruleJson, new JsonConverterForRule());
var compileResult2 = ruleFromJson.Compile();
compileResult2.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(ruleFromJson)}:{Environment.NewLine}" +
$"{ruleFromJson.ExpressionDebugView()}");
var value2 = ((ConstantRule <int, bool?>)ruleFromJson).Get(int.MinValue);
value2.Should().Be(false);
}
public void ConstantRuleThrowsExceptionForNullValueType()
{
var rule = new ConstantRule <int> {
Value = "null"
};
var exception = Assert.Throws <RuleEngineException>(() => rule.Compile());
exception.Message.Should().Be("System.Int32 is not nullable and [null and/or empty string] can't be assigned");
}
/// <summary>
/// Handles the constant rule.
/// </summary>
/// <param name="constantRule">The constant rule.</param>
private void HandleConstantRule(CppElementFinder elementFinder, ConstantRule constantRule, string nameSpace)
{
constantManager.AddConstantFromMacroToCSharpType(
elementFinder,
constantRule.Macro ?? constantRule.Guid,
constantRule.ClassName,
constantRule.Type,
constantRule.Name,
constantRule.Value,
constantRule.Visibility,
nameSpace);
}
public void ConstantRuleOfTypeIntNullableBoolReturnsFalse()
{
var rule = new ConstantRule <int, bool?> {
Value = "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 Test1()
{
var rule = new ConstantRule <int> {
Value = "55"
};
var json = JsonConvert.SerializeObject(rule, new JsonConverterForRule());
_testOutputHelper.WriteLine(json);
//var rule2 = JsonConvert.DeserializeObject<Rule>(json, settings);
var rule2 = JsonConvert.DeserializeObject <Rule>(json, new JsonConverterForRule());
var foo = rule2.Compile();
foo.Should().BeTrue();
_testOutputHelper.WriteLine(rule2.ExpressionDebugView());
}
public void ConstantRuleOfTypeDoubleThatReturnsWhatIsSetAsValueString()
{
var ruleReturningDouble = new ConstantRule <double> {
Value = "99.1"
};
var compileResult = ruleReturningDouble.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(ruleReturningDouble)}:{Environment.NewLine}" +
$"{ruleReturningDouble.ExpressionDebugView()}");
var value = ruleReturningDouble.Get();
_testOutputHelper.WriteLine($"expected: 99.1 - actual: {value}");
value.Should().Be(99.1);
}
public void ConstantRuleOfTypeIntThatReturns55WhenValueIsSetTo55()
{
var ruleReturning55 = new ConstantRule <int> {
Value = "55"
};
var compileResult = ruleReturning55.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(ruleReturning55)}:{Environment.NewLine}" +
$"{ruleReturning55.ExpressionDebugView()}");
var value = ruleReturning55.Get();
_testOutputHelper.WriteLine($"expected: 55 - actual: {value}");
value.Should().Be(55);
}
public void ConstantRuleOfTypeIntThatReturnsString()
{
var stringValue = "55";
var ruleReturningString = new ConstantRule <int, string> {
Value = stringValue
};
var compileResult = ruleReturningString.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(ruleReturningString)}:{Environment.NewLine}" +
$"{ruleReturningString.ExpressionDebugView()}");
var value = ruleReturningString.Get(int.MinValue);
value.Should().BeOfType <string>().And.Be(stringValue);
}
public void FuncBlockRuleReturnsLastRuleResult()
{
var ruleReturning5 = new ConstantRule <int, int> {
Value = "5"
};
var blockRule = new FuncBlockRule <int, int>();
blockRule.Rules.Add(ruleReturning5);
var compileResult = blockRule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(ruleReturning5)}:{Environment.NewLine}" +
$"{ruleReturning5.ExpressionDebugView()}");
var five = blockRule.Execute(99);
five.Should().Be(5);
}
/// <summary>
/// Creates a C++ variable declaration from a macro rule.
/// </summary>
/// <param name="cstRule">The macro rule.</param>
/// <param name="finder">The element finder to find the macro definitions in.</param>
/// <returns>A C++ variable declaration string</returns>
private string CreateVariableFromMacro(CppElementFinder finder, ConstantRule cstRule)
{
var builder = new StringBuilder();
builder.AppendLine("// Variable created from: " + cstRule);
foreach (CppDefine macroDef in finder.Find <CppDefine>(cstRule.Macro))
{
var macroName = macroDef.Name + EndTagCustomVariable;
// Only add the macro once (could have multiple identical macro in different includes)
if (!_variableMacrosDefined.ContainsKey(macroName))
{
builder.AppendFormat("extern \"C\" {0} {1} = {3}{2};\n", cstRule.CppType ?? cstRule.Type, macroName, macroDef.Name, cstRule.CppCast ?? "");
_variableMacrosDefined.Add(macroName, macroDef.Name);
}
}
return(builder.ToString());
}
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);
}
public void ReturnsNewOrUpdatedGame()
{
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 compileResult = blockRule.Compile();
compileResult.Should().BeTrue();
_testOutputHelper.WriteLine($"{nameof(blockRule)}:{Environment.NewLine}" +
$"{blockRule.ExpressionDebugView()}");
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}");
}
