public void GetContentNodesFromExecutionResult()
{
QuestionArgs argsret = null;
var controller = new YamlScriptController();
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
argsret = args;
};
var result = controller.Parse(YamlTestFileLoader.Load(@"Zorgtoeslag5.yaml"));
var parameters = new ParametersCollection()
{
new ClientParameter("woonland", "Nederland", TypeInference.InferenceResult.TypeEnum.List, "Dummy")
} as IParametersCollection;
var executionResult = new ExecutionResult(ref parameters) as IExecutionResult;
try
{
controller.ExecuteWorkflow(ref parameters, ref executionResult);
}
catch (UnresolvedException ex)
{
}
Assert.Equal(35, executionResult.ContentNodes.Count());
Assert.Equal("stap.woonsituatie.keuze.alleenstaande",
executionResult.ContentNodes.FirstOrDefault(c => c.Parameter.Name == argsret.Parameters.ToList()[0].Name).Parameter.SemanticKey);
Assert.Equal("stap.woonsituatie.keuze.aanvrager_met_toeslagpartner",
executionResult.ContentNodes.FirstOrDefault(c => c.Parameter.Name == argsret.Parameters.ToList()[1].Name).Parameter.SemanticKey);
}
public async Task <IActionResult> ExecuteRuleYaml([FromBody] ExecuteRuleYamlFromUriRequest request)
{
return(StatusCode(500, new ServerError500Response(new NotImplementedException())));
var controller = new YamlScriptController();
var response = new ExecuteRuleYamlFromUriResponse();
var parameters = request.ClientParameters.Adapt <IParametersCollection>();
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
};
var downloadResult = request.Endpoint.DownloadYaml();
var result = controller.Parse(downloadResult.Content);
// map the parsing result.
if (result.IsError)
{
return(StatusCode(400, response));
}
;
var executionResult = new ExecutionResult(ref parameters) as IExecutionResult;
controller.ExecuteWorkflow(ref parameters, ref executionResult);
return(StatusCode(200, new ExecuteRuleYamlFromUriResponse()));
}
public async Task <IActionResult> GenerateContentTemplate(Uri url)
{
try
{
var ret = await Download(url);
if (ret.StatusCode != 200)
{
return(ret);
}
var yaml = ret.Value.ToString();
YamlScriptController controller = new YamlScriptController();
var result = controller.Parse(yaml);
ParseResult parseResult = new ParseResult()
{
};
if (result.IsError)
{
return(StatusCode(400, parseResult));
}
return(StatusCode(200, controller.CreateYamlContentTemplate()));
}
catch (Exception ex)
{
return(StatusCode(500, new ServerError500Response(ex)));
}
}
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()
{
IsError = result.IsError,
Message = result.Message
};
return(StatusCode(200, parseResult));
}
catch (Exception ex)
{
return(StatusCode(500, new ServerError500Response(ex)));
}
}
public void ExecutionResultHasCorrectSemanticKeyOnGeenRecht()
{
QuestionArgs argsret = null;
var controller = new YamlScriptController();
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
argsret = args;
};
var result = controller.Parse(YamlTestFileLoader.Load(@"Zorgtoeslag5.yaml"));
var parameters = new ParametersCollection()
{
new ClientParameter("woonland", "Anders", TypeInference.InferenceResult.TypeEnum.List, "Dummy")
} as IParametersCollection;
var executionResult = new ExecutionResult(ref parameters) as IExecutionResult;
try
{
controller.ExecuteWorkflow(ref parameters, ref executionResult);
}
catch (UnresolvedException ex)
{
}
Assert.Equal("stap.woonland", executionResult.Step.SemanticKey);
Assert.Equal("stap.woonland.geen_recht", executionResult.Step.Break.SemanticKey);
Assert.True(executionResult?.Parameters?.Any(p => p.Name == "recht" && !(bool)p.Value));
}
public async Task <ExecutionResult> Execute(string yaml, IParametersCollection parameters)
{
await _parameters.ReadStateAsync();
var state = _parameters.State as IParametersCollection;
var executionResult = new ExecutionResult(ref parameters) as IExecutionResult;
var controller = new YamlScriptController();
controller.QuestionCallback = (sender, args) =>
{
executionResult.Questions = args;
};
var result = controller.Parse(yaml);
executionResult = new ExecutionResult(ref parameters);
try
{
controller.ExecuteWorkflow(ref state, ref executionResult);
}
catch (UnresolvedException) { }
_parameters.State = executionResult.Parameters as ParametersCollection;
await _parameters.WriteStateAsync();
return(executionResult as ExecutionResult);
}
public void CanParseChoices()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Zorgtoeslag4.yaml"));
Assert.False(result.IsError);
}
void Formula_Can_Execute_FormulaExpressionContext()
{
var controller = new YamlScriptController();
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
// should not be called.
throw new Exception("Questioncallback should not be called.");
};
var result = controller.Parse(YamlTestFileLoader.Load(@"Rijksoverheid/Zorgtoeslag.yaml"));
var parameters = new ParametersCollection()
{
new ClientParameter("alleenstaande", "ja", TypeInference.InferenceResult.TypeEnum.Boolean, "Dummy"),
new ClientParameter("woonland", "Nederland", TypeInference.InferenceResult.TypeEnum.List, "Dummy"),
new ClientParameter("toetsingsinkomen_aanvrager", (double)19000, TypeInference.InferenceResult.TypeEnum.Double, "Dummy"),
new ClientParameter("toetsingsinkomen_toeslagpartner", (double)0, TypeInference.InferenceResult.TypeEnum.Double, "Dummy")
} as IParametersCollection;
var model = result.Model;
var context = new FormulaExpressionContext(ref model, ref parameters, controller.GetFormula("normpremie"), controller.QuestionCallback, controller);
var parameter = context.Evaluate();
Assert.True(parameter.Name == "normpremie");
Assert.True((double)parameter.Value == 419.86704999999995);
Assert.True(parameters.Count == 7);
}
public void ShouldAcceptWaarde()
{
var controller = new YamlScriptController();
var parseResult = controller.Parse(_testYaml1);
Assert.False(parseResult.IsError);
}
void Formula_Can_Execute_FormulaExpressionContext_UsingQuestionAnswer()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Rijksoverheid/Zorgtoeslag.yaml"));
var parameters = new ParametersCollection()
{
new ClientParameter("alleenstaande", "ja", TypeInference.InferenceResult.TypeEnum.Boolean, "Dummy"),
new ClientParameter("woonland", "Nederland", TypeInference.InferenceResult.TypeEnum.List, "Dummy"),
new ClientParameter("toetsingsinkomen_toeslagpartner", (double)0, TypeInference.InferenceResult.TypeEnum.Double, "Dummy")
} as IParametersCollection;
var model = result.Model;
bool called = false;
OnQuestion = (FormulaExpressionContext sender, QuestionArgs args) =>
{
Assert.True(args.Parameters[0].Name == "toetsingsinkomen_aanvrager");
called = true;
};
var context = new FormulaExpressionContext(ref model, ref parameters, controller.GetFormula("normpremie"), OnQuestion, controller);
bool unresolvedException = false;
try
{
var parameter = context.Evaluate();
}
catch (UnresolvedException)
{
unresolvedException = true;
}
Assert.True(called);
Assert.True(unresolvedException);
}
public void ShouldReturnBooleanAsFirstQuestionNewSituation()
{
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(_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.True(isException);
Assert.Empty(executionResult.Parameters);
Assert.Equal(2, executionResult.Questions.Parameters.Count);
Assert.Equal("A", executionResult.Questions.Parameters[0].Name);
Assert.Equal("B", executionResult.Questions.Parameters[1].Name);
Assert.Single(executionResult.Stacktrace);
Assert.Equal("Test A of B", executionResult.Stacktrace.First().Step.Description);
}
public void ShouldAcceptKeuze()
{
//List<ParametersCollection> parameters = new List<ParametersCollection>();
var controller = new YamlScriptController();
var parseResult = controller.Parse(_testYaml1);
Assert.False(parseResult.IsError);
}
public static Model GetDefaultTestModel()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Zorgtoeslag5.yaml"));
Assert.False(result.IsError);
return(result.Model);
}
public void Model_Parse_Yaml_To_Model()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Rijksoverheid/Zorgtoeslag.yaml"));
Assert.True(controller.GetSituation("standaardpremie", "alleenstaande").Expression == "1609");
Assert.True(controller.GetSituation("maximaalvermogen", "aanvrager_met_toeslagpartner").Expression == "145136");
}
void Formula_Can_Discover_Parameters_And_InferedTypes_From_Yaml()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"WettelijkeRente.yaml"));
Assert.False(result.IsError);
var parameters = controller.GetFunctionTree(controller);
Assert.True(parameters.Count == 4);
}
void Formula_Can_Discover_Parameters_From_Yaml()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Rijksoverheid/Zorgtoeslag.yaml"));
Assert.False(result.IsError);
var parameters = controller.GetFunctionTree(controller);
Assert.True(parameters.Count == 9);
}
public void ShouldStillReadDescription()
{
var controller = new YamlScriptController();
var parseResult = controller.Parse(_testYaml1);
Assert.Single(parseResult.Model.Steps);
var stepToTest = parseResult.Model.Steps.First();
Assert.Equal("toetsingsinkomen", stepToTest.Name);
Assert.Equal("toetsingsinkomen", stepToTest.Description);
}
public void ShouldGenerateAValidContentYamlTemplate()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Zorgtoeslag5.yaml"));
Assert.False(result.IsError);
var template = controller.CreateYamlContentTemplate();
Assert.False(string.IsNullOrEmpty(template));
}
public void ShouldNotNeedDescription()
{
//List<ParametersCollection> parameters = new List<ParametersCollection>();
var controller = new YamlScriptController();
var parseResult = controller.Parse(_testYaml2);
Assert.Single(parseResult.Model.Steps);
var stepToTest = parseResult.Model.Steps.First();
Assert.Equal("Test A of B", stepToTest.Name);
Assert.Equal("Test A of B", stepToTest.Description);
}
public void Flow_ZorgToeslag_2019_Scenario1_Condition_Branche_Test()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"Rijksoverheid/Zorgtoeslag.yaml"));
var parameters = new ParametersCollection();
parameters.Add(new ClientParameter("woonland", "Nederland", TypeInference.InferenceResult.TypeEnum.List, "Dummy"));
// var executionResult = controller.ExecuteWorkflow(parameters);
// Tsjechië, 0.2412
// context.Variables.Add("woonland", "Tsjechië");
// var formula = controller.GetFormula("woonlandfactor");
}
public void ShouldHaveTwoChoices()
{
//List<ParametersCollection> parameters = new List<ParametersCollection>();
var controller = new YamlScriptController();
var parseResult = controller.Parse(_testYaml2);
Assert.Single(parseResult.Model.Steps);
var stepToTest = parseResult.Model.Steps.First();
Assert.Equal(2, stepToTest.Choices.Count());
Assert.Equal("A", stepToTest.Choices.ElementAt(0).Situation);
Assert.Equal("B", stepToTest.Choices.ElementAt(1).Situation);
}
public void CanDetermineTableLookupValueFromQuestion()
{
var controller = new YamlScriptController();
var result = controller.Parse(YamlTestFileLoader.Load(@"TableTests.yaml"));
Assert.False(result.IsError);
var parameters = new ParametersCollection() as IParametersCollection;
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
Assert.True(args.Parameters[0].Name == "woonland");
Assert.True(args.Parameters[0].Type == TypeInference.InferenceResult.TypeEnum.List);
// This list can be used to do a selection of a valid woonland
Assert.True(((List <object>)args.Parameters[0].Value).Count > 0);
// Provide an anwser by selecting an item: Finland from the list
parameters.Add(new ClientParameter(args.Parameters[0].Name,
((List <object>)args.Parameters[0].Value)[1], TypeInference.InferenceResult.TypeEnum.List, "Dummy"));
};
var executionResult = new ExecutionResult(ref parameters) as IExecutionResult;
try
{
var workflow = controller.ExecuteWorkflow(ref parameters, ref executionResult);
}
catch (UnresolvedException)
{
// The server lookup needs to be evaluated again to get the resulting woonlandfactor.
// In this case the client will not need to have to answer another question.
// Maybe this can be put in core, in order to make the client logic simpler.
var evaluateAgain = controller.ExecuteWorkflow(ref parameters, ref executionResult);
}
Assert.True(parameters[0].Name == "woonland");
Assert.True((string)parameters[0].Value == "Finland");
Assert.True(parameters[1].Name == "woonlandfactor");
Assert.True((double)parameters[1].Value == 0.7161);
Assert.True(parameters[2].Name == "recht");
Assert.True((bool)parameters[2].Value == true);
// Quick Hack to see if recht is false by selecting woonland: Anders
parameters.Clear();
parameters.Add(new ClientParameter("woonland", "Anders", TypeInference.InferenceResult.TypeEnum.List, "Dummy"));
var recalculate = controller.ExecuteWorkflow(ref parameters, ref executionResult);
Assert.True(parameters[0].Name == "woonland");
Assert.True((string)parameters[0].Value == "Anders");
Assert.True(parameters[1].Name == "woonlandfactor");
Assert.True((double)parameters[1].Value == 0);
Assert.True(parameters[2].Name == "recht");
Assert.True((bool)parameters[2].Value == false);
Assert.NotNull(recalculate.Stacktrace.FindLast(p => p.IsStopExecution == true));
}
public async Task <IActionResult> DebugRuleYamlContents([FromBody] DebugRuleYamlFromContentRequest request)
{
var response = new DebugRuleYamlFromContentResponse();
var controller = new YamlScriptController();
var result = controller.Parse(request.Yaml);
if (result.IsError)
{
response.ParseResult = new ParseResult();
response.ParseResult.FormattingExceptions = result.Exceptions.Exceptions.Adapt <List <Dto.Exceptions.FormattingException> >();
response.ExecutionStatus = ExecuteRuleYamlResultTypes.SyntaxError;
return(StatusCode(200, response));
}
// No Errors found.
return(StatusCode(404, response));
}
public async Task <IActionResult> ExecuteRuleYamlContents([FromBody] ExecuteRuleYamlFromContentRequest request)
{
if (String.IsNullOrEmpty(request.Yaml))
{
return(StatusCode(400, null));
}
var controller = new YamlScriptController();
var response = new ExecuteRuleYamlFromContentResponse();
var parameters = request.ClientParameters.Adapt <IParametersCollection>();
if (parameters is null)
{
parameters = new ParametersCollection();
}
IExecutionResult executionResult = null;
controller.QuestionCallback = (FormulaExpressionContext sender, QuestionArgs args) =>
{
executionResult.Questions = args;
};
var result = controller.Parse(request.Yaml);
if (result.IsError)
{
response.ParseResult = new ParseResult();
response.ParseResult.FormattingExceptions = result.Exceptions.Exceptions.Adapt <List <Dto.Exceptions.FormattingException> >();
response.ExecutionStatus = ExecuteRuleYamlResultTypes.SyntaxError;
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.Ok;
return(StatusCode(400, response));
}
response.Questions = executionResult.Questions.Parameters.Adapt <IEnumerable <ServerParameter> >();
response.ServerParameters = executionResult.Parameters.Adapt <IEnumerable <ServerParameter> >();
return(StatusCode(200, response));
}
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");
}
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}");
}
}
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 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 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 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);
}