public void StuurInformatieTest()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Rijksoverheid/Zorgtoeslag.yaml"));
Assert.False(result.IsError);
var header = controller.GetHeader();
Assert.True(header.Onderwerp == "zorgtoeslag");
Assert.True(header.Organisatie == "belastingdienst");
Assert.True(header.Type == "toeslagen");
Assert.True(header.Domein == "zorg");
Assert.True(header.Versie == "1.0");
Assert.True(header.Status == "ontwikkel");
Assert.True(header.Jaar == "2019");
Assert.True(header.Bron == "https://download.belastingdienst.nl/toeslagen/docs/berekening_zorgtoeslag_2019_tg0821z91fd.pdf");
}
void Formula_Table_Lookup_Test()
{
// -naam: woonlandfactoren
// woonland, factor:
// - [Finland, 0.7161]
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Rijksoverheid/Zorgtoeslag.yaml"));
ExpressionContext context = new ExpressionContext(controller);
// Tsjechië, 0.2412
context.Variables.Add("woonland", "Tsjechië");
var formula = controller.GetFormula("woonlandfactor");
// select(string tableName, string lookupValue, string lookupColumn, string resultColumn)
IDynamicExpression e = context.CompileDynamic(formula.Functions[0].Expression);
double result1 = (double)e.Evaluate();
Assert.True(result1 == 0.2412);
}
public async void ShouldReturnDebugInformation(string yamlFile)
{
// IMPORTANT please the nl-NL language at the end of the collection, as other
// tests are primarily tested under nl-NL yaml test files.
foreach (var language in new[] { "nl-NL", "en-US" })
{
Globalization.SetKeywordResourceCulture(new System.Globalization.CultureInfo(language));
Globalization.SetFormattingExceptionResourceCulture(new System.Globalization.CultureInfo(language));
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load($"Malformed/{language}/{yamlFile}.yaml"));
Assert.True(result.IsError);
Assert.NotNull(result.Exceptions);
Assert.NotNull(result.Message);
Assert.True(result.Exceptions.Exceptions.Count == 1);
Assert.NotNull(result.Exceptions.Exceptions[0].DebugInfo);
Output.WriteLine($"{language} message: {result.Message} {result.Exceptions.Exceptions[0].DebugInfo}");
}
}
public void ShouldReturnNoRight()
{
var isException = false;
//prepare the result
var parameters = new ParametersCollection
{
new ClientParameter("A", "nee", TypeInference.InferenceResult.TypeEnum.Boolean, "Dummy"),
new ClientParameter("B", "ja", TypeInference.InferenceResult.TypeEnum.Boolean, "Dummy")
} as IParametersCollection;
var executionResult = new ExecutionResult(ref parameters) as IExecutionResult;
//prepare yaml definition
var controller = new YamlScriptController();
controller.Parse(_testYaml2);
//set the callback
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
executionResult.Questions = args;
};
try
{
controller.ExecuteWorkflow(ref parameters, ref executionResult);
}
catch (UnresolvedException)
{
isException = true;
}
Assert.False(isException);
Assert.Equal(3, executionResult.Parameters.Count);
Assert.Equal("A", executionResult.Parameters[0].Name);
Assert.False((bool)executionResult.Parameters[0].Value);
Assert.Equal("B", executionResult.Parameters[1].Name);
Assert.True((bool)executionResult.Parameters[1].Value);
Assert.Equal("recht", executionResult.Parameters[2].Name);
Assert.False((bool)executionResult.Parameters[2].Value);
Assert.Null(executionResult.Questions);
Assert.Single(executionResult.Stacktrace);
Assert.Equal("Test A of B", executionResult.Stacktrace.First().Step.Description);
}
public void MinimalCompilationTest()
{
var controller = new YamlScriptController();
var result = controller.Parse(File.OpenText(@"../../../minimal.yaml").ReadToEnd());
//var p = parser.Flow();
StringBuilder i = new StringBuilder(); // grain interface.
StringBuilder p = new StringBuilder(); // grain persistence.
var m = result.Model;
i.AppendLine($"public interface {m.Header.Onderwerp} : IGrainWithStringKey {{");
p.AppendLine("using System;");
p.AppendLine($"namespace {m.Header.Organisatie.ToPascalCase()}.{m.Header.Domein.ToPascalCase()}.{m.Header.Type.ToPascalCase()}.{m.Header.Onderwerp.ToPascalCase()} {{");
p.AppendLine($"[Serializable]public class {m.Header.Onderwerp}_state {{");
p.AppendLine($"public const string hBron = \"{m.Header.Bron}\";");
p.AppendLine($"public const string hDomein = \"{m.Header.Domein}\";");
p.AppendLine($"public const string hPeriode = \"{m.Header.Jaar}\";");
p.AppendLine($"public const string hOnderwerp = \"{m.Header.Onderwerp}\";");
p.AppendLine($"public const string hOrganisatie = \"{m.Header.Organisatie}\";");
p.AppendLine($"public const string hStatus = \"{m.Header.Status}\";");
p.AppendLine($"public const string hType = \"{m.Header.Type}\";");
p.AppendLine($"public const string hVersie = \"{m.Header.Versie}\";");
//p.AppendLine($"public class {m.Header.Onderwerp}_state {{");
foreach (var step in result.Model.Steps)
{
// i.AppendLine($"public interface {m.Header.Onderwerp} : IGrainWithIntegerKey {{");
if (step.Choices != null)
{
foreach (var choice in step.Choices)
{
p.AppendLine($"public bool {choice.Situation} {{get;set;}}");
}
}
if (step.Value != null)
{
p.AppendLine($"public double {step.Value} {{get;set;}}");
}
}
p.AppendLine($"}}"); // end class
p.AppendLine($"}}"); // end namespace
var state = p.ToString();
}
public async Task <IExecutionResult> Execute(string yaml, IParametersCollection parameters)
{
IExecutionResult executionResult = null;
var controller = new YamlScriptController();
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
executionResult.Questions = args;
};
var result = controller.Parse(yaml);
executionResult = new ExecutionResult(ref parameters) as IExecutionResult;
try
{
controller.ExecuteWorkflow(ref parameters, ref executionResult);
}
catch (UnresolvedException) { }
return(executionResult);
}
public void CanDiscoverAllSemanticKeysAndBindToParameters()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Zorgtoeslag5.yaml"));
Assert.False(result.IsError);
Assert.True(controller.ContentNodes.Count == 35);
List <string> keys = new List <string>();
foreach (var item in controller.ContentNodes)
{
if (item.Name != "end")
{
Assert.NotNull(item.Parameter);
Assert.NotNull(item.Parameter.SemanticKey);
Assert.True(item.Parameter.SemanticKey == item.Name);
}
keys.Add(item.Name);
}
var s = string.Join('\n', keys);
}
public async Task <IActionResult> ValidateRuleYaml(Uri url)
{
try
{
var ret = await Download(url);
if (ret.StatusCode != 200)
{
return(ret);
}
YamlScriptController controller = new YamlScriptController();
var yaml = ret.Value.ToString();
var result = controller.Parse(yaml);
ParseResult parseResult = new ParseResult()
{
};
return(StatusCode(200, parseResult));
}
catch (Exception ex)
{
return(StatusCode(500, new ServerError500Response(ex)));
}
}
public async Task <IActionResult> ExecuteRuleYaml([FromBody] ExecuteRuleYamlFromUriRequest request)
{
var controller = new YamlScriptController();
var response = new ExecuteRuleYamlFromUriResponse();
var parameters = request.ClientParameters.Adapt <IParametersCollection>();
IExecutionResult executionResult = null;
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
executionResult.Questions = args;
};
var downloadResult = request.Endpoint.DownloadYaml();
var result = controller.Parse(downloadResult.Content);
if (result.IsError)
{
return(StatusCode(400, response));
}
;
executionResult = new ExecutionResult(ref parameters);
try
{
executionResult = controller.ExecuteWorkflow(ref parameters, ref executionResult);
}
catch (UnresolvedException)
{
}
if (executionResult.IsError)
{
response.ExecutionStatus = ExecuteRuleYamlResultTypes.SyntaxError;
return(StatusCode(400, response));
}
response.ServerParameters = executionResult.Parameters.Adapt <IEnumerable <ServerParameter> >();
return(StatusCode(200, new ExecuteRuleYamlFromUriResponse()));
}
public void YamlCanParseAndEvaluateSituationalTables()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(
@"UnitTests/SituationalTables/ValidSituations.yaml"));
Assert.False(result.IsError);
Assert.True(result.Model.Tables.ElementAt(0).IsSituational);
Assert.True(result.Model.Tables.ElementAt(0).Situations.ElementAt(0).Expression == "keuze_c1");
Assert.True(result.Model.GetTablesByName("tabel1").Count() == 3);
var parameters = new ParametersCollection()
{
new ClientParameter("waarde_a", "70", TypeInference.InferenceResult.TypeEnum.Double, "Dummy"),
new ClientParameter("waarde_b", "40", TypeInference.InferenceResult.TypeEnum.Double, "Dummy"),
new ClientParameter("keuze_c1", "ja", TypeInference.InferenceResult.TypeEnum.Boolean, "Dummy"),
new ClientParameter("keuze_c2", "nee", TypeInference.InferenceResult.TypeEnum.Boolean, "Dummy")
} as IParametersCollection;
var executionResult = null as IExecutionResult;
executionResult = new ExecutionResult(ref parameters);
executionResult = controller.ExecuteWorkflow(ref parameters, ref executionResult);
}
public void ShouldReturnBooleanAsFirstQuestionOldSituation2()
{
var isException = false;
//prepare the result
var parameters = new ParametersCollection() as IParametersCollection;
var executionResult = new ExecutionResult(ref parameters) as IExecutionResult;
//prepare yaml definition
var controller = new YamlScriptController();
//controller.Parse(_testYaml5);
controller.Parse(YamlTestFileLoader.Load(@"Zorgtoeslag4.yaml"));
//set the callback
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
executionResult.Questions = args;
};
try
{
controller.ExecuteWorkflow(ref parameters, ref executionResult);
}
catch (UnresolvedException)
{
isException = true;
}
Assert.True(isException);
Assert.Empty(executionResult.Parameters);
Assert.Single(executionResult.Questions.Parameters);
Assert.Equal("woonland", executionResult.Questions.Parameters[0].Name);
Assert.Equal(41, ((List <object>)executionResult.Questions.Parameters[0].Value).Count);
Assert.Single(executionResult.Stacktrace);
Assert.Equal("woonland", executionResult.Stacktrace.First().Step.Description);
}
public void ShouldCorrectlyMapServerParameters()
{
TypeAdapterConfig <Vs.Rules.Core.Model.IParameter, OpenApi.v1.Features.discipl.Dto.ServerParameter> .NewConfig().Compile();
// Get The Server Model.
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Rijksoverheid/Zorgtoeslag.yaml"));
var model = result.Model;
var parameters = new Vs.Rules.Core.ParametersCollection()
{
new Vs.Rules.Core.Model.Parameter("alleenstaande", "ja", Vs.Rules.Core.TypeInference.InferenceResult.TypeEnum.Boolean, ref model),
new Vs.Rules.Core.Model.Parameter("toetsingsinkomen_aanvrager", (double)19000, Vs.Rules.Core.TypeInference.InferenceResult.TypeEnum.Double, ref model),
new Vs.Rules.Core.Model.Parameter("vermogen_aanvrager", (double)1000, Vs.Rules.Core.TypeInference.InferenceResult.TypeEnum.Double, ref model),
new Vs.Rules.Core.Model.Parameter("woonland", "Nederland", Vs.Rules.Core.TypeInference.InferenceResult.TypeEnum.List, ref model)
} as Vs.Rules.Core.Interfaces.IParametersCollection;
var apiParameters = parameters.Adapt <OpenApi.v1.Features.discipl.Dto.ServerParametersCollection>();
Assert.True(apiParameters.Count == 4);
for (int i = 0; i < parameters.Count; i++)
{
Assert.True(apiParameters[i].Name == parameters[i].Name);
Assert.True((int)apiParameters[i].Type == (int)parameters[i].Type);
Assert.True(apiParameters[i].Value == parameters[i].Value);
}
// test implicit mapping
var serverParameters = apiParameters.Adapt <Vs.Rules.Core.ParametersCollection>();
for (int i = 0; i < parameters.Count; i++)
{
Assert.True(apiParameters[i].Name == serverParameters[i].Name);
Assert.True((int)apiParameters[i].Type == (int)serverParameters[i].Type);
Assert.True(apiParameters[i].Value == serverParameters[i].Value);
}
}
public CodeGeneratorTests()
{
var controller = new YamlScriptController();
_context.ParseResult = controller.Parse(File.OpenText(@"../../../minimal.yaml").ReadToEnd());
}
public async Task <Model> Parse(string yaml)
{
var controller = new YamlScriptController();
return(controller.Parse(yaml).Model);
}
public void TimePeriodsCanBeReadFromTable()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"WettelijkeRente.yaml"));
IParametersCollection parameters = new ParametersCollection();
var executionResult = null as IExecutionResult;
bool isException = false;
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
switch (args.Parameters[0].Name)
{
case "hoofdsom":
Assert.True(args.Parameters[0].Type == TypeInference.InferenceResult.TypeEnum.Double);
parameters.Add(new ClientParameter("hoofdsom", 7500, TypeInference.InferenceResult.TypeEnum.Double, "Dummy"));
break;
case "looptijd":
Assert.True(args.Parameters[0].Type == TypeInference.InferenceResult.TypeEnum.Period);
parameters.Add(new ClientParameter("vanaf", "30 Januari 2017", TypeInference.InferenceResult.TypeEnum.Period, "Dummy"));
break;
case "soort_rente":
Assert.True(args.Parameters[0].Type == TypeInference.InferenceResult.TypeEnum.List);
parameters.Add(new ClientParameter("soort_rente", 1500, TypeInference.InferenceResult.TypeEnum.Double, "Dummy"));
break;;
}
};
Assert.False(result.IsError);
Assert.True(result.Model.Tables.Count == 2);
Assert.True(result.Model.Tables[0].ColumnTypes[0].Type == TypeInference.InferenceResult.TypeEnum.DateTime);
// Create TimeRange Array
var range = new List <TimeRange>();
for (int i = result.Model.Tables[0].Rows.Count - 1; i > 0; i--)
{
range.Add(new TimeRange(
DateTime.Parse(result.Model.Tables[0].Rows[i].Columns[0].Value.ToString(), new CultureInfo("nl-NL")),
DateTime.Parse(result.Model.Tables[0].Rows[i - 1].Columns[0].Value.ToString(), new CultureInfo("nl-NL")).AddDays(-1)));
}
range.Add(new TimeRange(DateTime.Parse(result.Model.Tables[0].Rows[0].Columns[0].Value.ToString(), new CultureInfo("nl-NL")), DateTime.MaxValue));
/*
* try
* {
* executionResult = new ExecutionResult(ref parameters);
* controller.ExecuteWorkflow(ref parameters, ref executionResult);
* }
* catch (UnresolvedException)
* {
* isException = true;
* }
* Assert.True(isException);
* isException = false;
* try
* {
* controller.ExecuteWorkflow(ref parameters, ref executionResult);
* }
* catch (UnresolvedException)
* {
* isException = true;
* }
* isException = false;
* try
* {
* controller.ExecuteWorkflow(ref parameters, ref executionResult);
* }
* catch (UnresolvedException)
* {
* isException = true;
* }
* Assert.True(isException);
*/
}