public async Task Edit_action_result_method_should_return_ViewResult_with_correct_Model_type()
{
// Arrange
var id = 1;
var expectedQuiz = _testData.GetTestQuizzes().FirstOrDefault(q => q.QuizId == id);
_quizRepository.Setup(repo => repo.GetById(id)).ReturnsAsync(expectedQuiz);
var expectedQuestions = _testData.GetTestQuestions().Where(q => q.QuizId == id);
_questionRepository.Setup(repo => repo.GetByQuizId(id)).ReturnsAsync(expectedQuestions);
var controller = new QuizzesController(_quizRepository.Object, _questionRepository.Object);
// Act
var result = await controller.Edit(id);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <EditQuizViewModel>(viewResult.ViewData.Model);
Assert.NotNull(result);
Assert.Equal(expectedQuiz.QuizId, model.Quiz.QuizId);
Assert.Equal(2, model.Questions.Count());
}
public async Task Get()
{
const int userId = 56;
var quizzes = new List <Quiz>
{
new Quiz(),
new Quiz()
};
var quizManager = new Mock <IQuizManager>();
quizManager.Setup(c => c.GetAdminQuizList(userId))
.Returns(Task.FromResult(quizzes));
var sut = new QuizzesController(quizManager.Object);
sut.Token = new AuthToken
{
Token = "token",
UserId = userId,
ValidUntil = DateTime.Now.AddDays(1),
IsVerified = true
};
var result = await sut.Get();
Assert.AreEqual(quizzes.Count, result.ToList().Count);
}
public async Task Posting_quizzes_should_save_to_database()
{
using var context = CreateContextWithData();
var quizzesController = new QuizzesController(context);
var actionResult = await quizzesController.PostQuizAsync(testData.GetDefaultBackendQuiz());
Assert.AreEqual(201, (actionResult.Result as CreatedAtActionResult)?.StatusCode);
await context.Database.EnsureDeletedAsync();
}
public async Task Get_quiz_with_nonexistant_id_should_return_expected_result()
{
using var context = CreateContextWithData();
var quizzesController = new QuizzesController(context);
var quizzes = await quizzesController.GetQuizAsync(2);
Assert.AreEqual(404, (quizzes.Result as NotFoundResult)?.StatusCode);
await context.Database.EnsureDeletedAsync();
}
public async Task Get_random_quiz_Should_return_expected_result_If_no_quiz_exists()
{
using var context = CreateContextWithData();
var quizzesController = new QuizzesController(context);
var quizzes = await quizzesController.GetRandomQuizAsync();
Assert.AreEqual(404, (quizzes.Result as NotFoundResult).StatusCode);
await context.Database.EnsureDeletedAsync();
}
public void SetUp()
{
var options = new DbContextOptionsBuilder <QuizManagerContext>()
.UseInMemoryDatabase(databaseName: "QuizzesControllerTests")
.Options;
_quizManagerContext = new QuizManagerContext(options);
_quizzesController = new QuizzesController(_quizManagerContext);
}
public async Task Get_random_quiz_Should_return_expected_result()
{
var quiz = testData.GetDefaultBackendQuizzes(1);
using var context = CreateContextWithData(quiz);
var quizzesController = new QuizzesController(context);
var quizzes = await quizzesController.GetRandomQuizAsync();
Assert.AreEqual(1, quizzes.Value.Id);
await context.Database.EnsureDeletedAsync();
}
public async Task Get_quiz_with_id_should_return_the_specified_quiz_from_database()
{
var quiz = testData.GetDefaultBackendQuizzes(2);
using var context = CreateContextWithData(quiz);
var quizzesController = new QuizzesController(context);
var quizzes = await quizzesController.GetQuizAsync(2);
Assert.AreEqual(2, quizzes.Value.Id);
await context.Database.EnsureDeletedAsync();
}
public void Create_action_should_return_Create_View_with_correct_model()
{
// Arrange
var controller = new QuizzesController(_quizRepository.Object, _questionRepository.Object);
// act
var result = controller.Create();
// assert
Assert.IsType <ViewResult>(result);
Assert.NotNull(result);
}
public QuizzesController CreateQuizzesController()
{
var c = new QuizzesController(
_mockRepo.AnswerService,
_mockRepo.QuestionService,
_mockRepo.QuizCategoryService,
_mockRepo.QuizRatingRepo,
_mockRepo.QuizResultService,
_mockRepo.QuizService);
return(c);
}
public async Task Quiz_returned_by_details_view_has_all_associated_questions()
{
using (var context = new ApplicationDbContext(_dbContextOptions))
{
var sut = new QuizzesController(context);
var actionResult = await sut.Details(1);
var viewResult = actionResult as ViewResult;
var quiz = viewResult.Model as Quiz;
quiz.Questions.Count.Should().Be(QuestionsPerQuiz);
}
}
public async Task Delete_quiz_should_return_expected_result()
{
var quiz = testData.GetDefaultBackendQuizzes(2);
using var context = CreateContextWithData(quiz);
var quizzesController = new QuizzesController(context);
var actualSuccess = await quizzesController.DeleteQuizAsync(2);
var actualFail = await quizzesController.DeleteQuizAsync(2);
Assert.AreEqual(204, (actualSuccess as NoContentResult)?.StatusCode);
Assert.AreEqual(404, (actualFail as NotFoundResult)?.StatusCode);
await context.Database.EnsureDeletedAsync();
}
public async Task Index_returns_view_result_with_two_quizVM_objects()
{
using (var context = new ApplicationDbContext(_dbContextOptions))
{
var sut = new QuizzesController(context);
var actionResult = await sut.Index();
var viewResult = (ViewResult)actionResult;
var quizList = viewResult.Model as List <Quiz>;
quizList.Count.Should().Be(2);
}
}
public async Task Questions_returned_with_quiz_all_have_correct_quiz_id()
{
using (var context = new ApplicationDbContext(_dbContextOptions))
{
var sut = new QuizzesController(context);
var actionResult = await sut.Details(1);
var viewResult = actionResult as ViewResult;
var quiz = viewResult.Model as Quiz;
quiz.Questions.Should().OnlyContain(question => question.QuizId == quiz.QuizId);
}
}
public QuizzesController CreateQuizzesController()
{
var c = new QuizzesController(
_mockRepo.AnswerService,
_mockRepo.QuestionService,
_mockRepo.QuizCategoryService,
_mockRepo.QuizService,
_mockRepo.UserActivityService,
_mockRepo.ModelConverter,
_mockRepo.ViewModelConverter);
MockUser(c);
return(c);
}
public async Task Get_quiz_should_return_a_list_from_database()
{
var quiz = new List <Quiz>()
{
testData.GetDefaultBackendQuiz(),
testData.GetDefaultBackendQuiz()
};
using var context = CreateContextWithData(quiz);
var quizzesController = new QuizzesController(context);
var quizzes = await quizzesController.GetQuizAsync();
Assert.AreEqual(2, (quizzes.Value as List <Quiz>)?.Count);
await context.Database.EnsureDeletedAsync();
}
public async Task Details_action_result_method_should_return_BadRequest_when_quiz_id_is_null()
{
// Arrange
var controller = new QuizzesController(_quizRepository.Object, _questionRepository.Object);
// Act
var result = await controller.Details(null);
// Assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result);
var model = Assert.IsAssignableFrom <BadRequestObjectResult>(badRequestObjectResult);
Assert.Equal(model.StatusCode, badRequestObjectResult.StatusCode);
Assert.NotNull(result);
}
public async Task DeleteThrowsException()
{
const int userId = 56;
const int quizId = 56;
var quizManager = new Mock <IQuizManager>();
quizManager.Setup(c => c.DeleteQuiz(userId, quizId))
.Returns(Task.FromResult(true));
var sut = new QuizzesController(quizManager.Object);
var result = await sut.Delete(quizId);
Assert.AreEqual(HttpStatusCode.OK, (HttpStatusCode)result.StatusCode);
}
public async Task Index_action_result_get_method_should_return_ViewResult_with_correct_Model_type()
{
// Arrange
_quizRepository.Setup(repo => repo.GetAll()).ReturnsAsync(_testData.GetTestQuizzes);
var controller = new QuizzesController(_quizRepository.Object, _questionRepository.Object);
// Act
var result = await controller.Index();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <Quiz> >(viewResult.ViewData.Model);
Assert.Equal(2, model.Count());
}
public async Task Details_returns_view_result_with_correct_quiz()
{
using (var context = new ApplicationDbContext(_dbContextOptions))
{
var sut = new QuizzesController(context);
var actionResult = await sut.Details(1);
actionResult.Should().BeOfType(typeof(ViewResult));
var viewResult = actionResult as ViewResult;
var quiz = viewResult.Model as Quiz;
quiz.QuizId.Should().Be(1);
}
}
public async Task Questions_returned_with_quiz_have_all_associated_answers()
{
using (var context = new ApplicationDbContext(_dbContextOptions))
{
var sut = new QuizzesController(context);
var actionResult = await sut.Details(1);
var viewResult = actionResult as ViewResult;
var quiz = viewResult.Model as Quiz;
var questions = quiz.Questions;
foreach (var question in questions)
{
question.AnswerOptions.Count.Should().Be(AnswersPerQuestion);
question.AnswerOptions.Should().OnlyContain(answer => answer.QuestionId == question.QuestionId);
}
}
}
public async Task Index_action_result_method_should_return_an_empty_list_when_there_are_no_quizzes()
{
// Arrange
var emptyList = new List <Quiz>();
_quizRepository.Setup(repo => repo.GetAll()).ReturnsAsync(emptyList);
var controller = new QuizzesController(_quizRepository.Object, _questionRepository.Object);
// Act
var result = await controller.Index();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <IEnumerable <Quiz> >(viewResult.ViewData.Model);
}
public async Task Edit_post_action_result_should_return_ViewResult_with_correct_Model_type_when_modelState_not_valid()
{
// Arrange
var quiz = new Quiz
{
QuizId = 3
};
// Arrange
var controller = new QuizzesController(_quizRepository.Object, _questionRepository.Object);
controller.ModelState.AddModelError("Title", "Title is required");
// Act
var result = await controller.Edit(quiz.QuizId, quiz);
// Assert
Assert.IsType <ViewResult>(result);
}
public async Task DeleteConfirmed_post_action_result_should_redirect_to_action_when_modelState_valid()
{
var id = 1;
var httpContext = new DefaultHttpContext();
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var controller = new QuizzesController(_quizRepository.Object, _questionRepository.Object)
{
TempData = tempData
};
// Act
var result = await controller.DeleteConfirmed(id);
// Assert
Assert.IsType <RedirectToActionResult>(result);
}
public async Task Updating_a_quiz_should_return_expected_result()
{
var quiz = testData.GetDefaultBackendQuizzes(2);
using var context = CreateContextWithData(quiz);
var quizzesController = new QuizzesController(context);
quiz[1].Questions[0].Text = "How many Trumpets does it take to blow the vote blue in USA?";
var quizzes = await quizzesController.PutQuizAsync(2, quiz[1]);
var badResultQuizzes = await quizzesController.PutQuizAsync(3, quiz[1]);
var notFoundQuizzes = await quizzesController.PutQuizAsync(12, quiz[1]);
Assert.AreEqual(204, (quizzes as NoContentResult)?.StatusCode);
Assert.AreEqual(400, (badResultQuizzes as BadRequestResult)?.StatusCode);
// We would like to test DBUpdateConcurrencyException but cannot find a feasable way to test this within scope of this assignment (need to install separate testing framework)
await context.Database.EnsureDeletedAsync();
}
public async Task PutInsertThrowsException()
{
const int userId = 56;
var response = new SaveQuizResult
{
Result = 5,
Status = SaveQuizResultStatus.Success
};
var quizManager = new Mock <IQuizManager>();
quizManager.Setup(c => c.InsertQuiz(userId, It.IsAny <Quiz>()))
.Returns(Task.FromResult(response));
var sut = new QuizzesController(quizManager.Object);
var result = await sut.PutInsertQuiz(new Quiz());
Assert.AreEqual(HttpStatusCode.OK, (HttpStatusCode)result.StatusCode);
}
public async Task Delete_action_result_method_should_return_NotFound_when_no_quiz_found_for_id()
{
// Arrange
var id = 0;
var expectedQuiz = _testData.GetTestQuizzes().FirstOrDefault(q => q.QuizId == id);
_quizRepository.Setup(repo => repo.GetById(id)).ReturnsAsync(expectedQuiz);
var controller = new QuizzesController(_quizRepository.Object, _questionRepository.Object);
// Act
var result = await controller.Delete(id);
// Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
var model = Assert.IsAssignableFrom <NotFoundObjectResult>(notFoundObjectResult);
Assert.Equal(model.StatusCode, notFoundObjectResult.StatusCode);
Assert.Equal(model.Value, notFoundObjectResult.Value);
Assert.NotNull(result);
}
public async Task GetThrowsException()
{
const int userId = 56;
var quizzes = new List <Quiz>
{
new Quiz(),
new Quiz()
};
var quizManager = new Mock <IQuizManager>();
quizManager.Setup(c => c.GetAdminQuizList(userId))
.Returns(Task.FromResult(quizzes));
var sut = new QuizzesController(quizManager.Object);
var result = await sut.Get();
Assert.AreEqual(quizzes.Count, result.ToList().Count);
}
public async Task Create_post_action_result_should_return_ViewResult_with_correct_Model_type_when_modelState_not_valid()
{
// Arrange
var quiz = new Quiz
{
QuizId = 3
};
// Arrange
var controller = new QuizzesController(_quizRepository.Object, _questionRepository.Object);
controller.ModelState.AddModelError("Title", "Title is required");
// Act
var result = await controller.Create(quiz);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <Quiz>(viewResult.ViewData.Model);
}
public async Task PostUpdate(int saveResult, SaveQuizResultStatus status, HttpStatusCode expectedResponse)
{
const int userId = 56;
const int quizId = 154;
var quiz = new Quiz
{
Id = quizId,
Title = "Test",
Intro = "Intro"
};
var response = new SaveQuizResult
{
Result = saveResult,
Status = status
};
var quizManager = new Mock <IQuizManager>();
quizManager
.Setup(c => c.UpdateQuiz(userId, quizId, quiz))
.Returns(Task.FromResult(response));
var sut = new QuizzesController(quizManager.Object);
sut.Token = new AuthToken
{
Token = "token",
UserId = userId,
ValidUntil = DateTime.Now.AddDays(1),
IsVerified = true
};
var result = await sut.PostUpdateQuiz(quizId, quiz);
Assert.AreEqual(expectedResponse, (HttpStatusCode)result.StatusCode);
Assert.IsTrue((HttpStatusCode)result.StatusCode != HttpStatusCode.OK || ((GenericWrapper <int>)result.Value).Value == saveResult);
}
