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