Inheritance: ISelfValidator
        public ValidationResult AtualizarCurso(Curso curso)
        {
            var resultadoValidacao = new ValidationResult();
            var cursoDb = _cursoRepository.GetById(curso.CursoId);

            cursoDb.AtualizarCurso(curso.Nome, curso.Ativo, curso.TipoCurso);

            if (!cursoDb.IsValid)
            {
                resultadoValidacao.AdicionarErro(cursoDb.ResultadoValidacao);
                return resultadoValidacao;
            }

            var resultadoConsistencia = new CursoEstaConsistenteParaAtualizarValidation(_cursoRepository).Validar(cursoDb);

            if (!resultadoConsistencia.IsValid)
            {
                resultadoValidacao.AdicionarErro(resultadoConsistencia);
                return resultadoValidacao;
            }

            _cursoRepository.Update(cursoDb);

            return resultadoValidacao;
        }
        public void Na_Atualizacao_Do_Curso_Deve_Alterar_DataAtualizacao()
        {
            var curso = new Curso("Ciências da Computação");
            DateTime dataAtuzalicaoCriacao = curso.DataAtualizacao;
            System.Threading.Thread.Sleep(2000);
            curso.AtualizarCurso("Novo Nome de Curso");

            Assert.IsTrue(dataAtuzalicaoCriacao != curso.DataAtualizacao);
        }
        public void DescricaoDeveTerEntre5e50Caracteres()
        {
            string validacaoEsperada = "A descrição deve conter entre 5 e 50 caracteres";
            var curso = new Curso("mater");

            string validacaoQuebrada = curso.ResultadoValidacao.Erros.FirstOrDefault(x => x.Message == validacaoEsperada).Message;

            Assert.AreEqual(validacaoEsperada, validacaoQuebrada);
        }
        public void Nome_Deve_Ter_Entre_5_e_50_Caracteres()
        {
            string validacaoEsperada = "O nome deve conter entre 5 e 50 caracteres.";
            var tipoCurso = new TipoCurso("Tecnólogo", true);
            var curso = new Curso("mater", true, tipoCurso);

            string validacaoQuebrada = curso.ResultadoValidacao.Erros.FirstOrDefault(x => x.Message == validacaoEsperada).Message;

            Assert.AreEqual(validacaoEsperada, validacaoQuebrada);
        }
 public static CursoViewModel CursoDomainParaCursoViewModel(Curso curso)
 {
     return new CursoViewModel
     {
         CursoId = curso.CursoId,
         Descricao = curso.Descricao,
         DataCadastro = curso.DataCadastro,
         DataAtualizacao = curso.DataAtualizacao,
         Ativo = curso.Ativo
     };
 }
        public void Um_Curso_Deve_Ser_Unico_No_Banco_De_Dados()
        {
            var curso = new Curso("Análise de Sistemas");

            var stubRepo = MockRepository.GenerateStub<ICursoRepository>();
            stubRepo.Stub(x => x.ObterPorDescricao("Análise de Sistemas")).Return(curso);

            var cursoValidation = new CursoEstaConsistente(stubRepo);
            var result = cursoValidation.Validar(curso);

            Assert.IsFalse(result.IsValid);
            Assert.IsTrue(result.Erros.Any(x => x.Message == "Este curso já foi cadastrado na base de dados"));
        }
        public void NaoDeveAceitarCursoSemSemestres()
        {
            var curso = new Curso("Análise de Sistemas");

            Assert.IsTrue(curso.IsValid);

            curso.AtivarCurso();

            Assert.IsFalse(curso.IsValid);
            Assert.IsTrue(curso.ResultadoValidacao.Erros.Any(e => e.Message == "O curso não possui nenhum semestre"));
            Assert.IsTrue(curso.ResultadoValidacao.Erros.Any(e => e.Message == "O curso deve possuir pelo menos 4 semestres"));
            Assert.IsTrue(curso.ResultadoValidacao.Erros.Count() == 2);
        }
        public void Para_Atualizar_Um_Curso_Deve_Ter_Descricao_Diferente_Se_For_Ids_Diferentes()
        {
            var cursoParaAtualizar = new Curso("Análise de Sistemas");
            var cursoJaCadastrado = new Curso("Análise de Sistemas");

            var stubRepo = MockRepository.GenerateStub<ICursoRepository>();
            stubRepo.Stub(x => x.ObterPorDescricao("Análise de Sistemas")).Return(cursoJaCadastrado);

            var cursoValidation = new CursoEstaConsistenteParaAtualizar(stubRepo);
            var result = cursoValidation.Validar(cursoParaAtualizar);

            Assert.IsFalse(result.IsValid);
            Assert.IsTrue(result.Erros.Any(x => x.Message == "Este curso já foi cadastrado na base de dados"));
        }
        public ValidationAppResult CadastrarNovoCurso(NovoCursoViewModel novoCursoViewModel)
        {
            var resultadoValidacao = new ValidationAppResult();
            BeginTransaction();

            var novoCurso = new Curso(novoCursoViewModel.Nome, novoCursoViewModel.Ativo, _tipoCursoService.ObterPorId(novoCursoViewModel.TipoCursoId));

            resultadoValidacao = DomainToApplicationResult(_cursoService.AdicionarNovoCurso(novoCurso));

            if (resultadoValidacao.IsValid)
                Commit();

            return resultadoValidacao;
        }
        public void NaoDeveAceitarCursoComMenosDeQuatroSemestres()
        {
            var curso = new Curso("Ciências da Computação");
            Semestre semestre = new Semestre();
            curso.Semestres.Add(semestre);

            Assert.IsTrue(curso.Semestres.Any());

            //Curso criado com sucesso
            Assert.IsTrue(curso.IsValid);

            curso.AtivarCurso();
            Assert.IsTrue(curso.ResultadoValidacao.Erros.Count() == 1);
            Assert.IsFalse(curso.Ativo);
            Assert.IsFalse(curso.IsValid);
            Assert.IsTrue(curso.ResultadoValidacao.Erros.Any(e => e.Message == "O curso deve possuir pelo menos 4 semestres"));
        }
        public void Não_Deve_Aceitar_Curso_Com_Menos_De_Quatro_Semestres()
        {
            var curso = new Curso("Ciências da Computação");
            Semestre semestre = new Semestre();
            curso.Semestres.Add(semestre);

            Assert.IsTrue(curso.Semestres.Any());

            //Curso criado com sucesso
            Assert.IsTrue(curso.IsValid);

            curso.AtivarCurso();
            Assert.IsTrue(curso.ResultadoValidacao.Erros.Count() > 0);
            Assert.IsFalse(curso.Ativo);
            Assert.IsFalse(curso.IsValid);
            Assert.IsTrue(curso.ResultadoValidacao.Erros.Any(e => e.Message == "O curso deve possuir pelo menos 4 semestres para poder ser ativado"));
        }
        public ValidationResult AdicionarNovoCurso(Curso curso)
        {
            var resultadoValidacao = new ValidationResult();

            if (!curso.IsValid)
            {
                resultadoValidacao.AdicionarErro(curso.ResultadoValidacao);
                return resultadoValidacao;
            }

            var resultadoConsistencia = new CursoEstaConsistenteValidation(_cursoRepository).Validar(curso);

            if (!resultadoConsistencia.IsValid)
            {
                resultadoValidacao.AdicionarErro(resultadoConsistencia);
                return resultadoValidacao;
            }
            _cursoRepository.Add(curso);

            return resultadoValidacao;
        }