public async Task TestBoolExpressionsActuators()
{
var config = new MustacheConfigSchema()
{
Params = new List <Param>
{
new Param {
Name = "MySql", DefaultValue = "true"
},
new Param {
Name = "MySqlEFCore", DefaultValue = "false"
},
new Param {
Name = "C", DefaultValue = "false"
},
},
};
var dv = new Dictionary <string, string>
{
{ "MySql", "true" },
{ "MySqlEFCore", "false" },
};
var calcParam = new CalculatedParam
{
Name = "MySqlOrMySqlEFCore",
Expression = "MySql || MySqlEFCore",
ExpressionType = ExpressionTypeEnum.Bool,
};
var expression = new BooleanExpression(_logger, calcParam, config);
var result = await expression.EvaluateExpressionAsync(dv);
Assert.Equal(true.ToString(), result);
}
public async Task TestAnyExpression()
{
var config = new MustacheConfigSchema()
{
Params = new List <Param>
{
new Param {
Name = "MySql", DefaultValue = "true"
},
new Param {
Name = "MySqlEFCore", DefaultValue = "false"
},
new Param {
Name = "C", DefaultValue = "false"
},
},
};
var dv = new Dictionary <string, string>
{
{ "MySql", "true" },
};
var calcParam = new CalculatedParam
{
Name = "AnyEFCore",
Expression = "MySql,Postgres,Redis,MongoDB,OAuthConnector",
ExpressionType = ExpressionTypeEnum.Any,
};
var expression = new AnyExpression(_logger, calcParam, config);
var result = await expression.EvaluateExpressionAsync(dv);
Assert.Equal("True", result);
}
public EvaluationExpression BuildEvaluationExpression(MustacheConfigSchema schema)
{
using (Timing.Over(_logger, "Build case Expression"))
{
// TODO: Add validation
string EvaluationExpression(Dictionary <string, string> dataView)
{
var terms = _param.Expression.Split(',');
var lookupKey = terms[0]; // First term is the lookup Case(term0) { ...
var dataViewValue = dataView.ContainsKey(lookupKey) ? dataView[lookupKey] : string.Empty;
var caseResult = string.Empty;
foreach (var term in terms.Skip(1))
{
var expression = term.Split('=');
if ((dataViewValue == null || !expression[0].Equals(dataViewValue)) &&
expression[0] != "default")
{
continue;
}
caseResult = expression[1];
break;
}
return(caseResult);
}
return(EvaluationExpression);
}
}
public async Task TestCaseExpression()
{
var config = new MustacheConfigSchema()
{
Params = new List <Param>
{
new Param {
Name = "MySql", DefaultValue = "true"
},
new Param {
Name = "MySqlEFCore", DefaultValue = "false"
},
new Param {
Name = "C", DefaultValue = "false"
},
},
};
var dv = new Dictionary <string, string>
{
{ "TargetFrameworkVersion", "netcoreapp2.2" },
};
var calcParam = new CalculatedParam
{
Name = "AspNetCoreVersion",
Expression = "TargetFrameworkVersion,netcoreapp2.2=2.2.0,netcoreapp2.1=2.1.1,default=False",
ExpressionType = ExpressionTypeEnum.Case,
};
var expression = new CaseExpression(_logger, calcParam, config);
var result = await expression.EvaluateExpressionAsync(dv);
Assert.Equal("2.2.0", result);
}
public async Task TestStringExpression()
{
var config = new MustacheConfigSchema()
{
Params = new List <Param>
{
new Param {
Name = "MySql", DefaultValue = "true"
},
new Param {
Name = "MySqlEFCore", DefaultValue = "false"
},
new Param {
Name = "C", DefaultValue = "false"
},
},
};
var dv = new Dictionary <string, string>
{
{ "TargetFrameworkVersion", "netcoreapp2.2" },
};
var calcParam = new CalculatedParam
{
Name = "AspNetCoreVersion",
Expression = "dataView => dataView[\"TargetFrameworkVersion\"]==\"netcoreapp2.2\"? \"2.2.0\": null",
ExpressionType = ExpressionTypeEnum.Bool,
};
var expression = new StringExpression(_logger, calcParam, config);
var result = await expression.EvaluateExpressionAsync(dv);
Assert.Equal("2.2.0", result);
}
public EvaluationExpression BuildEvaluationExpression(MustacheConfigSchema config)
{
var options = ScriptOptions.Default.AddReferences(Assembly.GetExecutingAssembly());
using (Timing.Over(_logger, "Build StringExpression"))
{
return(CSharpScript.EvaluateAsync <EvaluationExpression>(_param.Expression, options).Result);
}
}
public EvaluationExpression BuildEvaluationExpression(MustacheConfigSchema schema)
{
// TODO: Add validation
using (Timing.Over(_logger, "Build Any Expression"))
{
var keys = _param.Expression.Split(',');
return(dataView => dataView.Any(kvp =>
keys.Contains(kvp.Key) &&
bool.TryParse(kvp.Value.ToString(), out var boolValue) &&
boolValue).ToString());
}
}
public async Task Test_MorethanOneExpression_false()
{
var config = new MustacheConfigSchema();
var dv = new Dictionary <string, string>
{
{ "IsMoreThanOne", "false" },
{ "ConfigServer", "false" },
{ "SQLServer", "true" },
{ "Redis", "false" },
};
var calcParam = new CalculatedParam
{
Name = "IsMoreThanOne",
Expression = "ConfigServer,SQLServer,Redis",
ExpressionType = ExpressionTypeEnum.MoreThanOne,
};
var expression = new MoreThanOneExpression(_logger, calcParam, config);
var result = await expression.EvaluateExpressionAsync(dv);
Assert.Equal("False", result);
}
public async Task TestBoolExpressions()
{
var config = new MustacheConfigSchema()
{
Params = new List <Param>
{
new Param {
Name = "A", DefaultValue = "true"
},
new Param {
Name = "B", DefaultValue = "false"
},
new Param {
Name = "C", DefaultValue = "false"
},
},
};
var dv = new Dictionary <string, string>
{
{ "A", "true" },
{ "B", "false" },
{ "C", "false" },
};
var calcParam = new CalculatedParam
{
Name = "testExp",
Expression = "A || B && !C ",
ExpressionType = ExpressionTypeEnum.Bool,
};
var expression = new BooleanExpression(_logger, calcParam, config);
var result = await expression.EvaluateExpressionAsync(dv);
Assert.Equal("True", result);
}
private string GetLambdaString(MustacheConfigSchema config)
{
var lambda = string.Empty;
var expressionString = _param.Expression;
var tree = SyntaxFactory.ParseExpression(expressionString);
foreach (var node in tree.DescendantTokens())
{
var key = node.ToString();
if (config.Params.Any(p => p.Name == key))
{
lambda += $" (bool.TryParse(dataView[\"{key}\"], out bool bool{key}Value) && bool{key}Value)";
}
else
{
lambda += key;
}
}
lambda = "dataView => { bool result = " + lambda + "; return result.ToString(); }";
_logger.LogDebug("Created boolean lambda : " + lambda);
return(lambda);
}
public MoreThanOneExpression(ILogger logger, CalculatedParam param, MustacheConfigSchema schema)
{
_param = param;
_logger = logger;
_evaluationExpression = BuildEvaluationExpression(schema);
}
public StringExpression(ILogger logger, CalculatedParam param, MustacheConfigSchema config)
{
_param = param;
_logger = logger;
_evaluationExpression = BuildEvaluationExpression(config);
}
