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 Post_ExistingKB()
{
var knowledgeBaseService = new Mock <IKnowledgeBaseService>();
var controller = new KnowledgeBaseController(knowledgeBaseService.Object);
var result = controller.Post(GetKnowledgeBaseResource(ReasoningMocks.GetKnowledgeBase())).Result;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(ConflictResult));
}
public void Put_MissingKB()
{
var knowledgeBaseService = new Mock <IKnowledgeBaseService>();
var controller = new KnowledgeBaseController(knowledgeBaseService.Object);
var result = controller.Put("testId", GetKnowledgeBaseResource(ReasoningMocks.GetKnowledgeBase())).Result;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public void CancelTaskAsync_ExistingTask()
{
var reasoningTask = ReasoningMocks.GetReasoningTask(ReasoningTaskStatus.WAITING);
var reasoningTaskRepository = new Mock <IReasoningTaskRepository>();
reasoningTaskRepository.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(reasoningTask));
var service = MockReasoningTaskService(reasoningTaskRepository.Object);
var result = service.CancelTaskAsync("testId").Result;
Assert.IsNotNull(result);
Assert.AreEqual(ReasoningTaskStatus.CANCELLED, result.Status);
}
public void GetById_GetExistingKB()
{
var knowledgeBaseService = new Mock <IKnowledgeBaseService>();
knowledgeBaseService.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(GetKnowledgeBaseResource(ReasoningMocks.GetKnowledgeBase())));
var controller = new KnowledgeBaseController(knowledgeBaseService.Object);
var result = controller.Get("testId").Result as OkObjectResult;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.IsNotNull(result.Value);
Assert.IsInstanceOfType(result.Value, typeof(KnowledgeBaseResource));
Assert.IsNotNull(((KnowledgeBaseResource)result.Value).KnowledgeBase);
}
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 Post_NewKB()
{
var knowledgeBaseResource = GetKnowledgeBaseResource(ReasoningMocks.GetKnowledgeBase());
var knowledgeBaseService = new Mock <IKnowledgeBaseService>();
knowledgeBaseService.Setup(x => x.CreateAsync(It.IsAny <IKnowledgeBase>()))
.Returns(Task.FromResult(knowledgeBaseResource));
var controller = new KnowledgeBaseController(knowledgeBaseService.Object);
var result = controller.Post(knowledgeBaseResource).Result as CreatedResult;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(CreatedResult));
Assert.IsNotNull(result.Value);
Assert.IsInstanceOfType(result.Value, typeof(IKnowledgeBase));
}
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 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);
}
