public void SetValues()
{
var conclusion1 = new Models.Variable("conclusion1", "conclusion1", "Should pass");
var conclusion2 = new Models.Variable("conclusion2", "conclusion2", "Shouldn't pass");
var service = new ReasoningService();
var reasoningProcess = MockReasoningProcess(ReasoningMethod.Deduction, conclusion1, conclusion2);
reasoningProcess = service.ClearReasoning(reasoningProcess);
var result = service.SetValues(reasoningProcess, new List <IVariable>
{
new Models.Variable("var1", 3),
new Models.Variable("var2", null, "OK"),
new Models.Variable("var3", new [] { "opt1" })
});
Assert.IsFalse(result.KnowledgeBase.RuleSet[0].Predicates[0].LeftTerm.IsEmpty());
Assert.IsFalse(result.KnowledgeBase.RuleSet[0].Predicates[1].LeftTerm.IsEmpty());
Assert.IsFalse(result.KnowledgeBase.RuleSet[0].Predicates[2].LeftTerm.IsEmpty());
Assert.IsFalse(result.KnowledgeBase.RuleSet[1].Predicates[0].LeftTerm.IsEmpty());
Assert.IsFalse(result.KnowledgeBase.RuleSet[1].Predicates[1].LeftTerm.IsEmpty());
Assert.IsFalse(result.KnowledgeBase.RuleSet[1].Predicates[2].LeftTerm.IsEmpty());
}
public void ProcessReasoningTask_PartialFacts_APIDoesNotRespond()
{
var reasoningTask = ReasoningMocks.GetReasoningTask(ReasoningTaskStatus.WAITING);
reasoningTask.ReasoningProcess.KnowledgeBase.RuleSet[0].Predicates[0].LeftTerm.Value = null;
reasoningTask.ReasoningProcess.KnowledgeBase.RuleSet[1].Predicates[0].LeftTerm.Value = null;
reasoningTask.Sources = new List <IVariableSource>
{
new VariableSource
{
VariableIds = new List <string> {
"var1"
},
Request = new ReasoningRequest
{
Uri = "http://localhost:8080",
Method = ReasoningRequestMethod.GET
}
}
};
var reasoningTaskRepository = new Mock <IReasoningTaskRepository>();
reasoningTaskRepository.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(reasoningTask));
var reasoningService = new ReasoningService();
var service = MockReasoningTaskResolver(reasoningTaskRepository.Object, reasoningService);
var result = service.ProcessReasoningTask("testId").Result;
Assert.IsNotNull(result);
Assert.AreEqual(ReasoningTaskStatus.STOPPED, result.Status);
Assert.IsTrue(result.ReasoningProcess.ReasonedItems.Count == 0);
}
public void StartReasoning_Deduction()
{
var conclusion1 = new Models.Variable("conclusion1", "conclusion1", "Should pass");
var conclusion2 = new Models.Variable("conclusion2", "conclusion2", "Shouldn't pass");
var reasoningProcess = MockReasoningProcess(ReasoningMethod.Deduction, conclusion1, conclusion2);
var result = new ReasoningService().StartReasoning(reasoningProcess);
Assert.AreEqual(ReasoningState.STOPPED, result.State);
Assert.AreEqual(EvaluationMessage.MISSING_VALUES, result.EvaluationMessage);
Assert.IsTrue(result.ReasonedItems.Count == 0);
}
public void ContinueReasoning_Deduction_OneTrue()
{
var conclusion1 = new Models.Variable("conclusion1", "conclusion1", "Should pass");
var conclusion2 = new Models.Variable("conclusion2", "conclusion2", "Shouldn't pass");
var reasoningProcess = MockReasoningProcess(ReasoningMethod.Deduction, conclusion1, conclusion2);
var result = new ReasoningService().ContinueReasoning(reasoningProcess);
Assert.AreEqual(ReasoningState.FINISHED, result.State);
Assert.AreEqual(EvaluationMessage.PASSED, result.EvaluationMessage);
Assert.IsTrue(result.ReasonedItems.Count == 1);
Assert.AreEqual(conclusion1, result.ReasonedItems[0]);
}
public void ContinueReasoning_Hypothesis_FalseHypothesis()
{
var conclusion1 = new Models.Variable("conclusion1", "conclusion1", "Should pass");
var conclusion2 = new Models.Variable("conclusion2", "conclusion2", "Shouldn't pass");
var reasoningProcess = MockReasoningProcess(ReasoningMethod.HypothesisTesting, conclusion1, conclusion2);
reasoningProcess.Hypothesis = conclusion2;
var result = new ReasoningService().ContinueReasoning(reasoningProcess);
Assert.AreEqual(ReasoningState.FINISHED, result.State);
Assert.AreEqual(EvaluationMessage.FAILED, result.EvaluationMessage);
Assert.IsTrue(result.ReasonedItems.Count == 0);
}
public void ContinueReasoning_Deduction_NoTrue()
{
var conclusion1 = new Models.Variable("conclusion1", "conclusion1", "Should pass");
var conclusion2 = new Models.Variable("conclusion2", "conclusion2", "Shouldn't pass");
var reasoningProcess = MockReasoningProcess(ReasoningMethod.Deduction, conclusion1, conclusion2);
reasoningProcess.KnowledgeBase.RuleSet[0].Predicates[0].LeftTerm.Value = 17;
var result = new ReasoningService().ContinueReasoning(reasoningProcess);
Assert.AreEqual(ReasoningState.FINISHED, result.State);
Assert.AreEqual(EvaluationMessage.FAILED, result.EvaluationMessage);
Assert.IsTrue(result.ReasonedItems.Count == 0);
}
public void CreateTaskAsync_ExistingKB()
{
var kb = ReasoningMocks.GetKnowledgeBase();
var createResource = MockCreateResource();
var knowledgeBaseRepository = new Mock <IKnowledgeBaseRepository>();
knowledgeBaseRepository.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(kb));
var reasoningService = new ReasoningService();
var service = MockReasoningTaskService(null, knowledgeBaseRepository.Object, reasoningService);
var result = service.CreateTaskAsync(createResource).Result;
Assert.IsNotNull(result);
Assert.AreEqual(ReasoningTaskStatus.WAITING, result.Status);
}
public void ProcessReasoningTask_AllFacts()
{
var reasoningTask = ReasoningMocks.GetReasoningTask(ReasoningTaskStatus.WAITING);
var reasoningTaskRepository = new Mock <IReasoningTaskRepository>();
reasoningTaskRepository.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(reasoningTask));
var reasoningService = new ReasoningService();
var service = MockReasoningTaskResolver(reasoningTaskRepository.Object, reasoningService);
var result = service.ProcessReasoningTask("testId").Result;
Assert.IsNotNull(result);
Assert.AreEqual(ReasoningTaskStatus.FINISHED, result.Status);
Assert.IsTrue(result.ReasoningProcess.ReasonedItems.Count == 1);
}
public void ClearReasoning()
{
var conclusion1 = new Models.Variable("conclusion1", "conclusion1", "Should pass");
var conclusion2 = new Models.Variable("conclusion2", "conclusion2", "Shouldn't pass");
var reasoningProcess = MockReasoningProcess(ReasoningMethod.Deduction, conclusion1, conclusion2);
var result = new ReasoningService().ClearReasoning(reasoningProcess);
Assert.AreEqual(ReasoningState.INITIALIZED, result.State);
Assert.AreEqual(EvaluationMessage.NONE, result.EvaluationMessage);
Assert.IsTrue(result.ReasonedItems.Count == 0);
Assert.IsTrue(result.KnowledgeBase.RuleSet[0].Predicates[0].LeftTerm.IsEmpty());
Assert.IsTrue(result.KnowledgeBase.RuleSet[0].Predicates[1].LeftTerm.IsEmpty());
Assert.IsTrue(result.KnowledgeBase.RuleSet[0].Predicates[2].LeftTerm.IsEmpty());
Assert.IsTrue(result.KnowledgeBase.RuleSet[1].Predicates[0].LeftTerm.IsEmpty());
Assert.IsTrue(result.KnowledgeBase.RuleSet[1].Predicates[1].LeftTerm.IsEmpty());
Assert.IsTrue(result.KnowledgeBase.RuleSet[1].Predicates[2].LeftTerm.IsEmpty());
}
public void GetAllMissingVariableIds()
{
var conclusion1 = new Models.Variable("conclusion1", "conclusion1", "Should pass");
var conclusion2 = new Models.Variable("conclusion2", "conclusion2", "Shouldn't pass");
var service = new ReasoningService();
var reasoningProcess = MockReasoningProcess(ReasoningMethod.Deduction, conclusion1, conclusion2);
reasoningProcess = service.ClearReasoning(reasoningProcess);
var result = service.GetAllMissingVariableIds(reasoningProcess);
var enumerable = result.ToList();
Assert.IsTrue(enumerable.Count == 3);
Assert.AreEqual("var1", enumerable[0]);
Assert.AreEqual("var2", enumerable[1]);
Assert.AreEqual("var3", enumerable[2]);
}
public void SetVariablesAsync_ExistingTask()
{
var reasoningTask = ReasoningMocks.GetReasoningTask(ReasoningTaskStatus.STOPPED);
var variablesResource = new VariablesResource {
Variables = new List <IVariable>()
};
var reasoningTaskRepository = new Mock <IReasoningTaskRepository>();
reasoningTaskRepository.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(reasoningTask));
var reasoningService = new ReasoningService();
var service = MockReasoningTaskService(reasoningTaskRepository.Object, null, reasoningService);
var result = service.SetVariablesAsync("testId", variablesResource).Result;
Assert.IsNotNull(result);
Assert.IsTrue(result.MissingVariableIds.ToList().Count == 0);
}
public void ProcessReasoningTask_PartialFacts_APISendsRequestOnEnd()
{
var reasoningTask = ReasoningMocks.GetReasoningTask(ReasoningTaskStatus.WAITING);
reasoningTask.Actions = new List <IReasoningAction>
{
new ReasoningAction
{
ReasoningItems = new List <IVariable>
{
new Variable("conclusion1", 1)
},
ReasoningRequests = new List <IReasoningRequest>
{
new ReasoningRequest
{
Uri = "http://localhost:8080",
Method = ReasoningRequestMethod.POST
}
}
}
};
var httpClientService = new Mock <IHttpClientService>();
httpClientService.Setup(x => x.ExecuteTaskAsync(It.IsAny <IReasoningRequest>()))
.Returns(Task.CompletedTask);
var reasoningTaskRepository = new Mock <IReasoningTaskRepository>();
reasoningTaskRepository.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(reasoningTask));
var reasoningService = new ReasoningService();
var service = MockReasoningTaskResolver(reasoningTaskRepository.Object, reasoningService, null, httpClientService.Object);
var result = service.ProcessReasoningTask("testId").Result;
Assert.IsNotNull(result);
Assert.AreEqual(ReasoningTaskStatus.FINISHED, result.Status);
Assert.IsTrue(result.ReasoningProcess.ReasonedItems.Count == 1);
}
