public void FetchAnswersForQuestions_Always_SetsAttemptCountEqualToCountFromIAttemptRepositoryGetAttemptsForAnswer()
{
// arrange
var questionId = AutoFixture.Create <int>();
var answerDtos = AutoFixture.CreateMany <AnswerDto>().ToList();
AutoFixture.Freeze <Mock <IStackExchangeClient> >()
.Setup(x => x.GetAnswers(It.IsAny <int>()))
.Returns(answerDtos);
var attempts = AutoFixture.CreateMany <Attempt>().ToList();
AutoFixture.Freeze <Mock <IAttemptRepository> >()
.Setup(x => x.GetAttemptsForAnswer(It.IsAny <int>()))
.Returns(attempts);
// act
var controller = AutoFixture.Create <QuestionController>();
controller.FetchAnswersForQuestion(questionId);
// assert
foreach (var answerDto in answerDtos)
{
answerDto.AttemptCount.Should().Be(attempts.Count);
}
}
public void CreateFilter_WhenIRestClientExecuteReturnsResponseWithZeroQuotaRemaining_ReturnsNull()
{
// arrange
var client = new Mock <IRestClient>();
var data = AutoFixture.Build <ItemResponseDto <FilterDto> >()
.With(x => x.QuotaRemaining, 0)
.Create();
var restResponse = AutoFixture.Build <RestResponse <ItemResponseDto <FilterDto> > >()
.With(x => x.Data, data)
.Create();
client
.Setup(x => x.Execute <ItemResponseDto <FilterDto> >(It.IsAny <IRestRequest>()))
.Returns(restResponse);
AutoFixture.Freeze <Mock <IRestSharpWrapper> >()
.Setup(x => x.CreateRestClient(It.IsAny <string>()))
.Returns(client.Object);
// act
var filterCreator = AutoFixture.Create <StackExchangeFilterCreator>();
var response = filterCreator.CreateFilter();
// assert
response.Should().BeNull();
}
public void FetchAttemptedQuestion_Always_ReturnsAttemptedQuestion()
{
// arrange
var userId = AutoFixture.Create <string>();
var questionId = AutoFixture.Create <int>();
var attemptDto = AutoFixture.Create <AttemptDto>();
AutoFixture.Freeze <Mock <IMapper> >()
.Setup(x => x.Map <AttemptDto>(It.IsAny <Attempt>()))
.Returns(attemptDto);
var questionDto = AutoFixture.Create <QuestionDto>();
AutoFixture.Freeze <Mock <IStackExchangeClient> >()
.Setup(x => x.GetQuestion(It.IsAny <int>()))
.Returns(questionDto);
// act
var fetcher = AutoFixture.Create <PreviouslyAttemptedQuestionFetcher>();
var response = fetcher.FetchAttemptedQuestion(userId, questionId);
// assert
response.AttemptDto.Should().Be(attemptDto);
response.QuestionDto.Should().Be(questionDto);
}
public void FetchQuestions_Always_CallsIAttemptedQuestionDtoAssemblerAssembleAttemptedQuestionsOnce()
{
// arrange
var userId = AutoFixture.Create <string>();
var questionDtos = AutoFixture.CreateMany <QuestionDto>().ToList();
AutoFixture.Freeze <Mock <IStackExchangeClient> >()
.Setup(x => x.GetQuestions(It.IsAny <List <int> >()))
.Returns(questionDtos);
var attemptDtos = AutoFixture.CreateMany <AttemptDto>().ToList();
AutoFixture.Freeze <Mock <IMapper> >()
.Setup(x => x.Map <IEnumerable <AttemptDto> >(It.IsAny <IEnumerable <Attempt> >()))
.Returns(attemptDtos);
var assemblerMock = AutoFixture.Freeze <Mock <IAttemptedQuestionDtoAssembler> >();
// act
var fetcher = AutoFixture.Create <PreviouslyAttemptedQuestionFetcher>();
fetcher.FetchAttemptedQuestions(userId);
// assert
assemblerMock.Verify(x => x.AssembleAttemptedQuestions(attemptDtos, questionDtos), Times.Once);
}
public void FetchQuestions_Always_CallsIQuestionFilterFilterQuestionsOnce()
{
// arrange
var userId = AutoFixture.Create <string>();
var questionDtos = AutoFixture.CreateMany <QuestionDto>().ToList();
AutoFixture.Freeze <Mock <IStackExchangeClient> >()
.Setup(x => x.GetLatestQuestions(It.IsAny <int>()))
.Returns(questionDtos);
var filteredQuestions = AutoFixture.CreateMany <QuestionDto>(20).ToList();
var filterMock = AutoFixture.Freeze <Mock <IQuestionFilter> >();
filterMock
.Setup(x => x.FilterQuestions(It.IsAny <IEnumerable <QuestionDto> >()))
.Returns(filteredQuestions);
// act
var fetcher = AutoFixture.Create <FilteredLatestQuestionsFetcher>();
fetcher.FetchQuestions(userId);
// assert
filterMock.Verify(x => x.FilterQuestions(questionDtos), Times.Once);
}
public void FetchQuestions_WhenAttemptRepositoryReturnsQuestionIds_ExcludesAttemptedQuestionIdsFromResult()
{
// arrange
var userId = AutoFixture.Create <string>();
var questionId = AutoFixture.Create <int>();
var attempts = AutoFixture.Build <Attempt>()
.With(x => x.QuestionId, questionId)
.CreateMany()
.ToList();
AutoFixture.Freeze <Mock <IAttemptRepository> >()
.Setup(x => x.GetAttempts(It.IsAny <string>()))
.Returns(attempts);
var previouslyAttemptedQuestions = AutoFixture.Build <QuestionDto>()
.With(x => x.QuestionId, questionId)
.CreateMany()
.ToList();
var notPreviouslyAttemptedQuestions = AutoFixture.CreateMany <QuestionDto>(20).ToList();
previouslyAttemptedQuestions.InsertRange(RandomGenerator.Next(previouslyAttemptedQuestions.Count), notPreviouslyAttemptedQuestions);
AutoFixture.Freeze <Mock <IQuestionFilter> >()
.Setup(x => x.FilterQuestions(It.IsAny <IEnumerable <QuestionDto> >()))
.Returns(previouslyAttemptedQuestions);
// act
var fetcher = AutoFixture.Create <FilteredLatestQuestionsFetcher>();
var response = fetcher.FetchQuestions(userId);
// assert
response.Should().BeEquivalentTo(notPreviouslyAttemptedQuestions);
}
public void SubmitAttempt_WhenExistingAttemptCheckReturnsNull_AssignsUserIdAndScore()
{
// arrange
var attemptDto = AutoFixture.Create <AttemptDto>();
var userId = AutoFixture.Create <string>();
AutoFixture.Freeze <Mock <IAttemptRepository> >()
.Setup(x => x.GetAttempt(It.IsAny <int>(), It.IsAny <string>()))
.Returns((Attempt)null);
var attempt = AutoFixture.Create <Attempt>();
AutoFixture.Freeze <Mock <IMapper> >()
.Setup(x => x.Map <Attempt>(It.IsAny <AttemptDto>()))
.Returns(attempt);
var score = AutoFixture.Create <int>();
AutoFixture.Freeze <Mock <IAttemptScoreCalculator> >()
.Setup(x => x.CalculateScore(It.IsAny <Attempt>()))
.Returns(score);
var repositoryMock = AutoFixture.Freeze <Mock <IAttemptRepository> >();
// act
var manager = AutoFixture.Create <AttemptSubmissionManager>();
manager.SubmitAttempt(attemptDto, userId);
// assert
repositoryMock.Verify(x => x.InsertAttempt(It.Is <Attempt>(param => param.UserId == userId && param.Score == score)));
}
public void CalculateScore_GivenIncorrectAnswer_ReturnsRatioOfSameAttemptsDividedByTotalAttemptsOnQuestion()
{
// arrange
var attempt = AutoFixture.Create <Attempt>();
var matchingAttempts = AutoFixture.Build <Attempt>()
.With(x => x.AnswerId, attempt.AnswerId)
.CreateMany()
.ToList();
var nonMatchingAttempts = AutoFixture.CreateMany <Attempt>().ToList();
nonMatchingAttempts.InsertRange(RandomGenerator.Next(nonMatchingAttempts.Count), matchingAttempts);
AutoFixture.Freeze <Mock <IAttemptRepository> >()
.Setup(x => x.GetAttemptsForQuestion(It.IsAny <int>()))
.Returns(nonMatchingAttempts);
// act
var calculator = AutoFixture.Create <AttemptScoreCalculator>();
var response = calculator.CalculateScore(attempt);
// assert
var score = (double)(matchingAttempts.Count - 1) / nonMatchingAttempts.Count * 100;
response.Should().Be((int)Math.Round(score));
}
public void SubmitAttempt_WhenExistingAttemptCheckReturnsNull_CallsIAttemptScoreCalculatorCalculateScoreOnce()
{
// arrange
var attemptDto = AutoFixture.Create <AttemptDto>();
var userId = AutoFixture.Create <string>();
AutoFixture.Freeze <Mock <IAttemptRepository> >()
.Setup(x => x.GetAttempt(It.IsAny <int>(), It.IsAny <string>()))
.Returns((Attempt)null);
var attempt = AutoFixture.Create <Attempt>();
AutoFixture.Freeze <Mock <IMapper> >()
.Setup(x => x.Map <Attempt>(It.IsAny <AttemptDto>()))
.Returns(attempt);
var calculatorMock = AutoFixture.Freeze <Mock <IAttemptScoreCalculator> >();
// act
var manager = AutoFixture.Create <AttemptSubmissionManager>();
manager.SubmitAttempt(attemptDto, userId);
// assert
calculatorMock.Verify(x => x.CalculateScore(attempt), Times.Once);
}
public void ValidationResults_NotNullAndEmptyAfterCreation()
{
var target = AutoFixture.Freeze <DefaultOptionSetValidator>();
Assert.That(target.ValidationResults, Is.Not.Null);
Assert.That(target.ValidationResults, Is.Empty);
}
public void CreateFilter_WhenIRestClientExecuteReturnsValidResponse_ReturnsResponseData()
{
// arrange
var client = new Mock <IRestClient>();
var data = AutoFixture.Build <ItemResponseDto <FilterDto> >()
.With(x => x.QuotaRemaining, RandomGenerator.Next(1, 100))
.Create();
var restResponse = AutoFixture.Build <RestResponse <ItemResponseDto <FilterDto> > >()
.With(x => x.Data, data)
.Create();
client
.Setup(x => x.Execute <ItemResponseDto <FilterDto> >(It.IsAny <IRestRequest>()))
.Returns(restResponse);
AutoFixture.Freeze <Mock <IRestSharpWrapper> >()
.Setup(x => x.CreateRestClient(It.IsAny <string>()))
.Returns(client.Object);
// act
var filterCreator = AutoFixture.Create <StackExchangeFilterCreator>();
var response = filterCreator.CreateFilter();
// assert
response.Should().BeEquivalentTo(data.Items.FirstOrDefault()?.Filter);
}
public override void SetupTest()
{
base.SetupTest();
_mapper = AutoFixture.Freeze <Mock <IMappingEngine> >();
_mapper.DefaultValue = DefaultValue.Mock;
_repository = AutoFixture.Freeze <Mock <IRepository> >();
_sut = AutoFixture.Create <WorkerRegistry>();
_mapper.Setup(s => s.Map <RegisterWorkerRequest, WorkerRegistration>(It.IsAny <RegisterWorkerRequest>())).Returns(AutoFixture.Create <WorkerRegistration>());
}
public void AddError_WhenWePassEmptyMessage_ThrowException()
{
var ex = Assert.Throws <ArgumentNullException>(() =>
{
var target = AutoFixture.Freeze <DefaultOptionSetValidator>();
target.AddError(null, null);
});
Assert.That(ex.ParamName, Is.EqualTo("message"));
}
public override void SetupTest()
{
base.SetupTest();
_fileSystemMock = AutoFixture.Freeze <Mock <IFileSystem> >();
_processRunner = AutoFixture.Freeze <Mock <IProcessRunner> >();
_serverChannel = AutoFixture.Freeze <Mock <IServerChannel> >();
_options = AutoFixture.Freeze <TaskExecutionOptions>();
_serverChannel.Setup(s => s.WorkComplete(It.IsAny <TaskExecutionResult>())).Returns(new Response(false, ""));
_taskExecutor = AutoFixture.Create <TaskExecutor>();
}
public void FetchLatestQuestions_Always_CallsIFilteredLatestQuestionsFetcherFetchQuestionsOnce()
{
// arrange
var questionFetcherMock = AutoFixture.Freeze <Mock <IFilteredLatestQuestionsFetcher> >();
// act
var controller = AutoFixture.Create <QuestionController>();
controller.FetchLatestQuestions();
// assert
questionFetcherMock.Verify(x => x.FetchQuestions(It.IsAny <string>()), Times.Once);
}
public void CreateFilter_Always_CallsIStackExchangeResourceFactoryFetchResourceOnce()
{
// arrange
var resourceFactoryMock = AutoFixture.Freeze <Mock <IStackExchangeResourceFactory> >();
// act
var filterCreator = AutoFixture.Create <StackExchangeFilterCreator>();
filterCreator.CreateFilter();
// assert
resourceFactoryMock.Verify(x => x.FetchResource(StackExchangeResourceEnum.CreateFilter), Times.Once);
}
public void FetchPreviousQuestions_Always_CallsIPreviouslyAttemptedQuestionFetcherFetchQuestionsOnce()
{
// arrange
var questionFetcherMock = AutoFixture.Freeze <Mock <IPreviouslyAttemptedQuestionFetcher> >();
// act
var controller = AutoFixture.Create <AttemptController>();
controller.FetchPreviousQuestions();
// assert
questionFetcherMock.Verify(x => x.FetchAttemptedQuestions(It.IsAny <string>()), Times.Once);
}
public void CreateFilter_Always_CallsIRestSharpWrapperCreateRestClientOnce()
{
// arrange
var restSharpWrapperMock = AutoFixture.Freeze <Mock <IRestSharpWrapper> >();
// act
var filterCreator = AutoFixture.Create <StackExchangeFilterCreator>();
filterCreator.CreateFilter();
// assert
restSharpWrapperMock.Verify(x => x.CreateRestClient("https://api.stackexchange.com/2.2"), Times.Once);
}
public async Task TestEmitBatchAsync_WithEnabledTrue_ShouldInsertLogEvents(IEnumerable <LogEvent> logEvents)
{
//Arrange
AutoFixture.Customize <BigQuerySinkOptions>(opt => opt.With(p => p.IsEnabled, true));
var connection = AutoFixture.Freeze <Mock <IConnection> >();
//Act
var sut = AutoFixture.Create <SinkTest>();
await sut.TestEmitBatchAsync(logEvents);
//Assert
connection.Verify(mock => mock.CreateLogTableAsync(), Times.Once);
connection.Verify(mock => mock.InsertLogEventsAsync(It.IsAny <IEnumerable <BigQueryLogEvent> >()), Times.Once);
}
public void CreateAttempt_Always_CallsIAttemptSubmissionManagerSubmitAttemptOnce()
{
// arrange
var attemptDto = AutoFixture.Create <AttemptDto>();
var managerMock = AutoFixture.Freeze <Mock <IAttemptSubmissionManager> >();
// act
var controller = AutoFixture.Create <AttemptController>();
controller.CreateAttempt(attemptDto);
// assert
managerMock.Verify(x => x.SubmitAttempt(attemptDto, It.IsAny <string>()), Times.Once);
}
public void AddError_WhenCallAddError_MessagePersistsAmongValidationResults()
{
var message = AutoFixture.Create <string>();
var xmlLineInfo = AutoFixture.Create <Mock <IXmlLineInfo> >()
.Object;
var target = AutoFixture.Freeze <DefaultOptionSetValidator>();
target.AddError(message, xmlLineInfo);
Assert.That(target.ValidationResults, Is.Not.Null);
Assert.That(target.ValidationResults.Count, Is.EqualTo(1));
Assert.That(target.ValidationResults[0].Key, Is.EqualTo(message));
Assert.That(target.ValidationResults[0].Value, Is.SameAs(xmlLineInfo));
}
public void FetchAnswersForQuestion_Always_CallsIStackExchangeClientFetchAnswersForQuestionOnce()
{
// arrange
var questionId = AutoFixture.Create <int>();
var clientMock = AutoFixture.Freeze <Mock <IStackExchangeClient> >();
// act
var controller = AutoFixture.Create <QuestionController>();
controller.FetchAnswersForQuestion(questionId);
// assert
clientMock.Verify(x => x.GetAnswers(questionId), Times.Once);
}
public void GetAttemptsForQuestion_Always_CallsIAttemptRepositoryGetAttemptsForQuestion()
{
// arrange
var questionId = AutoFixture.Create <int>();
var repositoryMock = AutoFixture.Freeze <Mock <IAttemptRepository> >();
// act
var controller = AutoFixture.Create <QuestionController>();
controller.GetAttemptsForQuestion(questionId);
// assert
repositoryMock.Verify(x => x.GetAttemptsForQuestion(questionId), Times.Once);
}
public void CalculateScore_GivenIncorrectAnswer_CallsIAttemptRepositoryGetAttemptsForQuestionOnce()
{
// arrange
var attempt = AutoFixture.Create <Attempt>();
var attemptRepositoryMock = AutoFixture.Freeze <Mock <IAttemptRepository> >();
// act
var calculator = AutoFixture.Create <AttemptScoreCalculator>();
calculator.CalculateScore(attempt);
// assert
attemptRepositoryMock.Verify(x => x.GetAttemptsForQuestion(attempt.QuestionId), Times.Once);
}
public void FetchQuestions_Always_CallsIAttemptRepositoryGetAttemptsOnce()
{
// arrange
var userId = AutoFixture.Create <string>();
var repositoryMock = AutoFixture.Freeze <Mock <IAttemptRepository> >();
// act
var fetcher = AutoFixture.Create <PreviouslyAttemptedQuestionFetcher>();
fetcher.FetchAttemptedQuestions(userId);
// assert
repositoryMock.Verify(x => x.GetAttempts(userId), Times.Once);
}
public void FetchPreviousQuestions_Always_ReturnsResponseFromIPreviouslyAttemptedQuestionFetcher()
{
// arrange
var attemptQuestionDtos = AutoFixture.CreateMany <AttemptedQuestionDto>().ToList();
AutoFixture.Freeze <Mock <IPreviouslyAttemptedQuestionFetcher> >()
.Setup(x => x.FetchAttemptedQuestions(It.IsAny <string>()))
.Returns(attemptQuestionDtos);
// act
var controller = AutoFixture.Create <AttemptController>();
var response = controller.FetchPreviousQuestions();
// assert
response.Should().BeEquivalentTo(attemptQuestionDtos);
}
public void FetchLatestQuestions_Always_ReturnsResponseFromIFilteredLatestQuestionsFetcher()
{
// arrange
var questionDtos = AutoFixture.CreateMany <QuestionDto>().ToList();
AutoFixture.Freeze <Mock <IFilteredLatestQuestionsFetcher> >()
.Setup(x => x.FetchQuestions(It.IsAny <string>()))
.Returns(questionDtos);
// act
var controller = AutoFixture.Create <QuestionController>();
var response = controller.FetchLatestQuestions();
// assert
response.Should().BeEquivalentTo(questionDtos);
}
public void SubmitAttempt_Always_CallsIAttemptRepositoryGetAttemptOnce()
{
// arrange
var attemptDto = AutoFixture.Create <AttemptDto>();
var userId = AutoFixture.Create <string>();
var repositoryMock = AutoFixture.Freeze <Mock <IAttemptRepository> >();
// act
var manager = AutoFixture.Create <AttemptSubmissionManager>();
manager.SubmitAttempt(attemptDto, userId);
// assert
repositoryMock.Verify(x => x.GetAttempt(attemptDto.QuestionId, userId), Times.Once);
}
public void FetchAttemptedQuestion_Always_CallsIStackExchangeClientGetQuestionOnce()
{
// arrange
var userId = AutoFixture.Create <string>();
var questionId = AutoFixture.Create <int>();
var clientMock = AutoFixture.Freeze <Mock <IStackExchangeClient> >();
// act
var fetcher = AutoFixture.Create <PreviouslyAttemptedQuestionFetcher>();
fetcher.FetchAttemptedQuestion(userId, questionId);
// assert
clientMock.Verify(x => x.GetQuestion(questionId), Times.Once);
}
public void AssembleAttemptedQuestions_WhenQuestionFilterReturnsNull_ReturnsEmptyList()
{
// arrange
var attemptDtos = AutoFixture.CreateMany <AttemptDto>().ToList();
var questionDtos = AutoFixture.CreateMany <QuestionDto>().ToList();
AutoFixture.Freeze <Mock <IQuestionFilter> >()
.Setup(x => x.GetQuestionDtoById(It.IsAny <IEnumerable <QuestionDto> >(), It.IsAny <int>()))
.Returns((QuestionDto)null);
// act
var assembler = AutoFixture.Create <AttemptedQuestionDtoAssembler>();
var response = assembler.AssembleAttemptedQuestions(attemptDtos, questionDtos);
// assert
response.Should().BeEmpty();
}