public async Task GivenAnInexistentId_WhenDeleteAsync_ThenReturnFalse()
        {
            var evaluation = EvaluationsFactory.ValidEvaluation();

            var result = await _repository.DeleteAsync(evaluation.Id);

            result.Should().BeFalse();
        }
        public async Task GivenAnInexistentId_WhenGetByIdAsync_ThenReturnNull()
        {
            var evaluation = EvaluationsFactory.ValidEvaluation();

            var result = await _repository.GetByIdAsync(evaluation.Id);

            result.Should().BeNull();
        }
        public async Task GivenAEvaluation_WhenUpdateEvaluation_ThenReturnEvaluationUpdated()
        {
            var evaluation        = EvaluationsFactory.AddedEvaluation(_database.DbContext);
            var updatedEvaluation = EvaluationsFactory.UpdateScorValidEvaluation(evaluation.Id);

            var result = await _repository.UpdateAsync(updatedEvaluation);

            result.Should().BeOfType <Evaluation>();
            result.Scor.Should().Be(updatedEvaluation.Scor);
        }
        public async Task GivenAListOfEvaluations_WhenGetAllEvaluations_ThenReturnListOfEvaluationEntity()
        {
            var evaluation = EvaluationsFactory.Added2Evaluations(_database.DbContext);

            var result = await _repository.GetAllAsync();

            result.Should().BeOfType <List <Evaluation> >();
            var addedEvaluation = result.FirstOrDefault(e => e.Id == evaluation.Id);

            addedEvaluation.Should().NotBeNull();
        }
        public async Task GivenAnEvaluation_WhenCreateAsync_ThenReturnEvaluationEntity()
        {
            var evaluation = EvaluationsFactory.ValidEvaluation();

            var result = await _repository.CreateAsync(evaluation);

            result.Should().BeOfType <Evaluation>();
            result.Scor.Should().Be(evaluation.Scor);
            result.UserId.Should().Be(evaluation.UserId);
            result.ConsultantId.Should().Be(evaluation.ConsultantId);
        }
        public async Task GivenAnId_WhenDeleteEvaluationByIdCommandHandler_ThenReturnTrue()
        {
            var evaluation = EvaluationsFactory.ValidEvaluation();
            var command    = new DeleteEvaluationByIdCommand(evaluation.Id);
            var mockRepo   = new Mock <IEvaluationRepository>();

            mockRepo.Setup(db => db.DeleteAsync(command.Id).Result).Returns(true);
            var handler = new DeleteEvaluationByIdCommandHandler(mockRepo.Object);

            var result = await handler.Handle(command, CancellationToken.None);

            result.Should().BeTrue();
        }
        public async Task GivenAnId_WhenGetEvaluationByIdQueryHandler_ThenReturnNotNull()
        {
            var evaluation = EvaluationsFactory.ValidEvaluation();
            var command    = new GetEvaluationByIdQuery(evaluation.Id);
            var mockRepo   = new Mock <IEvaluationRepository>();

            mockRepo.Setup(db => db.GetByIdAsync(command.Id).Result).Returns(evaluation);
            var handler = new GetEvaluationByIdQueryHandler(mockRepo.Object);

            var result = await handler.Handle(command, CancellationToken.None);

            result.Should().NotBeNull();
            result.Id.Should().Be(evaluation.Id);
            result.Scor.Should().Be(evaluation.Scor);
            result.UserId.Should().Be(evaluation.UserId);
            result.ConsultantId.Should().Be(evaluation.ConsultantId);
        }
        public async Task GivenAList_WhenGetAllEvaluationsQueryHandler_ThenReturnNotNull()
        {
            var evaluation1 = EvaluationsFactory.ValidEvaluation();
            var evaluation2 = EvaluationsFactory.ValidEvaluation();
            var evaluations = new List <Evaluation> {
                evaluation1, evaluation2
            };
            var command  = new GetAllEvaluationsQuery();
            var mockRepo = new Mock <IEvaluationRepository>();

            mockRepo.Setup(db => db.GetAllAsync().Result).Returns(evaluations);
            var handler = new GetAllEvaluationsQueryHandler(mockRepo.Object);

            var result = await handler.Handle(command, CancellationToken.None);

            result.Should().NotContainNulls();
            result.Should().HaveCount(evaluations.Count);
            result.Should().Contain(evaluation1);
        }