private QuestionsController CreateQuestionsController()
{
// common setups
this.mockOptions.Setup(r => r.Value).Returns(new PagingOptions()
{
Limit = 2, Offset = 2
});
var controllerObj = new QuestionsController(
this.mockQuestionBusiness.Object,
this.mockUserBusiness.Object,
this.mockOptions.Object);
//this.mockRepository.Create<ControllerContext>();
controllerObj.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "Admin123")
}, "someAuthTypeName"))
}
};
return(controllerObj);
}
public async void GetQuestion_WhenQuestionIsFound_ReturnsQuestion()
{
var mockQuestion = new QuestionGetSingleResponse
{
QuestionId = 1,
Title = "test"
};
var mockQuestionCache = new Mock <IQuestionCache>();
mockQuestionCache
.Setup(cache => cache.Get(1))
.Returns(() => null);
var mockDataRepo = new Mock <IDataRepository>();
mockDataRepo
.Setup(repo => repo.GetQuestion(1))
.Returns(() => Task.FromResult(mockQuestion));
var mockConfig = new Mock <IConfigurationRoot>();
mockConfig
.SetupGet(config => config[It.IsAny <string>()])
.Returns("String");
var questionsController = new QuestionsController(
mockDataRepo.Object,
null, mockQuestionCache.Object, null);
var result = await questionsController.GetQuestion(1);
var actionResult = Assert.IsType <ActionResult <QuestionGetSingleResponse> >(result);
}
public async Task Create_post_action_result_should_redirect_to_action_when_modelState_valid()
{
// Arrange
var question = new Question
{
QuestionId = 1,
QuizId = 1,
QuestionText = "Test"
};
var httpContext = new DefaultHttpContext();
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var controller = new QuestionsController(_questionRepository.Object, _answerRepository.Object)
{
TempData = tempData
};
// Act
var result = await controller.Create(question);
// Assert
Assert.IsType <RedirectToActionResult>(result);
}
public async void GetQuestions_WhenNoParameters_ReturnsAllQuestions()
{
var mockQuestions = new List <QuestionGetManyResponse>();
for (int i = 1; i <= 10; i++)
{
mockQuestions.Add(new QuestionGetManyResponse
{
QuestionId = 1,
Title = $"Test title {i}",
Content = $"Test content {i}",
UserName = "******",
Answers = new List <AnswerGetResponse>()
});
}
var mockDataRepo = new Mock <IDataRepository>();
mockDataRepo
.Setup(repo => repo.GetQuestions())
.Returns(() => mockQuestions.AsEnumerable());
var questionsController = new QuestionsController(
mockDataRepo.Object,
null, null, null);
var result = questionsController.GetQuestions(null, false);
Assert.Equal(mockQuestions.Count, result.Count());
mockDataRepo.Verify(mock => mock.GetQuestions(), Times.Once());
}
public void TestQuestionsByType()
{
var repo = new FakeRepository();
Question q1 = new Question
{
QuestionID = repo.Questions.Count,
QuestionHeader = "testQuestion1",
QuestionBody = "testQuestionBody1",
Type = "KB"
};
Question q2 = new Question
{
QuestionID = repo.Questions.Count,
QuestionHeader = "testQuestion2",
QuestionBody = "testQuestionBody2",
Type = "FQ"
};
repo.AddQuestion(q1);
repo.AddQuestion(q2);
List <Question> sortedQuestions = repo.FindQuestionsByType("KB");
Assert.Equal("testQuestion1", sortedQuestions[0].QuestionHeader);
var questionsController = new QuestionsController(repo);
List <Question> remainingQuestions = questionsController.FindQuestionsByType("FQ");
Assert.Equal("testQuestionBody2", remainingQuestions[0].QuestionBody);
}
public void Setup()
{
this.questions = new List <Question>()
{
new Question()
{
QuestionID = 0,
QuestionText = "abc"
},
new Question()
{
QuestionID = 1,
QuestionText = "xyz"
},
new Question
{
CategoryID = 2,
QuestionText = "lmn"
}
};
this.mockUnitOfWork = new Mock <IUnitOfWork>();
this.mockUnitOfWork.Setup(m => m.QuestionRepository.Get(null, null, "")).Returns(this.questions);
this.controller = new QuestionsController();
this.controller.UnitOfWork = mockUnitOfWork.Object;
foreach (var question in this.questions)
{
this.mockUnitOfWork.Object.QuestionRepository.Insert(question);
}
}
public void ShouldGetQuestions()
{
//Arrange
var expectedTitle = "My expected questions";
var expectedTexts = new List <string>();
expectedTexts.Add("What is the capital of Cuba?");
expectedTexts.Add("What is the capital of Ireland?");
expectedTexts.Add("What is the capital of the UK?");
var expectedQuestions = new Questionnaire()
{
QuestionnaireTitle = expectedTitle, QuestionsText = expectedTexts
};
var fakeQuestionRepository = new FakeQuestionRepository()
{
ExpectedQuestions = expectedQuestions
};
var questionsController = new QuestionsController(fakeQuestionRepository);
//Act
var questions = questionsController.Get();
//Assert
Assert.That(questions.QuestionnaireTitle, Is.EqualTo(expectedTitle));
Assert.That(questions.QuestionsText.Count, Is.EqualTo(expectedTexts.Count));
Assert.That(questions.QuestionsText[0], Is.EqualTo(expectedTexts[0]));
Assert.That(questions.QuestionsText[1], Is.EqualTo(expectedTexts[1]));
Assert.That(questions.QuestionsText[2], Is.EqualTo(expectedTexts[2]));
}
public async Task Get()
{
const int userId = 32;
const int quizId = 56;
var questions = new List <Question>
{
new Question(),
new Question()
};
var questionManager = new Mock <IQuestionManager>();
questionManager.Setup(c => c.GetQuizQuestions(userId, quizId))
.Returns(Task.FromResult(questions));
var sut = new QuestionsController(questionManager.Object);
sut.Token = new Models.TransferObjects.AuthToken
{
Token = "token",
UserId = userId,
ValidUntil = DateTime.Now.AddDays(1),
IsVerified = true
};
var result = await sut.Get(quizId);
Assert.AreEqual(questions.Count, result.ToList().Count);
}
public async Task PostUpdateThrowsException()
{
const int userId = 56;
const int quizId = 44;
const int questionId = 154;
var question = new Question
{
Id = questionId,
Body = "Test",
Level = 3,
Type = QuestionType.MultiSelect
};
var response = new SaveQuizResult
{
Result = 5,
Status = SaveQuizResultStatus.Success
};
var questionManager = new Mock <IQuestionManager>();
questionManager
.Setup(c => c.UpdateQuestion(userId, quizId, questionId, question))
.Returns(Task.FromResult(response));
var sut = new QuestionsController(questionManager.Object);
var result = await sut.PostUpdateQuestion(quizId, questionId, question);
Assert.AreEqual(HttpStatusCode.OK, (HttpStatusCode)result.StatusCode);
}
public async System.Threading.Tasks.Task AddQuestionForTopic()
{
using var dbContext = this.GetDbContext();
using var unity = new UnitofWork(dbContext);
dbContext.Questions.Add(new Models.Questions {
Id = Guid.NewGuid(), 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();
Models.Questions newquestion = new Models.Questions()
{
Question = "question4", Tags = "azure"
};
var service = new QuestionsController(unity);
var result = await service.AddQuestionsAsync(newquestion);
Xunit.Assert.NotNull(result);
}
public void PollPassedToQuestionCreateView()
{
// Arrange
var fakeDB = new FakePollContext();
fakeDB.Polls = new FakePollSet();
fakeDB.Questions = new FakeDbSet <Question>();
var poll = new Poll {
ID = 1, Title = "Hello"
};
fakeDB.Polls.Add(poll);
var poll2 = new Poll {
ID = 2, Title = "world"
};
fakeDB.Polls.Add(poll2);
QuestionsController controller = new QuestionsController(fakeDB);
// Act
ViewResult result = controller.Create("1") as ViewResult;
CreateQuestionViewModel generatedViewModel = result.ViewData.Model as CreateQuestionViewModel;
// Assert
Assert.AreEqual(generatedViewModel.PollTitle, "Hello");
}
public void GetQuestions_WhenHaveSearchParameter_ReturnsCorrectQuestions()
{
var mockQuestions = new List <QuestionGetManyResponse>();
mockQuestions.Add(new QuestionGetManyResponse
{
QuestionId = 1,
Title = $"Test title ",
Content = $"Test content",
UserName = "******",
Answers = new List <AnswerGetResponse>()
});
var mockDataRepository = new Mock <IDataRepository>();
mockDataRepository.Setup(repo => repo.GetQuestionsBySearchWithPaging("Test", 1, 20))
.Returns(() => mockQuestions.AsEnumerable());
var mockConfigurationRoot = new Mock <IConfigurationRoot>();
mockConfigurationRoot.SetupGet(config =>
config[It.IsAny <string>()]).Returns("some setting");
var questionsController = new QuestionsController(mockDataRepository.Object, null,
null, null, mockConfigurationRoot.Object);
var result = questionsController.GetQuestions("Test", false);
Assert.Single(result);
mockDataRepository.Verify(mock => mock.GetQuestionsBySearchWithPaging("Test", 1, 20), Times.Once());
}
public async Task PostQuestion_Success()
{
var question = new QuestionRequest
{
Content = "This is ... car?",
AnswerA = "a",
AnswerB = "an",
AnswerC = "that",
AnswerD = "this",
CorectAns = "a"
};
var questionService = new QuestionService(_questionRepository);
var controller = new QuestionsController(questionService);
//action
var result = await controller.AddQuestion(question);
//course
result.Should().NotBeNull();
var createdAtActionResult = Assert.IsType <OkObjectResult>(result.Result);
var returnValue = Assert.IsType <Question>(createdAtActionResult.Value);
Assert.Equal("This is ... car?", returnValue.Content);
Assert.Equal("a", returnValue.AnswerA);
Assert.Equal("an", returnValue.AnswerB);
Assert.Equal("that", returnValue.AnswerC);
Assert.Equal("this", returnValue.AnswerD);
Assert.Equal("a", returnValue.CorectAns);
}
public async Task DeleteQuestionAsync_UnauthorizedUserCall_ReturnUnauthorizedResult()
{
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, "1"),
}));
var exam = new Exam()
{
AuthorId = 2
};
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.QuestionRepository.Delete(It.IsAny <Question>()));
repositoryMock.Setup(r => r.SaveAllAsync()).ReturnsAsync(true);
var controllerMock = new QuestionsController(repositoryMock.Object, mapperMock.Object);
controllerMock.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
var result = await controllerMock.DeleteQuestionAsync(1, 1);
Assert.IsType <UnauthorizedResult>(result);
}
public async Task CreateQuestionAsync_ValidExamIdPassed_ReturnsCreatedAtRouteResult()
{
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, "1"),
}));
var exam = new Exam()
{
AuthorId = 1
};
var mapperMock = new Mock <IMapper>();
var repositoryMock = new Mock <IRepositoryWrapper>();
repositoryMock.Setup(r => r.ExamRepository.GetExamAsync(It.IsAny <int>())).ReturnsAsync(exam);
repositoryMock.Setup(r => r.QuestionRepository.Add(It.IsAny <Question>()));
repositoryMock.Setup(r => r.SaveAllAsync()).ReturnsAsync(true);
mapperMock.Setup(m => m.Map <Question>(It.IsAny <QuestionForCreationDto>())).Returns(new Question());
mapperMock.Setup(m => m.Map <QuestionForReturnDto>(It.IsAny <Question>())).Returns(new QuestionForReturnDto());
var controllerMock = new QuestionsController(repositoryMock.Object, mapperMock.Object);
controllerMock.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
var result = await controllerMock.CreateQuestionAsync(1, new QuestionForCreationDto());
Assert.IsType <CreatedAtRouteResult>(result);
}
public TestQuestionsController()
{
var mappingConfig = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new JeopardyMappingProfile());
});
model = new QuestionsModel()
{
Id = 55, QuestionEn = "TestQuestion 1", QuestionFr = "TestQuestion 1 en francais", AnswerEn = "TestAnswer 1", AnswerFr = "TestAnswer 1 en francais", CategoryId = 30, Hint = "Test Hint 1", Points = 100, TimeLimit = 30
};
updateModel = new QuestionsModel()
{
Id = 32, QuestionEn = "TestQuestion 112434", QuestionFr = "TestQuestion 112434 en francais", AnswerEn = "TestAnswer 1", AnswerFr = "TestAnswer 1 en francais", CategoryId = 30, Hint = "Test Hint 1", Points = 100, TimeLimit = 30
};
var mapper = mappingConfig.CreateMapper(); // Use this mapper to instantiate your class
_mapper = mapper;
_service = new JeopardyRepositoryFake(testContext);
_controller = new QuestionsController(_service, _mapper);
}
public async void GetQuestions_WhenNoParameters_ReturnsAllQuestions()
{
var mockQuestions = new List<QuestionGetManyResponse>();
for(int i = 0; i< 10; i++)
{
mockQuestions.Add(new QuestionGetManyResponse
{
QuestionId = 1,
Title = $"Test Title{i}",
Content = $"Test Content{i}",
UserName = "******",
Answers = new List<AnswerGetResponse>()
});
}
// Mock Data Repository
var mockDataRepository = new Mock<IDataRepository>();
mockDataRepository
.Setup(repo => repo.GetQuestions())
.Returns(() => Task.FromResult(mockQuestions.AsEnumerable()));
// Mock Configuration
var mockConfigurationRoot = new Mock<IConfigurationRoot>();
mockConfigurationRoot.SetupGet(config =>
config[It.IsAny<string>()]).Returns("some setting");
var questionsController = new QuestionsController(mockDataRepository.Object, null, null, null, mockConfigurationRoot.Object);
var result = await questionsController.GetQuestions(null, false);
Assert.Equal(10, result.Count());
mockDataRepository.Verify(mock => mock.GetQuestions(), Times.Once());
}
public void Test_QuestionsController_PutQuestion()
{
QuestionsController controller = new QuestionsController(_context);
var questionForUpdate = _context.Questions.FirstOrDefault();
var oldQuestion = _context.Questions.FirstOrDefault();
questionForUpdate.Answers = new List <Answer>()
{
new Answer()
{
Question = questionForUpdate,
Body = "test",
Creator = questionForUpdate.Creator
}
};
controller.PutQuestion(questionForUpdate.Id, questionForUpdate);
var changedQuestion = _context.Questions.Find(questionForUpdate.Id);
//because of EF entity refs
Assert.AreEqual(oldQuestion, changedQuestion);
}
public void GetQuestion_WhenQuestionIsFound_ReturnsQuestion()
{
var mockQuestion = new QuestionGetSingleResponse
{
QuestionId = 1,
Title = "test"
};
var mockDataRepository = new Mock <IDataRepository>();
mockDataRepository.Setup(repo => repo.GetQuestion(1))
.Returns(() => mockQuestion);
var mockQuestionCache = new Mock <IQuestionCache>();
mockQuestionCache.Setup(cache => cache.Get(1))
.Returns(() => mockQuestion);
var mockConfigurationRoot = new Mock <IConfigurationRoot>();
mockConfigurationRoot.SetupGet(config => config[It.IsAny <string>()]).Returns("some setting");
var questionsController = new QuestionsController(mockDataRepository.Object, null, mockQuestionCache.Object,
null, mockConfigurationRoot.Object);
var result = questionsController.GetQuestion(1);
var actionResult = Assert.IsType <ActionResult <QuestionGetSingleResponse> >(result);
var questionResult = Assert.IsType <QuestionGetSingleResponse>(actionResult.Value);
Assert.Equal(1, questionResult.QuestionId);
}
GetQuestion_WhenQuestionNotFound_Returns404()
{
var mockDataRepository = new Mock <IDataRepository>();
mockDataRepository
.Setup(repo => repo.GetQuestion(1))
.Returns(() => Task.FromResult(default(QuestionGetSingleResponse)));
var mockQuestionCache = new Mock <IQuestionCache>();
mockQuestionCache
.Setup(cache => cache.Get(1))
.Returns(() => null);
var mockConfigurationRoot = new Mock <IConfiguration>();
mockConfigurationRoot
.SetupGet(config => config[It.IsAny <string>()]).Returns("some setting");
var questionsController = new QuestionsController(
mockDataRepository.Object,
null, // AutoMapper
null, // SignalR Hub
mockQuestionCache.Object,
null, // HttpClientFactory
mockConfigurationRoot.Object
);
var result = await questionsController.GetQuestion(1);
var actionResult = Assert.IsType <ActionResult <QuestionGetSingleResponse> >(result);
Assert.IsType <NotFoundResult>(actionResult.Result);
}
public void GetQuestion_WhenQuestionNotFound_Returns404()
{
var mockDataRepository = new Mock <IDataRepository>();
mockDataRepository.Setup(repo => repo.GetQuestion(1))
.Returns(() => default(QuestionGetSingleResponse));
var mockQuestionCache = new Mock <IQuestionCache>();
mockQuestionCache.Setup(cache => cache.Get(1))
.Returns(() => null);
var mockConfigurationRoot = new Mock <IConfigurationRoot>();
mockConfigurationRoot.SetupGet(config => config[It.IsAny <string>()]).Returns("some setting");
var questionsController = new QuestionsController(mockDataRepository.Object, null,
mockQuestionCache.Object, null, mockConfigurationRoot.Object);
var result = questionsController.GetQuestion(1);
var actionResult = Assert.IsType <ActionResult <QuestionGetSingleResponse> >(result);
Assert.IsType <NotFoundResult>(actionResult.Result);
}
public QuestionnaireViewModel()
{
if (_qc == null)
{
_qc = new QuestionsController();
}
}
public void Test_QuestionsController_GetQuestionById_ReturnsQuestion()
{
QuestionsController controller = new QuestionsController(_context);
var result = controller.GetQuestion(_context.Questions.Select(x => x.Id).FirstOrDefault()).Result.Value;
Assert.IsInstanceOf <Question>(result);
}
public void Test_QuestionsController_GetQuestions_ReturnsListOfQuestions()
{
QuestionsController controller = new QuestionsController(_context);
var result = controller.GetQuestions();
Assert.IsNotEmpty(result.Result.Value);
}
public QuestionsControllerTest()
{
this.random = new Random();
this.expectedId = this.random.Next();
this.questionRepository = new Mock <IQuestionRepository>();
this.questionsController = new QuestionsController(this.questionRepository.Object);
}
public void SetUp()
{
controller = new QuestionsController()
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
}
public void Setup()
{
_fakeQuestionManager = new Mock <IQuestionManager>();
_fakeAnswerManager = new Mock <IAnswerManager>();
_fakePersonaManager = new Mock <IPersonaManager>();
_fakeHttpWrapper = new Mock <IHttpWrapper>();
_controller = new QuestionsController(_fakeQuestionManager.Object, _fakeAnswerManager.Object, _fakePersonaManager.Object, _fakeHttpWrapper.Object);
}
private void InitializeController()
{
var tempDataProvider = Mock.Of <ITempDataProvider>();
var tempDataDictionaryFactory = new TempDataDictionaryFactory(tempDataProvider);
var tempData = tempDataDictionaryFactory.GetTempData(new DefaultHttpContext());
_controller = new QuestionsController(_sessionServiceMock.Object);
_controller.TempData = tempData;
}
public async Task GetReturnsListOfQuestions()
{
_mockProvider.Setup(x => x.Get(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>())).ReturnsAsync(() => new List <SavedQuestion>());
controller = new QuestionsController(null, _mockProvider.Object);
var result = await controller.Get();
Assert.IsInstanceOf <OkObjectResult>(result);
}
public async Task DeleteQuestion_Success()
{
var question1 = new Question
{
QuestionId = 1,
Content = "This is ... car?",
AnswerA = "a",
AnswerB = "an",
AnswerC = "that",
AnswerD = "this",
CorectAns = "a"
};
var question2 = new Question
{
QuestionId = 2,
Content = "What your name?",
AnswerA = "Mr Nam",
AnswerB = "a",
AnswerC = "an",
AnswerD = "her",
CorectAns = "Mr Nam"
};
var list = new List <Question>();
list.Add(question1);
list.Add(question2);
await _questionRepository.AddRange(list);
var questionService = new QuestionService(_questionRepository);
var controller = new QuestionsController(questionService);
//action
var result = await controller.DeleteQuestion(1);
//course
result.Should().NotBeNull();
var response = Assert.IsType <OkObjectResult>(result.Result);
var returnValue = Assert.IsType <Question>(response.Value);
Assert.Equal(1, returnValue.QuestionId);
Assert.Equal("This is ... car?", returnValue.Content);
Assert.Equal("a", returnValue.AnswerA);
Assert.Equal("an", returnValue.AnswerB);
Assert.Equal("that", returnValue.AnswerC);
Assert.Equal("this", returnValue.AnswerD);
Assert.Equal("a", returnValue.CorectAns);
var totalQuestion = await _questionRepository.GetAll();
totalQuestion.Should().HaveCount(1);
}
