private void Awake()
{
if (instance == null)
{
instance = this;
}
}
public async System.Threading.Tasks.Task GetAnswersForQuestion()
{
using var dbContext = this.GetDbContext();
using var unity = new UnitofWork(dbContext);
var guid = Guid.NewGuid();
dbContext.Questions.Add(new Models.Questions {
Id = guid, Question = "question1", Tags = "c#"
});
dbContext.Questions.Add(new Models.Questions {
Id = Guid.NewGuid(), Question = "question2", Tags = "asp"
});
dbContext.Questions.Add(new Models.Questions {
Id = Guid.NewGuid(), Question = "question3", Tags = "azure"
});
await dbContext.SaveChangesAsync();
dbContext.Answers.Add(new Models.Answers {
Id = Guid.NewGuid(), Answer = "answer1", QuestionID = guid
});
dbContext.Answers.Add(new Models.Answers {
Id = Guid.NewGuid(), Answer = "answer2", QuestionID = guid
});
dbContext.Answers.Add(new Models.Answers {
Id = Guid.NewGuid(), Answer = "answer3", QuestionID = guid
});
await dbContext.SaveChangesAsync();
var service = new AnswersController(unity);
var result = (IList <Models.Answers>) await service.GetAnswersByquestionAsync("question1");
Xunit.Assert.NotNull(result);
Xunit.Assert.Equal(3, result.Count);
}
public async Task Create_post_action_result_should_redirect_to_action_when_modelState_valid()
{
// Arrange
var answer = new Answer
{
QuestionId = 1,
AnswerId = 1,
AnswerText = "Test"
};
var httpContext = new DefaultHttpContext();
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var controller = new AnswersController(_answerRepository.Object)
{
TempData = tempData
};
// Act
var result = await controller.Create(answer);
// Assert
Assert.IsType <RedirectToActionResult>(result);
}
private async Task <JsonResult> ExecutePost(Models.TransferObjects.UpdateQuizAttemptStatusResult status)
{
const int attemptId = 5;
const int userId = 2;
var quizAttemptsManager = new Mock <IQuizAttemptManager>();
quizAttemptsManager.Setup(c => c.InsertAnswerAsync(userId, attemptId, It.IsAny <Models.TransferObjects.Answer>()))
.Returns <int, int, Models.TransferObjects.Answer>((u, a, answer) =>
Task.FromResult(status));
var controller = new AnswersController(quizAttemptsManager.Object);
controller.Token = new Models.TransferObjects.AuthToken
{
Token = "token",
UserId = userId,
ValidUntil = DateTime.Now.AddDays(1),
IsVerified = true
};
var result = await controller.Post(5,
new Models.TransferObjects.Answer
{
TimeSpent = 10,
QuestionId = 3,
Options = new List <int> {
8, 9
}
});
return(result);
}
public void AnswerControllerReturnsNotFound()
{
//initilize
Answer answer = new Answer {
Id = 1, AnswerText = "�עדמגמנ 1", Correct = 1, WrongText = ""
};
Answer answer2 = new Answer {
Id = 2, AnswerText = "�עדמגמנ 2", Correct = 0, WrongText = ""
};
Answer answer3 = new Answer {
Id = 3, AnswerText = "�עדמגמנ 3", Correct = 0, WrongText = ""
};
var data = new List <Answer> {
answer, answer2, answer3
}.AsQueryable();
var mockSet = new Mock <DbSet <Answer> >();
mockSet.As <IQueryable <Answer> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <Answer> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <Answer> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <Answer> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <Brainzzler_DBContext>();
mockContext.Setup(set => set.Answers).Returns(mockSet.Object);
//Act
var service = new AnswersController(mockContext.Object);
var answ = service.GetAnswer(4);
//Assert
Assert.AreEqual(null, answ.Value);
}
public AnswersControllerTest()
{
this.random = new Random();
this.expectedId = this.random.Next();
this.answerRepository = new Mock <IAnswerRepository>();
this.answersController = new AnswersController(this.answerRepository.Object);
}
public void Test_AnswersController_GetAnswerById_ReturnsQuestion()
{
AnswersController controller = new AnswersController(_context);
var result = controller.GetAnswer(_context.Answers.Select(x => x.Id).FirstOrDefault());
Assert.IsInstanceOf <Answer>(result.Result.Value);
}
public void Test_AnswersController_GetAnswers_ReturnsListOfAnswers()
{
AnswersController controller = new AnswersController(_context);
var result = controller.GetAnswers();
Assert.IsNotEmpty(result.Result.Value);
}
public void Test_AnswersController_DeleteQuestion()
{
AnswersController controller = new AnswersController(_context);
var questionForDelete = _context.Answers.FirstOrDefault();
var result = controller.DeleteAnswer(questionForDelete.Id).Result.Value;
Assert.AreEqual(questionForDelete, result);
}
public void TestGetUserToken()
{
var mockLogger = new Mock <ILogger <AnswersController> >();
var controller = new AnswersController(mockLogger.Object, productRepository, MapperConfiguration);
var result = controller.GetUserToken();
Assert.IsInstanceOfType(result, typeof(UserTokenResponse));
Assert.AreEqual(result.name, "Sajith Kumar");
Assert.AreEqual(result.token, "320dccaf-a669-458e-a45f-1375d7f95628");
}
public void Setup()
{
Mock <IStringLocalizer <SharedResource> > localizerMock = new Mock <IStringLocalizer <SharedResource> >();
Mock <ILogger> loggerMock = new Mock <ILogger>();
Mock <IConfiguration> configMock = new Mock <IConfiguration>();
//var service = new AnswersApiClient(loggerMock.Object, configMock.Object);
//Mock<AnswersApiClient> serviceMock = new Mock<AnswersApiClient>();
controller = new AnswersController(localizerMock.Object, null, null);
}
private static AnswersController GetAnswersController(
IRepository <Question> questionsRepository, IRepository <Answer> answersRepository)
{
var controller = new AnswersController(questionsRepository, answersRepository);
controller.ControllerContext = new ControllerContext
{
Controller = controller,
RequestContext = new RequestContext(new MockHttpContext(), new RouteData())
};
return(controller);
}
public void Test_AnswersController_PutAnswer()
{
AnswersController controller = new AnswersController(_context);
var answer = _context.Answers.FirstOrDefault();
var result = controller.PutAnswer(answer.Id, answer);
var changedQuestion = _context.Answers.Find(answer.Id);
//because of EF entity refs
Assert.AreEqual(answer, changedQuestion);
}
public void Test_AnswersController_PostAnswer()
{
AnswersController controller = new AnswersController(_context);
var result = controller.PostAnswer(new Answer()
{
Id = Guid.NewGuid(),
Question = _context.Questions.FirstOrDefault(),
Creator = _context.Users.FirstOrDefault(),
Body = "test"
});
Assert.IsInstanceOf <ActionResult <Answer> >(result.Result);
}
public void TestGetProducts_sortOption_High()
{
var mockLogger = new Mock <ILogger <AnswersController> >();
var controller = new AnswersController(mockLogger.Object, productRepository, MapperConfiguration);
var result = controller.GetProducts(BusinessLayer.Entities.SortOptions.High).Result;
Assert.IsInstanceOfType(result, typeof(ProductsResponse[]));
Assert.AreEqual(result.Length, 5);
Assert.AreEqual(result[0].price, 999999999999);
Assert.AreEqual(result[1].price, 101.99);
Assert.AreEqual(result[2].price, 99.99);
Assert.AreEqual(result[3].price, 10.99);
Assert.AreEqual(result[4].price, 5);
}
public async Task Delete_action_result_method_should_return_BadRequest_when_answer_id_is_null()
{
// Arrange
var controller = new AnswersController(_answerRepository.Object);
// Act
var result = await controller.Delete(null);
// Assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result);
var model = Assert.IsAssignableFrom <BadRequestObjectResult>(badRequestObjectResult);
Assert.Equal(model.StatusCode, badRequestObjectResult.StatusCode);
Assert.NotNull(result);
}
public void Create_action_should_return_BadRequest_when_questionId_is_not_valid()
{
// Arrange
var controller = new AnswersController(_answerRepository.Object);
// Act
var result = controller.Create(id: null);
// Assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result);
var model = Assert.IsAssignableFrom <BadRequestObjectResult>(badRequestObjectResult);
Assert.Equal(model.StatusCode, badRequestObjectResult.StatusCode);
Assert.NotNull(result);
}
public void TestGetProducts_sortOption_Ascending()
{
var mockLogger = new Mock <ILogger <AnswersController> >();
var controller = new AnswersController(mockLogger.Object, productRepository, MapperConfiguration);
var result = controller.GetProducts(BusinessLayer.Entities.SortOptions.Ascending).Result;
Assert.IsInstanceOfType(result, typeof(ProductsResponse[]));
Assert.AreEqual(result.Length, 5);
Assert.AreEqual(result[0].name, "Test Product A");
Assert.AreEqual(result[1].name, "Test Product B");
Assert.AreEqual(result[2].name, "Test Product C");
Assert.AreEqual(result[3].name, "Test Product D");
Assert.AreEqual(result[4].name, "Test Product F");
}
public async Task PostThrowsError()
{
var quizAttemptsManager = new Mock <IQuizAttemptManager>();
var controller = new AnswersController(quizAttemptsManager.Object);
var result = await controller.Post(5,
new Models.TransferObjects.Answer
{
TimeSpent = 10,
QuestionId = 3,
Options = new List <int> {
8, 9
}
});
Assert.IsNotNull(result);
}
public AnswersControllerTests()
{
_fixture = new Fixture();
var userProfileOption = new Mock <IOptions <UserProfile> >();
_productService = new Mock <IProductService>();
_trolleyService = new Mock <ITrolleyService>();
userProfileOption.Setup(x => x.Value)
.Returns(_fixture.Create <UserProfile>());
_target = new AnswersController(
userProfileOption.Object,
_productService.Object,
_trolleyService.Object);
}
public void Create_action_should_return_Create_View_with_correct_model()
{
// Arrange
var questionId = 1;
var answersForQuestion = _testData.GetTestAnswers().Where(q => q.QuestionId == questionId);
_answerRepository.Setup(repo => repo.GetByQuestionId(questionId)).ReturnsAsync(answersForQuestion.ToList);
var controller = new AnswersController(_answerRepository.Object);
// act
var result = controller.Create(questionId);
// assert
Assert.IsType <ViewResult>(result);
Assert.NotNull(result);
}
public async Task Edit_post_action_result_should_return_ViewResult_with_correct_Model_type_when_modelState_not_valid()
{
// Arrange
var answer = new Answer()
{
AnswerId = 20,
};
// Arrange
var controller = new AnswersController(_answerRepository.Object);
controller.ModelState.AddModelError("Title", "Title is required");
// Act
var result = await controller.Edit(answer.AnswerId, answer);
// Assert
Assert.IsType <ViewResult>(result);
}
public async Task Delete_action_result_method_should_return_NotFound_when_no_quiz_found_for_id()
{
// Arrange
var id = 0;
var expecteAnswer = _testData.GetTestAnswers().FirstOrDefault(q => q.AnswerId == id);
_answerRepository.Setup(repo => repo.GetByAnswerId(id)).ReturnsAsync(expecteAnswer);
var controller = new AnswersController(_answerRepository.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 Delete_action_result_method_should_return_ViewResult_with_correct_Model_type()
{
// Arrange
var id = 1;
var expectedAnswer = _testData.GetTestAnswers().FirstOrDefault(q => q.AnswerId == id);
_answerRepository.Setup(repo => repo.GetByAnswerId(id)).ReturnsAsync(expectedAnswer);
var controller = new AnswersController(_answerRepository.Object);
// Act
var result = await controller.Delete(id);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <Answer>(viewResult.ViewData.Model);
Assert.NotNull(result);
}
public async Task Create_post_action_result_should_return_ViewResult_with_correct_Model_type_when_modelState_not_valid()
{
// Arrange
var answer = new Answer
{
AnswerId = 20,
};
// Arrange
var controller = new AnswersController(_answerRepository.Object);
controller.ModelState.AddModelError("Title", "Title is required");
// Act
var result = await controller.Create(answer);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <Answer>(viewResult.ViewData.Model);
}
public async Task Edit_post_action_result_should_redirect_to_action_when_modelState_valid()
{
var id = 1;
var answer = _testData.GetTestAnswers().FirstOrDefault(q => q.AnswerId == id);
_answerRepository.Setup(repo => repo.GetByAnswerId(id)).ReturnsAsync(answer);
var httpContext = new DefaultHttpContext();
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var controller = new AnswersController(_answerRepository.Object)
{
TempData = tempData
};
// Act
var result = await controller.Edit(answer.AnswerId, answer);
// Assert
Assert.IsType <RedirectToActionResult>(result);
}
public async Task CreateAnswerAsync_ValidQuestionIdPassed_ReturnsCreatedAtRouteResult()
{
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, "1"),
}));
var exam = new Exam()
{
AuthorId = 1
};
var question = new Question()
{
Exam = exam
};
var mapperMock = new Mock <IMapper>();
var repositoryMock = new Mock <IRepositoryWrapper>();
repositoryMock.Setup(r => r.QuestionRepository.GetQuestionAsync(It.IsAny <int>())).ReturnsAsync(question);
repositoryMock.Setup(r => r.AnswerRepository.Add(It.IsAny <Answer>()));
repositoryMock.Setup(r => r.SaveAllAsync()).ReturnsAsync(true);
mapperMock.Setup(m => m.Map <Answer>(It.IsAny <AnswerForCreationDto>())).Returns(new Answer());
mapperMock.Setup(m => m.Map <AnswerForReturnDto>(It.IsAny <Answer>())).Returns(new AnswerForReturnDto());
var controllerMock = new AnswersController(repositoryMock.Object, mapperMock.Object);
controllerMock.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
var result = await controllerMock.CreateAnswerAsync(1, new AnswerForCreationDto());
Assert.IsType <CreatedAtRouteResult>(result);
}
public async Task GetAnswersAsync_ValidQuestionIdPassed_ReturnsOkObjectResult()
{
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, "1"),
}));
var mapperMock = new Mock <IMapper>();
var repositoryMock = new Mock <IRepositoryWrapper>();
repositoryMock.Setup(r => r.AnswerRepository.GetAnswersAsync(It.IsAny <int>())).ReturnsAsync(new List <Answer>());
mapperMock.Setup(m => m.Map <IEnumerable <AnswerForReturnDto> >(It.IsAny <IEnumerable <Answer> >())).Returns(new List <AnswerForReturnDto>());
var controllerMock = new AnswersController(repositoryMock.Object, mapperMock.Object);
controllerMock.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
var result = await controllerMock.GetAnswersAsync(1);
Assert.IsType <OkObjectResult>(result);
}
public async Task Edit_post_action_result_method_should_return_BadRequest_when_id_received_different_to_answerId()
{
// Arrange
var id = 0;
var answer = new Answer()
{
AnswerId = 1,
AnswerText = "Test"
};
_answerRepository.Setup(repo => repo.GetByAnswerId(id)).ReturnsAsync(answer);
var controller = new AnswersController(_answerRepository.Object);
// Act
var result = await controller.Edit(id, answer);
// Assert
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result);
var model = Assert.IsAssignableFrom <BadRequestObjectResult>(badRequestObjectResult);
Assert.Equal(model.StatusCode, badRequestObjectResult.StatusCode);
Assert.NotNull(result);
}
public AnswersControllerTests()
{
_productsService = Substitute.For <IProductsService>();
_userService = Substitute.For <IUserService>();
_answersController = new AnswersController(_productsService, _userService);
}
