public async Task Get_CorrectIdGiven_ReturnsJsonViewModel()
{
var queryResult = _fixture.Create <GetResultQueryResult>();
var resultId = _fixture.Create <int>();
_queryDispatcherMock.Setup(x =>
x.DispatchAsync <GetResultQuery, GetResultQueryResult>(It.IsAny <GetResultQuery>()))
.Returns(Task.FromResult(queryResult));
var result = await _controller.Get(resultId) as JsonResult;
Assert.IsNotNull(result);
Assert.AreEqual(result.GetObjectFromJsonResult <ResultViewModel>().Text, queryResult.Result.Text);
Assert.AreEqual(result.GetObjectFromJsonResult <ResultViewModel>().Id, queryResult.Result.Id);
}
public void GetReturnsSearchResults()
{
_context.Setup(m => m.SearchResults).Returns(new List <SearchResult> {
GetSearchResult(), GetSearchResult2()
});
_context.Setup(m => m.GetSearchResults())
.Returns(new List <SearchResult> {
GetSearchResult(), GetSearchResult2()
});
var response = controller.Get();
Assert.IsFalse(response.StatusCode == HttpStatusCode.NotFound);
IEnumerable <SearchResult> searchResults;
Assert.IsTrue(response.TryGetContentValue <IEnumerable <SearchResult> >(out searchResults));
Assert.AreEqual(2, searchResults.Count());
}
public void Get_WhenCorrectIdGiven_ShouldReturnJsonViewModel()
{
var resultId = 1;
var resultModel = new Result
{
Id = resultId,
Text = "Text1"
};
_mockRepo.Setup(x => x.GetResult(resultId)).Returns(Task.FromResult(resultModel));
var result = _sut.Get(resultId).Result as JsonResult;
Assert.IsNotNull(result);
var viewModel = result.GetObjectFromJsonResult <ResultViewModel>();
Assert.AreEqual(viewModel.Text, resultModel.Text);
Assert.AreEqual(viewModel.Id, resultModel.Id);
}
public void Test2()
{
ResultController rCtrl = new ResultController();
JObject exp = JObject.FromObject(new { expression = "1 + 2 + 3 + 4 + 12 + 34" });
IActionResult ArRes = rCtrl.Get(exp);
Assert.NotNull(ArRes);
OkObjectResult okObj = ArRes as OkObjectResult;
JObject resultat = JObject.FromObject(okObj.Value);
Assert.AreEqual(56, resultat.GetValue("result").ToObject <int>());
}
public void GetTest()
{
//Arrange
var test = new TestIdFree
{
Name = "Results2Test",
Cron = "1 1 1 1 1"
};
var result = new ResultIdFree {
Date = DateTime.Now,
Test = test.Name,
PassFail = false,
RemediationSucceeded = false,
StatusMessage = "Failed to even run twice"
};
//...
//Act
var resultController = new ResultController(
_loggerMock.Object
);
var testController = new TestController(
new Mock <ILogger <TestController> >().Object
);
resultController.ControllerContext.HttpContext = _contextMock.Object;
testController.ControllerContext.HttpContext = _contextMock.Object;
testController.Post(test.Name, new Tests {
Name = test.Name, Cron = test.Cron
});
var actionResult = resultController.Post(test.Name, result);
var actualResult = resultController.Get(test.Name);
//Assert
var viewResult = Assert.IsType <Result <ResultIdFree> >(actualResult);
Assert.True(viewResult.status == "ok", "Test was not ok!");
Assert.True(viewResult.results.First().Test == test.Name, "Wrong name: " + viewResult.results.First().Test);
Assert.True(viewResult.results.Count == 1, "Wrong Length " + viewResult.results.Count);
}
public long Import(string DatabaseImportPath)
{
// Copy data from Export Database to Current Database.
using (Database DBRestore = new Database(DatabaseImportPath))
{
// Checking if there are same Users.
List <UserModelDataTransferObject> RestoreUsers, CurrentUsers;
using (UserController UserController = new UserController(DatabaseImportPath))
RestoreUsers = UserController.GetUsers().OrderBy(u => u.UserID).ToList();
using (UserController UserController = new UserController())
CurrentUsers = UserController.GetUsers().OrderBy(u => u.UserID).ToList();
if (CurrentUsers.Count != RestoreUsers.Count)
{
throw new Exception("Selected database does not have the same Users.");
}
for (int UserIndex = 0; UserIndex <= RestoreUsers.Count - 1; ++UserIndex)
{
if (CurrentUsers[UserIndex] != RestoreUsers[UserIndex])
{
throw new Exception("Selected database does not have the same Users.");
}
}
// Check if there are the same Questions
List <Question> RestoreQuestions, CurrentQuestions;
using (QuestionController QuestionControllerRestore = new QuestionController(DatabaseImportPath))
RestoreQuestions = QuestionControllerRestore.GetAll();
using (QuestionController QuestionControllerCurrent = new QuestionController())
CurrentQuestions = QuestionControllerCurrent.GetAll();
if (CurrentQuestions.Count != RestoreQuestions.Count)
{
throw new Exception("Selected database does not have the same Questions.");
}
foreach (Question CurrentQuestion in CurrentQuestions)
{
if (!RestoreQuestions.Any(q => q.QuestionID == CurrentQuestion.QuestionID &&
q.Question1 == CurrentQuestion.Question1))
{
throw new Exception("Selected database does not have the same Questions.");
}
}
// Check if there are the same Surveys
List <Survey> RestoreSurveys, CurrentSurveys;
using (SurveyController SurveyControllerRestore = new SurveyController(DatabaseImportPath))
RestoreSurveys = SurveyControllerRestore.GetAll();
using (SurveyController SurveyControllerCurrent = new SurveyController())
CurrentSurveys = SurveyControllerCurrent.GetAll();
if (CurrentSurveys.Count != RestoreSurveys.Count)
{
throw new Exception("Selected database does not have the same Surveys.");
}
foreach (Survey CurrentSurvey in CurrentSurveys)
{
if (!RestoreSurveys.Any(s => s.SurveyID == CurrentSurvey.SurveyID &&
s.SurveyName == CurrentSurvey.SurveyName))
{
throw new Exception("Selected database does not have the same Surveys.");
}
}
// Check if there are the same Survey Definitions
List <SurveyDefinition> RestoreSurveyDefinitions, CurrentSurveyDefinitions;
using (SurveyDefinitionController AttitudeDefinitionControllerRestore = new SurveyDefinitionController(DatabaseImportPath))
RestoreSurveyDefinitions = AttitudeDefinitionControllerRestore.Get();
using (SurveyDefinitionController AttitudeDefinitionControllerCurrent = new SurveyDefinitionController())
CurrentSurveyDefinitions = AttitudeDefinitionControllerCurrent.Get();
if (CurrentSurveyDefinitions.Count != RestoreSurveyDefinitions.Count)
{
throw new Exception("Selected database does not have the same Survey Definitions.");
}
foreach (SurveyDefinition CurrentSurveyDefinition in CurrentSurveyDefinitions)
{
if (!RestoreSurveyDefinitions.Any(sd => sd.SurveyDefinitionID == CurrentSurveyDefinition.SurveyDefinitionID &&
sd.QuestionID == CurrentSurveyDefinition.QuestionID &&
sd.SurveyID == CurrentSurveyDefinition.SurveyID))
{
throw new Exception("Selected database does not have the same Survey Definitions.");
}
}
// Check if there are the same Attitudes
List <Attitude> RestoreAttitudes, CurrentAttitudes;
using (AttitudeController AttitudeControllerRestore = new AttitudeController(DatabaseImportPath))
RestoreAttitudes = AttitudeControllerRestore.GetAttitudes();
using (AttitudeController AttitudeControllerCurrent = new AttitudeController())
CurrentAttitudes = AttitudeControllerCurrent.GetAttitudes();
if (CurrentAttitudes.Count != RestoreAttitudes.Count)
{
throw new Exception("Selected database does not have the same Attitudes.");
}
foreach (Attitude CurrentAttitude in CurrentAttitudes)
{
if (!RestoreAttitudes.Any(a => a.AttitudeID == CurrentAttitude.AttitudeID &&
a.AttitudeName == CurrentAttitude.AttitudeName))
{
throw new Exception("Selected database does not have the same Attitudes.");
}
}
// Check if there are the same Attitudes Definitions
List <AttitudeDefinition> RestoreAttitudeDefinitions, CurrentAttitudeDefinitions;
using (AttitudeDefinitionController AttitudeDefinitionControllerRestore = new AttitudeDefinitionController(DatabaseImportPath))
RestoreAttitudeDefinitions = AttitudeDefinitionControllerRestore.Get();
using (AttitudeDefinitionController AttitudeDefinitionControllerCurrent = new AttitudeDefinitionController())
CurrentAttitudeDefinitions = AttitudeDefinitionControllerCurrent.Get();
if (CurrentAttitudeDefinitions.Count != RestoreAttitudeDefinitions.Count)
{
throw new Exception("Selected database does not have the same Attitude Definitions.");
}
foreach (AttitudeDefinition CurrentAttitudeDefinition in CurrentAttitudeDefinitions)
{
if (!RestoreAttitudeDefinitions.Any(ad => ad.AttitudeDefinitionID == CurrentAttitudeDefinition.AttitudeDefinitionID &&
ad.AttitudeID == CurrentAttitudeDefinition.AttitudeID &&
ad.QuestionID == CurrentAttitudeDefinition.QuestionID))
{
throw new Exception("Selected database does not have the same Attitude Definitions.");
}
}
// Actually import new data from Result Table
long ImportedResultCount = 0;
using (ResultController resultControllerRestore = new ResultController(DatabaseImportPath))
using (ResultController resultControllerCurrent = new ResultController())
{
List <Result> RestoreResults = resultControllerRestore.Get();
List <Result> CurrentResults = resultControllerCurrent.Get();
foreach (Result RestoreResult in RestoreResults)
{
if (!CurrentResults.Any(r => r.SurveyID == RestoreResult.SurveyID &&
r.Date == RestoreResult.Date &&
r.UserID == RestoreResult.UserID))
{
// Add to result table
long OldResultID = RestoreResult.ResultID;
resultControllerCurrent.Add(RestoreResult); // ID may change during adding.
long NewResultID = RestoreResult.ResultID;
++ImportedResultCount;
// Get all Result definitions
using (ResultDefinitionController resultDefinitionControllerRestore = new ResultDefinitionController(DatabaseImportPath))
using (ResultDefinitionController resultDefinitionControllerCurrent = new ResultDefinitionController())
{
List <ResultDefinition> RestoreResultDefinitions = resultDefinitionControllerRestore.Get(OldResultID);
RestoreResultDefinitions.ForEach(rd => rd.ResultID = NewResultID); // Update with new ResultID
resultDefinitionControllerCurrent.Add(RestoreResultDefinitions);
}
}
}
}
return(ImportedResultCount);
}
}
