Subversion Repositories Integrator Subversion

package br.gov.al.saude.srv.core.domain;

import static br.gov.al.saude.srv.core.domain.parametro.ParametroService.CODIGO_PARAMETRO_QUANTIDADE_VAGAS_FUNCAO_GRATIFICADA_1;
import static br.gov.al.saude.srv.core.domain.servidor.ServidorService.PAPEL_SERVIDOR_TECNICO_SAFP_SEM_PREFIXO_ROLE;
import static br.gov.al.saude.srv.core.domain.servidor.ServidorService.PAPEL_SERVIDOR_TECNICO_SER_SEM_PREFIXO_ROLE;
import static br.gov.al.saude.srv.core.domain.servidor.ServidorService.PAPEL_SERVIDOR_TECNICO_SIF_SEM_PREFIXO_ROLE;
import static br.gov.al.saude.test.ConstantesTestHelper.ATIVO_SIM;
import static br.gov.al.saude.test.ConstantesTestHelper.DATA_ATUAL_MAIS_1_DIA;
import static br.gov.al.saude.test.ConstantesTestHelper.DATA_ATUAL_MAIS_365_DIA;
import static br.gov.al.saude.test.ConstantesTestHelper.DATA_ATUAL_MENOS_1_DIA;
import static br.gov.al.saude.test.ConstantesTestHelper.DESCRICAO_SIM;
import static br.gov.al.saude.test.ConstantesTestHelper.DIRETORIO_FOTOS;
import static br.gov.al.saude.test.ConstantesTestHelper.CargoConstantes.DESCRICAO_CARGO_ANALISTA_SISTEMAS;
import static br.gov.al.saude.test.ConstantesTestHelper.CargoConstantes.SEQUENCIAL_CARGO_9;
import static br.gov.al.saude.test.ConstantesTestHelper.CargoConstantes.SEQUENCIAL_CARGO_ANALISTA_SISTEMAS_13;
import static br.gov.al.saude.test.ConstantesTestHelper.CarreiraConstantes.SEQUENCIAL_CARREIRA_APOIO_SAUDE_9;
import static br.gov.al.saude.test.ConstantesTestHelper.CarreiraConstantes.SEQUENCIAL_CARREIRA_MEDICA_8;
import static br.gov.al.saude.test.ConstantesTestHelper.CursoConstantes.CODIGO_CURSO_MEDICINA_1;
import static br.gov.al.saude.test.ConstantesTestHelper.CursoConstantes.DESCRICAO_CURSO_ANALISE_SISTEMAS;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.CARGA_HORARIA_10;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.CARGA_HORARIA_20;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.DATA_INICIO_01_01_2011;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.DIGITO_MATRICULA_0;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.DIGITO_MATRICULA_8;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.NOSSO_NUMERO_SERVIDOR_DADO_FUNCIONAL_105;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.NUMERO_CONTRATO_354_2010;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.NUMERO_CONTRATO_35_2013;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.NUMERO_CONTRATO_905_2013;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.NUMERO_MATRICULA_96754522;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.NUMERO_MATRICULA_9889424;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.NUMERO_ORDEM_1357;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.NUMERO_ORDEM_3542;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.TIPO_CLASSE_A;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.TIPO_NIVEL_4;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalConstantes.TIPO_REGIME_TRABALHO_NORMAL_N;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalEstagio.NIVEL_ENSINO_SUPERIOR_S;
import static br.gov.al.saude.test.ConstantesTestHelper.DadosFuncionalEstagio.OBRIGATORIO_NAO;
import static br.gov.al.saude.test.ConstantesTestHelper.DeficienciaConstantes.SEQUENCIAL_DEFICIENCIA_FISICA_3;
import static br.gov.al.saude.test.ConstantesTestHelper.FuncaoConstantes.DESCRICAO_FUNCAO_ANALISTA_SISTEMAS;
import static br.gov.al.saude.test.ConstantesTestHelper.FuncaoConstantes.NIVEL_AS3;
import static br.gov.al.saude.test.ConstantesTestHelper.FuncaoConstantes.SEQUENCIAL_FUNCAO_ANALISTA_SISTEMAS_19;
import static br.gov.al.saude.test.ConstantesTestHelper.FuncaoConstantes.SEQUENCIAL_FUNCAO_ASSESSOR_TECNICO_23;
import static br.gov.al.saude.test.ConstantesTestHelper.GrauInstrucaoConstantes.SEQUENCIAL_GRAU_INSTRUCAO_SUPERIOR_4;
import static br.gov.al.saude.test.ConstantesTestHelper.InstituicaoConstantes.CODIGO_INSTITUICAO_CESMAC_3;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.EXTENSAO_ARQUIVO_FOTO_INVALIDA;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.LIMITE_CARGA_HORARIA_ATINGIDO;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.LIMITE_VAGAS_FUNCAO_TIPO_GRATIFICADA_FOI_ATINGIDO;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.MSG_ERRO_JA_EXISTE_SERVIDOR_ATIVO_CADASTRADO_COM_MATRICULA_INFORMADA;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.MSG_ERRO_NAO_EH_PERMITIDO_ALTERAR_SITUACAO_SERVIDOR_COM_DADO_FUNCIONAL_DIFERENTE_ESTAGIARIO;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.MSG_ERRO_NAO_EH_PERMITIDO_ALTERAR_SITUACAO_SERVIDOR_COM_DADO_FUNCIONAL_DIFERENTE_PRESTADOR;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.MSG_ERRO_NUMERO_ORDEM_JA_CADASTRADO;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.OBRIGATORIO_INFORMAR_FUNCAO;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.SERVIDOR_POSSUI_DADO_FUNCIONAL_ATIVO_COM_CARGO_NA_UNIDADE_LOTACAO;
import static br.gov.al.saude.test.ConstantesTestHelper.NacionalidadeConstantes.SEQUENCIAL_NACIONALIDADE_BRASILEIRA_1;
import static br.gov.al.saude.test.ConstantesTestHelper.OrgaoConstantes.SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20;
import static br.gov.al.saude.test.ConstantesTestHelper.ParametroConstantes.CODIGO_PARAMETRO_1;
import static br.gov.al.saude.test.ConstantesTestHelper.ParametroConstantes.DESCRICAO_PARAMETRO_QUANTIDADE_VAGAS_FUNCAO;
import static br.gov.al.saude.test.ConstantesTestHelper.ParametroConstantes.VALOR_PARAMETRO_QUANTIDADE_VAGAS_FUNCAO;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.DATA_NASCIMENTO_01_01_1995;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.NOME_FOTO_GIF;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.NOME_FOTO_JPEG;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.NOME_FOTO_PNG;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.NOME_PESSOA_JOSE_MARIA;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.NOME_PESSOA_YANNE_ALMEIDA;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.NUMERO_CPF_03147532062;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.NUMERO_CPF_07771278495;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.SEQUENCIAL_PESSOA_13;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.SEQUENCIAL_PESSOA_ANDERSON_SILVA_7;
import static br.gov.al.saude.test.ConstantesTestHelper.QualificacaoConstantes.DATA_FINAL_01_03_2012;
import static br.gov.al.saude.test.ConstantesTestHelper.QualificacaoConstantes.DATA_INICIAL_01_01_2012;
import static br.gov.al.saude.test.ConstantesTestHelper.QualificacaoConstantes.INSTITUICAO_CESMAC;
import static br.gov.al.saude.test.ConstantesTestHelper.QualificacaoConstantes.NUMERO_CARGA_HORARIA_10;
import static br.gov.al.saude.test.ConstantesTestHelper.QualificacaoConstantes.TIPO_QUALIFICACAO_FORMACAO_ACADEMICA_A;
import static br.gov.al.saude.test.ConstantesTestHelper.SetorConstantes.CODIGO_SETOR_INFORMATICA_100;
import static br.gov.al.saude.test.ConstantesTestHelper.SituacaoServidorConstantes.SEQUENCIAL_SITUACAO_SERVIDOR_ATIVO_1;
import static br.gov.al.saude.test.ConstantesTestHelper.SituacaoServidorConstantes.SEQUENCIAL_SITUACAO_SERVIDOR_EXONERADO_2;
import static br.gov.al.saude.test.ConstantesTestHelper.UnidadeConstantes.SEQUENCIAL_UNIDADE_HOSPITAL_GERAL_ESTADO_25;
import static br.gov.al.saude.test.ConstantesTestHelper.UnidadeConstantes.SEQUENCIAL_UNIDADE_SEDE_33;
import static br.gov.al.saude.test.ConstantesTestHelper.UsuarioScaConstantes.SEQUENCIAL_USUARIO_3;
import static br.gov.al.saude.test.ConstantesTestHelper.UtilConstantes.DESCRICAO_SEXO_MASCULINO;
import static br.gov.al.saude.test.ConstantesTestHelper.UtilConstantes.GRAU_PARENTESCO_FILHO_F;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import net.sf.jasperreports.engine.JasperPrint;

import org.jmock.Expectations;
import org.junit.Before;
import org.junit.Test;

import br.gov.al.saude.framework.core.consulta.restricao.Restricoes;
import br.gov.al.saude.framework.core.generic.GenericRepository;
import br.gov.al.saude.framework.core.generic.GenericService;
import br.gov.al.saude.framework.core.interfaces.Alterar;
import br.gov.al.saude.framework.core.interfaces.Cadastrar;
import br.gov.al.saude.framework.core.util.VerificadorUtil;
import br.gov.al.saude.framework.core.validador.Validador;
import br.gov.al.saude.framework.model.PermissaoView;
import br.gov.al.saude.framework.model.PessoaFisicaView;
import br.gov.al.saude.framework.model.UsuarioView;
import br.gov.al.saude.srv.core.domain.servidor.ServidorService;
import br.gov.al.saude.srv.core.domain.servidor.impl.ServidorServiceImpl;
import br.gov.al.saude.srv.core.domain.servidor.relatorio.GeradorRelatorioServidor;
import br.gov.al.saude.srv.core.infrastructure.persistence.jpa.cargo.CargoRepository;
import br.gov.al.saude.srv.core.infrastructure.persistence.jpa.funcao.FuncaoRepository;
import br.gov.al.saude.srv.core.infrastructure.persistence.jpa.parametro.ParametroRepository;
import br.gov.al.saude.srv.core.infrastructure.persistence.jpa.servidor.ServidorRepository;
import br.gov.al.saude.srv.model.FormaIngresso;
import br.gov.al.saude.srv.model.Funcao;
import br.gov.al.saude.srv.model.Orgao;
import br.gov.al.saude.srv.model.Parametro;
import br.gov.al.saude.srv.model.Servidor;
import br.gov.al.saude.srv.model.ServidorDadoFuncional;
import br.gov.al.saude.srv.model.ServidorDadoFuncionalContratadoEstagiario;
import br.gov.al.saude.srv.model.ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo;
import br.gov.al.saude.srv.model.ServidorDadoFuncionalMatricula;
import br.gov.al.saude.srv.model.ServidorDadoFuncionalMatriculaCarreira;
import br.gov.al.saude.srv.model.ServidorDependente;
import br.gov.al.saude.srv.model.ServidorQualificacao;
import br.gov.al.saude.srv.model.SituacaoServidor;
import br.gov.al.saude.srv.model.Unidade;
import br.gov.al.saude.srv.model.dto.CargoDTO;
import br.gov.al.saude.srv.model.dto.FuncaoDTO;
import br.gov.al.saude.srv.model.dto.ParametroConsultaServidorAtivoDTO;
import br.gov.al.saude.srv.model.dto.ParametroConsultaServidorDTO;
import br.gov.al.saude.srv.model.enums.TipoFuncao;
import br.gov.al.saude.srv.model.enums.TipoSituacaoCadastral;
import br.gov.al.saude.srv.model.enums.TipoVinculo;
import br.gov.al.saude.framework.model.SetorView;
import br.gov.al.saude.test.builder.CargoBuilder;
import br.gov.al.saude.test.builder.CarreiraBuilder;
import br.gov.al.saude.test.builder.DeficienciaBuilder;
import br.gov.al.saude.test.builder.FormaIngressoBuilder;
import br.gov.al.saude.test.builder.FuncaoBuilder;
import br.gov.al.saude.test.builder.GrauInstrucaoBuilder;
import br.gov.al.saude.test.builder.NacionalidadeBuilder;
import br.gov.al.saude.test.builder.OrgaoBuilder;
import br.gov.al.saude.test.builder.ServidorBuilder;
import br.gov.al.saude.test.builder.ServidorDadoFuncionalContratadoEstagiarioBuilder;
import br.gov.al.saude.test.builder.ServidorDadoFuncionalContratadoPrestadorProcessoSeletivoBuilder;
import br.gov.al.saude.test.builder.ServidorDadoFuncionalMatriculaBuilder;
import br.gov.al.saude.test.builder.ServidorDadoFuncionalMatriculaCarreiraBuilder;
import br.gov.al.saude.test.builder.ServidorDependenteBuilder;
import br.gov.al.saude.test.builder.ServidorQualificacaoBuilder;
import br.gov.al.saude.test.builder.SetorViewBuilder;
import br.gov.al.saude.test.builder.SituacaoServidorBuilder;
import br.gov.al.saude.test.builder.UnidadeBuilder;
import br.gov.al.saude.test.builder.UsuarioViewBuilder;
import br.gov.al.saude.test.unidade.generic.service.ServiceImplTest;
import br.gov.al.saude.test.util.CommandSemMensagem;
import br.gov.al.saude.test.util.FileUtil;
import br.gov.al.saude.test.util.VerificadorLancamentoException;

public class ServidorServiceImplTest extends ServiceImplTest<Servidor> {

        private ServidorService servidorService;
        private ServidorRepository servidorRepositoryMock;
        private CargoRepository cargoRepositoryMock;
        private FuncaoRepository funcaoRepositoryMock;
        private ParametroRepository parametroRepositoryMock;
        private GeradorRelatorioServidor geradorRelatorioServidorMock;
       
        @Before
        public void inicializarContexto() {
                super.inicializarContexto();
                servidorRepositoryMock = getContexto().mock(ServidorRepository.class);
                validadorMock = getContexto().mock(Validador.class);
                geradorRelatorioServidorMock = getContexto().mock(GeradorRelatorioServidor.class);
                cargoRepositoryMock = getContexto().mock(CargoRepository.class);
                funcaoRepositoryMock = getContexto().mock(FuncaoRepository.class);
                parametroRepositoryMock = getContexto().mock(ParametroRepository.class);
                servidorService = new ServidorServiceImpl(validadorMock, servidorRepositoryMock, cargoRepositoryMock,
                                funcaoRepositoryMock, parametroRepositoryMock, geradorRelatorioServidorMock);
                setEntidade(gerarServidorCompleto());
        }
       
        @Override
        protected GenericService<Servidor> getService() {
                return servidorService;
        }

        @Override
        protected GenericRepository<Servidor> getRepositoryMock() {
                return servidorRepositoryMock;
        }
       
        @Test
        public void aoConsultarServidorPorSequencialDeveriaDelegarParaOhRepositorio() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarServidorPorSequencial(with(new Long(SEQUENCIAL_PESSOA_ANDERSON_SILVA_7)));
                        will(returnValue(new Servidor()));
                }});
               
                servidorService.consultarServidorPorSequencial(new Long(SEQUENCIAL_PESSOA_ANDERSON_SILVA_7));
        }
       
        @Test
        public void aoConsultarPessoaPorSequencialDeveriaDelegarParaOhRepositorio() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarPessoaPorSequencial(with(any(Long.class)));
                        will(returnValue(new PessoaFisicaView()));
                }});
               
                servidorService.consultarPessoaPorSequencial(Long.parseLong(SEQUENCIAL_PESSOA_ANDERSON_SILVA_7));
        }
       
        @Test
        public void aoAtualizarServidorLegadoDeveriaDelegarParaOhRepositorio() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).atualizarServidorLegado(with(any(Servidor.class)));
                }});
               
                servidorService.atualizarServidorLegado(new Servidor());
        }

        @Test
        public void aoEmitirFichaCadastralDeveriaParaOhGeradorRelatorio() {
                getContexto().checking(new Expectations(){{
                        oneOf(geradorRelatorioServidorMock).emitirFichaCadastral(Long.parseLong(SEQUENCIAL_PESSOA_ANDERSON_SILVA_7));
                        will(returnValue(new JasperPrint()));
                }});
               
                servidorService.emitirFichaCadastral(Long.parseLong(SEQUENCIAL_PESSOA_ANDERSON_SILVA_7));
        }

        @Test
        public void aoAtualizarCadastrandoServidorDeveriaDelegarParaRepositorio() {
               
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoComVagas()));
                        oneOf(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        will(returnValue(gerarFuncaoComVagas()));
                        oneOf(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        will(returnValue(gerarParametroQuantidadeVagasFuncaoGratificada()));
                        oneOf(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        will(returnValue(0));
                        oneOf(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                servidorService.atualizarServidor(getEntidade());
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComFotoDeveriaDelegarParaRepositorio() {
                getEntidade().setFoto(FileUtil.getConteudoArquivoImagem(DIRETORIO_FOTOS, NOME_FOTO_PNG));
               
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoComVagas()));
                        oneOf(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        will(returnValue(gerarFuncaoComVagas()));
                        oneOf(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        will(returnValue(gerarParametroQuantidadeVagasFuncaoGratificada()));
                        oneOf(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        will(returnValue(0));
                        oneOf(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                servidorService.atualizarServidor(getEntidade());
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorSemDadosFuncionaisDeveriaDelegarParaRepositorio() {
                getEntidade().getListaServidorDadoFuncional().clear();

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        will(returnValue(gerarParametroQuantidadeVagasFuncaoGratificada()));
                        oneOf(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        will(returnValue(0));
                        oneOf(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                servidorService.atualizarServidor(getEntidade());
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComDadosAtivosEeInativosDeveriaDelegarParaRepositorio() {

                final ServidorDadoFuncional dadoFuncionalExonerado = gerarDadoFuncionalTipoMatriculaExonerado();
                dadoFuncionalExonerado.setServidor(getEntidade());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalExonerado);
               
                final ServidorDadoFuncional dadoFuncionalInativo = gerarDadoFuncionalTipoPrestadorInativo();
                dadoFuncionalInativo.setServidor(getEntidade());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalInativo);
               
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalExonerado)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalExonerado)));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoComVagas()));
                        oneOf(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        will(returnValue(gerarFuncaoComVagas()));
                        oneOf(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        will(returnValue(gerarParametroQuantidadeVagasFuncaoGratificada()));
                        oneOf(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        will(returnValue(0));
                        oneOf(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                servidorService.atualizarServidor(getEntidade());
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComDadoFuncionalComissionadoSemFuncaoDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalSemFuncao = gerarDadoFuncionalTipoMatricula();
                ((ServidorDadoFuncionalMatricula)dadoFuncionalSemFuncao).setFuncao(null);
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalSemFuncao);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        never(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        never(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, OBRIGATORIO_INFORMAR_FUNCAO);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComMatriculaServidorAtivoJaCadastradaDeveriaLancarExcecao() {
               
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(gerarServidorMesmaMatricula()));
                        never(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, MSG_ERRO_JA_EXISTE_SERVIDOR_ATIVO_CADASTRADO_COM_MATRICULA_INFORMADA +
                        " Servidor: " + gerarServidorMesmaMatricula().getPessoa().getNumeroDocumento() + " - " + gerarServidorMesmaMatricula().getNomeDaPessoa());
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComNumeroOrdemServidorAtivoJaCadastradaDeveriaLancarExcecao() {

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(true));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, MSG_ERRO_NUMERO_ORDEM_JA_CADASTRADO);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComCargoDiferenteTipoPrestadorEmMesmaUnidadeLotacaoDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalCargoDiferente = gerarDadoFuncionalTipoPrestador();
                ((ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo)dadoFuncionalCargoDiferente).setCargo(new CargoBuilder().comCodigo(SEQUENCIAL_CARGO_9).build());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargoDiferente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, SERVIDOR_POSSUI_DADO_FUNCIONAL_ATIVO_COM_CARGO_NA_UNIDADE_LOTACAO);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComCargoDiferenteTipoMatriculaEmMesmaUnidadeLotacaoDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalPrestador = gerarDadoFuncionalTipoPrestador();
                dadoFuncionalPrestador.setServidor(getEntidade());

                List<ServidorDadoFuncional> listaDadosFuncionais = new ArrayList<ServidorDadoFuncional>(getEntidade().getListaServidorDadoFuncional());
                listaDadosFuncionais.remove(dadoFuncionalPrestador);
                getEntidade().setListaServidorDadoFuncional(new HashSet<ServidorDadoFuncional>(listaDadosFuncionais));
               
                final ServidorDadoFuncional dadoFuncionalCargoDiferente = gerarDadoFuncionalTipoMatriculaCarreira();
                ((ServidorDadoFuncionalMatriculaCarreira)dadoFuncionalCargoDiferente).setCargoCarreira(new CargoBuilder().comCodigo(SEQUENCIAL_CARGO_9).build());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargoDiferente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalCargoDiferente)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalCargoDiferente)));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, SERVIDOR_POSSUI_DADO_FUNCIONAL_ATIVO_COM_CARGO_NA_UNIDADE_LOTACAO);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComTipoEfetivoCarreiraMedicaEeTipoMatriculaExcedendoLimite64HorasDeveriaLancarExcecao() {
               
                final ServidorDadoFuncional dadoFuncionalCargaHorariaExcedente = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCargaHorariaExcedente.setCargaHoraria(new Integer(CARGA_HORARIA_20));
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargaHorariaExcedente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalCargaHorariaExcedente)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalCargaHorariaExcedente)));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_CARGA_HORARIA_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComTipoCeletistaCarreiraMedicaEeTipoMatriculaExcedendoLimite64HorasDeveriaLancarExcecao() {
               
                final ServidorDadoFuncional dadoFuncionalCargaHorariaExcedente = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCargaHorariaExcedente.setFormaIngresso(gerarFormaIngresso(FormaIngresso.FORMA_INGRESSO_CONCURSADO, TipoVinculo.CELETISTA));
                dadoFuncionalCargaHorariaExcedente.setCargaHoraria(new Integer(CARGA_HORARIA_20));
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargaHorariaExcedente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalCargaHorariaExcedente)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalCargaHorariaExcedente)));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_CARGA_HORARIA_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorTipoEfetivoComCarreiraMedicaEeTipoPrestadorExcedendoLimite64HorasDeveriaLancarExcecao() {
               
                final ServidorDadoFuncional dadoFuncionalCargaHorariaExcedente = gerarDadoFuncionalTipoPrestador();
                dadoFuncionalCargaHorariaExcedente.setCargaHoraria(new Integer(CARGA_HORARIA_20));
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargaHorariaExcedente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_CARGA_HORARIA_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComTipoEfetivoEeTipoMatriculaExcedendoLimite60HorasDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalCarreiraMedica = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCarreiraMedica.setServidor(getEntidade());

                List<ServidorDadoFuncional> listaDadosFuncionais = new ArrayList<ServidorDadoFuncional>(getEntidade().getListaServidorDadoFuncional());
                listaDadosFuncionais.remove(dadoFuncionalCarreiraMedica);
                getEntidade().setListaServidorDadoFuncional(new HashSet<ServidorDadoFuncional>(listaDadosFuncionais));

                final ServidorDadoFuncional dadoFuncionalSemCarreiraMedica = gerarDadoFuncionalTipoMatriculaCarreira();
                ((ServidorDadoFuncionalMatriculaCarreira)dadoFuncionalSemCarreiraMedica).setCarreira(new CarreiraBuilder().comCodigo(SEQUENCIAL_CARREIRA_APOIO_SAUDE_9).build());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalSemCarreiraMedica);
               
                final ServidorDadoFuncional dadoFuncionalCargaHorariaExcedente = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCargaHorariaExcedente.setCargaHoraria(new Integer(CARGA_HORARIA_20));
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargaHorariaExcedente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalSemCarreiraMedica)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalCargaHorariaExcedente)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalSemCarreiraMedica)));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalCargaHorariaExcedente)));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_CARGA_HORARIA_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComTipoEfetivoEeTipoPrestadorExcedendoLimite60HorasDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalCarreiraMedica = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCarreiraMedica.setServidor(getEntidade());

                List<ServidorDadoFuncional> listaDadosFuncionais = new ArrayList<ServidorDadoFuncional>(getEntidade().getListaServidorDadoFuncional());
                listaDadosFuncionais.remove(dadoFuncionalCarreiraMedica);
                getEntidade().setListaServidorDadoFuncional(new HashSet<ServidorDadoFuncional>(listaDadosFuncionais));

                final ServidorDadoFuncional dadoFuncionalSemCarreiraMedica = gerarDadoFuncionalTipoMatriculaCarreira();
                ((ServidorDadoFuncionalMatriculaCarreira)dadoFuncionalSemCarreiraMedica).setCarreira(new CarreiraBuilder().comCodigo(SEQUENCIAL_CARREIRA_APOIO_SAUDE_9).build());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalSemCarreiraMedica);
               
                final ServidorDadoFuncional dadoFuncionalCargaHorariaExcedente = gerarDadoFuncionalTipoPrestador();
                dadoFuncionalCargaHorariaExcedente.setCargaHoraria(new Integer(CARGA_HORARIA_20));
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargaHorariaExcedente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalSemCarreiraMedica)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalSemCarreiraMedica)));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_CARGA_HORARIA_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComTipoEfetivoEeTipoPrestadorNaoExcedendoLimite60HorasDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalCarreiraMedica = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCarreiraMedica.setServidor(getEntidade());

                List<ServidorDadoFuncional> listaDadosFuncionais = new ArrayList<ServidorDadoFuncional>(getEntidade().getListaServidorDadoFuncional());
                listaDadosFuncionais.remove(dadoFuncionalCarreiraMedica);
                getEntidade().setListaServidorDadoFuncional(new HashSet<ServidorDadoFuncional>(listaDadosFuncionais));

                final ServidorDadoFuncional dadoFuncionalSemCarreiraMedica = gerarDadoFuncionalTipoMatriculaCarreira();
                ((ServidorDadoFuncionalMatriculaCarreira)dadoFuncionalSemCarreiraMedica).setCarreira(new CarreiraBuilder().comCodigo(SEQUENCIAL_CARREIRA_APOIO_SAUDE_9).build());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalSemCarreiraMedica);
               
                final ServidorDadoFuncional dadoFuncionalCargaHorariaExcedente = gerarDadoFuncionalTipoPrestador();
                dadoFuncionalCargaHorariaExcedente.setCargaHoraria(new Integer(CARGA_HORARIA_10));
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargaHorariaExcedente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalSemCarreiraMedica)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalSemCarreiraMedica)));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(null));
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, null);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComTipoEfetivoComCargoSemVagasDeveriaLancarExcecao() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoSemVagas()));
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, "O limite de vagas para o cargo " + gerarCargoSemVagas().getDescricao() + " foi atingido.");
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComTipoComissionadoComFuncaoSemVagasDeveriaLancarExcecao() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoComVagas()));
                        oneOf(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        will(returnValue(gerarFuncaoSemVagas()));
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, "O limite de vagas para a função " + gerarFuncaoSemVagas().getNivel() + " - " + gerarFuncaoSemVagas().getTipo().getDescricao() + " foi atingido.");
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComQuantidadeFuncaoGratificadaExcedendoLimiteDeveriaLancarExcecao() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoComVagas()));
                        oneOf(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        will(returnValue(gerarFuncaoComVagas()));
                        oneOf(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        will(returnValue(gerarParametroQuantidadeVagasFuncaoGratificada()));
                        oneOf(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        will(returnValue(1));
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_VAGAS_FUNCAO_TIPO_GRATIFICADA_FOI_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarCadastrandoServidorComFotoDeFormatoInvalidoDeveriaLancarExcecao() {
                getEntidade().setFoto(FileUtil.getConteudoArquivoImagem(DIRETORIO_FOTOS, NOME_FOTO_GIF));
               
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(false));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Cadastrar.class}));
                        never(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        never(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, EXTENSAO_ARQUIVO_FOTO_INVALIDA);
        }

        @Test
        public void aoAtualizarAlterandoServidorDeveriaDelegarParaRepositorio() {
               
                final ServidorDadoFuncional dadoFuncionalCadastrado = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCadastrado.setSequencial(new Long(NOSSO_NUMERO_SERVIDOR_DADO_FUNCIONAL_105));
                dadoFuncionalCadastrado.setCargaHoraria(new Integer(CARGA_HORARIA_10));
                ((ServidorDadoFuncionalMatriculaCarreira)dadoFuncionalCadastrado).setSituacaoServidor(new SituacaoServidorBuilder().comCodigo(SEQUENCIAL_SITUACAO_SERVIDOR_EXONERADO_2).build());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCadastrado);
               
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalCadastrado)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalCadastrado)));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoComVagas()));
                        oneOf(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        will(returnValue(gerarFuncaoComVagas()));
                        oneOf(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        will(returnValue(gerarParametroQuantidadeVagasFuncaoGratificada()));
                        oneOf(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        will(returnValue(0));
                        oneOf(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                servidorService.atualizarServidor(getEntidade());
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComFotoDeveriaDelegarParaRepositorio() {
                getEntidade().setFoto(FileUtil.getConteudoArquivoImagem(DIRETORIO_FOTOS, NOME_FOTO_JPEG));

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoComVagas()));
                        oneOf(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        will(returnValue(gerarFuncaoComVagas()));
                        oneOf(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        will(returnValue(gerarParametroQuantidadeVagasFuncaoGratificada()));
                        oneOf(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        will(returnValue(0));
                        oneOf(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                servidorService.atualizarServidor(getEntidade());
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComDadoFuncionalComissionadoSemFuncaoDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalSemFuncao = gerarDadoFuncionalTipoMatricula();
                ((ServidorDadoFuncionalMatricula)dadoFuncionalSemFuncao).setFuncao(null);
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalSemFuncao);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        never(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        never(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).cadastrar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, OBRIGATORIO_INFORMAR_FUNCAO);
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComMatriculaServidorAtivoJaCadastradaDeveriaLancarExcecao() {
               
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(gerarServidorMesmaMatricula()));
                        never(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, MSG_ERRO_JA_EXISTE_SERVIDOR_ATIVO_CADASTRADO_COM_MATRICULA_INFORMADA +
                        " Servidor: " + gerarServidorMesmaMatricula().getPessoa().getNumeroDocumento() + " - " + gerarServidorMesmaMatricula().getNomeDaPessoa());
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComNumeroOrdemServidorAtivoJaCadastradaDeveriaLancarExcecao() {

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(true));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, MSG_ERRO_NUMERO_ORDEM_JA_CADASTRADO);
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComCargoDiferenteTipoPrestadorEmMesmaUnidadeLotacaoDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalCargoDiferente = gerarDadoFuncionalTipoPrestador();
                ((ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo)dadoFuncionalCargoDiferente).setCargo(new CargoBuilder().comCodigo(SEQUENCIAL_CARGO_9).build());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargoDiferente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, SERVIDOR_POSSUI_DADO_FUNCIONAL_ATIVO_COM_CARGO_NA_UNIDADE_LOTACAO);
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComCargoDiferenteTipoMatriculaEmMesmaUnidadeLotacaoDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalPrestador = gerarDadoFuncionalTipoPrestador();
                dadoFuncionalPrestador.setServidor(getEntidade());

                List<ServidorDadoFuncional> listaDadosFuncionais = new ArrayList<ServidorDadoFuncional>(getEntidade().getListaServidorDadoFuncional());
                listaDadosFuncionais.remove(dadoFuncionalPrestador);
                getEntidade().setListaServidorDadoFuncional(new HashSet<ServidorDadoFuncional>(listaDadosFuncionais));

                final ServidorDadoFuncional dadoFuncionalCargoDiferente = gerarDadoFuncionalTipoMatriculaCarreira();
                ((ServidorDadoFuncionalMatriculaCarreira)dadoFuncionalCargoDiferente).setCargoCarreira(new CargoBuilder().comCodigo(SEQUENCIAL_CARGO_9).build());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargoDiferente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalCargoDiferente)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalCargoDiferente)));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, SERVIDOR_POSSUI_DADO_FUNCIONAL_ATIVO_COM_CARGO_NA_UNIDADE_LOTACAO);
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComTipoEfetivoCarreiraMedicaEeTipoMatriculaExcedendoLimite64HorasDeveriaLancarExcecao() {
               
                final ServidorDadoFuncional dadoFuncionalCargaHorariaExcedente = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCargaHorariaExcedente.setCargaHoraria(new Integer(CARGA_HORARIA_20));
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargaHorariaExcedente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalCargaHorariaExcedente)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalCargaHorariaExcedente)));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_CARGA_HORARIA_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarAlterandoServidorTipoEfetivoComCarreiraMedicaEeTipoPrestadorExcedendoLimite64HorasDeveriaLancarExcecao() {
               
                final ServidorDadoFuncional dadoFuncionalCargaHorariaExcedente = gerarDadoFuncionalTipoPrestador();
                dadoFuncionalCargaHorariaExcedente.setCargaHoraria(new Integer(CARGA_HORARIA_20));
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargaHorariaExcedente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_CARGA_HORARIA_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComTipoEfetivoEeTipoMatriculaExcedendoLimite60HorasDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalCarreiraMedica = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCarreiraMedica.setServidor(getEntidade());

                List<ServidorDadoFuncional> listaDadosFuncionais = new ArrayList<ServidorDadoFuncional>(getEntidade().getListaServidorDadoFuncional());
                listaDadosFuncionais.remove(dadoFuncionalCarreiraMedica);
                getEntidade().setListaServidorDadoFuncional(new HashSet<ServidorDadoFuncional>(listaDadosFuncionais));

                final ServidorDadoFuncional dadoFuncionalSemCarreiraMedica = gerarDadoFuncionalTipoMatriculaCarreira();
                ((ServidorDadoFuncionalMatriculaCarreira)dadoFuncionalSemCarreiraMedica).setCarreira(new CarreiraBuilder().comCodigo(SEQUENCIAL_CARREIRA_APOIO_SAUDE_9).build());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalSemCarreiraMedica);
               
                final ServidorDadoFuncional dadoFuncionalCargaHorariaExcedente = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCargaHorariaExcedente.setCargaHoraria(new Integer(CARGA_HORARIA_20));
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargaHorariaExcedente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalSemCarreiraMedica)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalCargaHorariaExcedente)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalSemCarreiraMedica)));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalCargaHorariaExcedente)));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_CARGA_HORARIA_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComTipoEfetivoEeTipoPrestadorExcedendoLimite60HorasDeveriaLancarExcecao() {
               
                ServidorDadoFuncional dadoFuncionalCarreiraMedica = gerarDadoFuncionalTipoMatriculaCarreira();
                dadoFuncionalCarreiraMedica.setServidor(getEntidade());

                List<ServidorDadoFuncional> listaDadosFuncionais = new ArrayList<ServidorDadoFuncional>(getEntidade().getListaServidorDadoFuncional());
                listaDadosFuncionais.remove(dadoFuncionalCarreiraMedica);
                getEntidade().setListaServidorDadoFuncional(new HashSet<ServidorDadoFuncional>(listaDadosFuncionais));

                final ServidorDadoFuncional dadoFuncionalSemCarreiraMedica = gerarDadoFuncionalTipoMatriculaCarreira();
                ((ServidorDadoFuncionalMatriculaCarreira)dadoFuncionalSemCarreiraMedica).setCarreira(new CarreiraBuilder().comCodigo(SEQUENCIAL_CARREIRA_APOIO_SAUDE_9).build());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalSemCarreiraMedica);
               
                final ServidorDadoFuncional dadoFuncionalCargaHorariaExcedente = gerarDadoFuncionalTipoPrestador();
                dadoFuncionalCargaHorariaExcedente.setCargaHoraria(new Integer(CARGA_HORARIA_20));
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalCargaHorariaExcedente);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(dadoFuncionalSemCarreiraMedica)));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(dadoFuncionalSemCarreiraMedica)));
                        will(returnValue(false));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_CARGA_HORARIA_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComTipoEfetivoComCargoSemVagasDeveriaLancarExcecao() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoSemVagas()));
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, "O limite de vagas para o cargo " + gerarCargoSemVagas().getDescricao() + " foi atingido.");
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComTipoComissionadoComFuncaoSemVagasDeveriaLancarExcecao() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoComVagas()));
                        oneOf(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        will(returnValue(gerarFuncaoSemVagas()));
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, "O limite de vagas para a função " + gerarFuncaoSemVagas().getNivel() + " - " + gerarFuncaoSemVagas().getTipo().getDescricao() + " foi atingido.");
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComQuantidadeFuncaoGratificadaExcedendoLimiteDeveriaLancarExcecao() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoComVagas()));
                        oneOf(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        will(returnValue(gerarFuncaoComVagas()));
                        oneOf(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        will(returnValue(gerarParametroQuantidadeVagasFuncaoGratificada()));
                        oneOf(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        will(returnValue(1));
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, LIMITE_VAGAS_FUNCAO_TIPO_GRATIFICADA_FOI_ATINGIDO);
        }
       
        @Test
        public void aoAtualizarAlterandoServidorComFotoDeFormatoInvalidoDeveriaLancarExcecao() {
                getEntidade().setFoto(FileUtil.getConteudoArquivoImagem(DIRETORIO_FOTOS, NOME_FOTO_GIF));

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarSeExisteServidorPassandoRestricoes(gerarListaRestricoesConsultarServidorExiste(getEntidade()));
                        will(returnValue(true));
                        oneOf(getValidadorMock()).validar(with(getEntidade()), with(new Class<?>[]{Alterar.class}));
                        never(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        never(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        never(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        never(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        never(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        never(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        never(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});
               
                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.atualizarServidor(getEntidade());
                        }
                }, EXTENSAO_ARQUIVO_FOTO_INVALIDA);
        }

        @Test
        public void aoAlterarSituacaoCadastralServidorDeveriaDelegarParaRepositorio() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).alterar(getEntidade());
                }});

                servidorService.alterarSituacaoFichaCadastral(getEntidade(), TipoSituacaoCadastral.HOMOLOGADO);
        }
       
        @Test
        public void aoAlterarSituacaoCadastralServidorComUsuarioTecnicoSEREeDadoFuncionalApenasEstagiarioDeveriaDelegarParaRepositorio() {
                getEntidade().setUsuarioAlteracaoSituacaoCadastral(gerarUsuarioComPermissaoTecnicoSER());
                getEntidade().getListaServidorDadoFuncional().clear();
               
                ServidorDadoFuncional dadoFuncionalEstagiario = gerarDadoFuncionalTipoEstagiario();
                dadoFuncionalEstagiario.setServidor(getEntidade());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalEstagiario);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).alterar(getEntidade());
                }});

                servidorService.alterarSituacaoFichaCadastral(getEntidade(), TipoSituacaoCadastral.HOMOLOGADO);
        }
       
        @Test
        public void aoAlterarSituacaoCadastralServidorComUsuarioTecnicoSAFPEeDadoFuncionalApenasPrestadorDeveriaDelegarParaRepositorio() {
                getEntidade().setUsuarioAlteracaoSituacaoCadastral(gerarUsuarioComPermissaoTecnicoSAFP());
                getEntidade().getListaServidorDadoFuncional().clear();
               
                ServidorDadoFuncional dadoFuncionalPrestador = gerarDadoFuncionalTipoPrestador();
                dadoFuncionalPrestador.setServidor(getEntidade());
                getEntidade().getListaServidorDadoFuncional().add(dadoFuncionalPrestador);

                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).alterar(getEntidade());
                }});

                servidorService.alterarSituacaoFichaCadastral(getEntidade(), TipoSituacaoCadastral.HOMOLOGADO);
        }

        @Test
        public void aoAlterarSituacaoCadastralServidorComUsuarioTecnicoSEREeDadoFuncionalDiferenteEstagiarioDeveriaLancarExcecao() {
                getEntidade().setUsuarioAlteracaoSituacaoCadastral(gerarUsuarioComPermissaoTecnicoSER());
               
                getContexto().checking(new Expectations(){{
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});

                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.alterarSituacaoFichaCadastral(getEntidade(), TipoSituacaoCadastral.HOMOLOGADO);
                        }
                }, MSG_ERRO_NAO_EH_PERMITIDO_ALTERAR_SITUACAO_SERVIDOR_COM_DADO_FUNCIONAL_DIFERENTE_ESTAGIARIO);
        }
       
        @Test
        public void aoAlterarSituacaoCadastralServidorComUsuarioTecnicoSAFPEeDadoFuncionalDiferentePrestadorDeveriaLancarExcecao() {
                getEntidade().setUsuarioAlteracaoSituacaoCadastral(gerarUsuarioComPermissaoTecnicoSAFP());

                getContexto().checking(new Expectations(){{
                        never(servidorRepositoryMock).alterar(getEntidade());
                }});

                VerificadorLancamentoException.verificarMensagemLancamentoExceptionSemRetornoMensagem(new CommandSemMensagem() {
                        @Override
                        public void execute() throws Exception {
                                servidorService.alterarSituacaoFichaCadastral(getEntidade(), TipoSituacaoCadastral.HOMOLOGADO);
                        }
                }, MSG_ERRO_NAO_EH_PERMITIDO_ALTERAR_SITUACAO_SERVIDOR_COM_DADO_FUNCIONAL_DIFERENTE_PRESTADOR);
        }
       
        @Test
        public void aoConsultarDeveriaDelegarParaOhRepositorio() throws Exception {
                final ParametroConsultaServidorDTO parametroConsultaServidorDTO = new ParametroConsultaServidorDTO();
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultar(parametroConsultaServidorDTO);
                }});
               
                servidorService.consultar(parametroConsultaServidorDTO);
        }
       
        @Test
        public void aoObterQuantidadeDeRegistrosDeveriaDelegarParaOhRepositorio() throws Exception {
                final ParametroConsultaServidorDTO parametroConsultaServidorDTO = new ParametroConsultaServidorDTO();
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).obterQuantidadeDeRegistros(parametroConsultaServidorDTO);
                }});
               
                servidorService.obterQuantidadeDeRegistros(parametroConsultaServidorDTO);
        }
       
        @Test
        public void aoConsultarServidorPorNossoNumeroDeveriaDelegarParaOhServico() throws Exception {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarServidorPorNossoNumero(with(any(Long.class)));
                }});
               
                servidorService.consultarServidorPorNossoNumero(new Long(1l));
        }
       
        @Test
        public void aoConsultarServidorAtivoDeveriaDelegarParaOhRepositorio() throws Exception {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarServidorUnidade(with(any(ParametroConsultaServidorAtivoDTO.class)));
                }});
               
                servidorService.consultarServidorAtivo(new ParametroConsultaServidorAtivoDTO());
        }
       
        @Test
        public void aoConsultarServidorNaoPendenteDeveriaDelegarParaOhRepositorio() throws Exception {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarServidorUnidade(with(any(ParametroConsultaServidorAtivoDTO.class)));
                }});
               
                servidorService.consultarServidorNaoPendente(new ParametroConsultaServidorAtivoDTO());
        }
       
        @Test
        public void aoObterQuantidadeDeRegistrosParaConsultarServidorAtivoDeveriaDelegarParaOhRepositorio() throws Exception {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).obterQuantidadeDeRegistrosParaServidorUnidade(with(any(ParametroConsultaServidorAtivoDTO.class)));
                }});
               
                servidorService.obterQuantidadeDeRegistrosParaConsultarServidorAtivo(new ParametroConsultaServidorAtivoDTO());
        }
       
        @Test
        public void aoObterQuantidadeDeRegistrosParaConsultarServidorNaoPendenteDeveriaDelegarParaOhRepositorio() throws Exception {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).obterQuantidadeDeRegistrosParaServidorUnidade(with(any(ParametroConsultaServidorAtivoDTO.class)));
                }});
               
                servidorService.obterQuantidadeDeRegistrosParaConsultarServidorNaoPendente(new ParametroConsultaServidorAtivoDTO());
        }

               
        @Override
        protected void expectativasDeNegocioFuncionalidadeCadastrar() {
                expectativasDeNegocioFuncionalidadesCadastrarEeAlterar();
        };
       
        @Override
        protected void expectativasDeNegocioFuncionalidadeAlterar() {
                expectativasDeNegocioFuncionalidadesCadastrarEeAlterar();
        }
       
        private void expectativasDeNegocioFuncionalidadesCadastrarEeAlterar() {
                getContexto().checking(new Expectations(){{
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarServidorPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmaMatricula(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(null));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatricula())));
                        will(returnValue(false));
                        oneOf(servidorRepositoryMock).consultarSeExisteDadoFuncionalPassandoRestricoes(with(gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(gerarDadoFuncionalTipoMatriculaCarreira())));
                        will(returnValue(false));
                        oneOf(cargoRepositoryMock).consultarCargoAtivo(((ServidorDadoFuncionalMatriculaCarreira)gerarDadoFuncionalTipoMatriculaCarreira()).getCargoCarreira());
                        will(returnValue(gerarCargoComVagas()));
                        oneOf(funcaoRepositoryMock).consultarFuncaoAtiva(((ServidorDadoFuncionalMatricula)gerarDadoFuncionalTipoMatricula()).getFuncao());
                        will(returnValue(gerarFuncaoComVagas()));
                        oneOf(parametroRepositoryMock).consultarPorId(gerarParametroConsultaQuantidadeVagasFuncaoGratificada());
                        will(returnValue(gerarParametroQuantidadeVagasFuncaoGratificada()));
                        oneOf(servidorRepositoryMock).obterQuantidadeRegistrosParaFuncaoGratificada();
                        will(returnValue(0));
                }});
        }

        private Servidor gerarServidorMesmaMatricula() {
                Servidor servidor = new ServidorBuilder()
                        .comPessoa(gerarPessoaFisicaYanne())
                        .build();

                return servidor;
        }
       
        private PessoaFisicaView gerarPessoaFisicaYanne() {
                PessoaFisicaView pessoa = new PessoaFisicaView();
                pessoa.setSequencialPessoa(new Long(SEQUENCIAL_PESSOA_13));
                pessoa.setNumeroDocumento(NUMERO_CPF_03147532062);
                pessoa.setNomePessoa(NOME_PESSOA_YANNE_ALMEIDA);
                return pessoa;
        }
       
        private Servidor gerarServidorCompleto() {
                Servidor servidor = new ServidorBuilder()
                        .comGrauInstrucao(new GrauInstrucaoBuilder().comCodigo(SEQUENCIAL_GRAU_INSTRUCAO_SUPERIOR_4).build())
                        .comNacionalidade(new NacionalidadeBuilder().comCodigo(SEQUENCIAL_NACIONALIDADE_BRASILEIRA_1).build())
                        .comDeficiencia(new DeficienciaBuilder().comCodigo(SEQUENCIAL_DEFICIENCIA_FISICA_3).build())
                        .comDependente(gerarDependentes())
                        .comQualificacao(gerarQualificacoes())
                        .comDadoFuncional(gerarDadosFuncionais())
                        .comUsuarioCadastro(SEQUENCIAL_USUARIO_3)
                        .comUsuarioAlteracaoSituacaoCadastral(gerarUsuarioComPermissoesCompletas())
                .build();

                return servidor;
        }

        private Set<ServidorDependente> gerarDependentes() {
                Set<ServidorDependente> dependentes = new HashSet<ServidorDependente>();

                ServidorDependente servidorDependente = new ServidorDependenteBuilder()
                        .comNome(NOME_PESSOA_JOSE_MARIA)
                        .comCPF(NUMERO_CPF_07771278495)
                        .comDataNascimento(DATA_NASCIMENTO_01_01_1995)
                        .comSexo(DESCRICAO_SEXO_MASCULINO)
                        .comTipoParentesco(GRAU_PARENTESCO_FILHO_F)
                        .build();

                dependentes.add(servidorDependente);

                return dependentes;
        }
       
        private Set<ServidorQualificacao> gerarQualificacoes() {
                Set<ServidorQualificacao> qualificacoes = new HashSet<ServidorQualificacao>();
                       
                ServidorQualificacao servidorQualificacao = new ServidorQualificacaoBuilder()
                        .comTipoQualificacao(TIPO_QUALIFICACAO_FORMACAO_ACADEMICA_A)
                        .comDescricao(DESCRICAO_CURSO_ANALISE_SISTEMAS)
                        .comInstituicao(INSTITUICAO_CESMAC)
                        .comCargaHoraria(NUMERO_CARGA_HORARIA_10)
                        .comDataInicial(DATA_INICIAL_01_01_2012)
                        .comDataFinal(DATA_FINAL_01_03_2012)
                        .build();

                qualificacoes.add(servidorQualificacao);
               
                return qualificacoes;
        }
       
        private Set<ServidorDadoFuncional> gerarDadosFuncionais() {
                Set<ServidorDadoFuncional> dadosFuncionais = new HashSet<ServidorDadoFuncional>();
               
                dadosFuncionais.add(gerarDadoFuncionalTipoMatricula());
                dadosFuncionais.add(gerarDadoFuncionalTipoMatriculaCarreira());
                dadosFuncionais.add(gerarDadoFuncionalTipoEstagiario());
                dadosFuncionais.add(gerarDadoFuncionalTipoPrestador());
               
                return dadosFuncionais;
        }
       
        private FormaIngresso gerarFormaIngresso(Integer codigo, TipoVinculo tipoVinculo) {
                return new FormaIngressoBuilder().comCodigo(codigo.toString()).comTipoVinculo(tipoVinculo).build();
        }
       
        private Orgao gerarOrgao(String codigoOrgao) {
                return new OrgaoBuilder().comSequencial(codigoOrgao).build();
        }
       
        private Unidade gerarUnidade(String codigoUnidade) {
                return new UnidadeBuilder().comCodigo(codigoUnidade).build();
        }
       
        private SetorView gerarSetor(String codigoSetor) {
                return new SetorViewBuilder().comCodigo(codigoSetor).build();
        }
       
        private Funcao gerarFuncaoGratificada(String codigo) {
                return new FuncaoBuilder().comCodigo(codigo).comTipoFuncao(TipoFuncao.FUNCAO_GRATIFICADA.getValue()).comAtivo(ATIVO_SIM).build();
        }
       
        private Funcao gerarFuncaoCargoComissionado(String codigo) {
                return new FuncaoBuilder().comCodigo(codigo).comTipoFuncao(TipoFuncao.CARGO_COMISSIONADO.getValue()).comAtivo(ATIVO_SIM).build();
        }

        private ServidorDadoFuncional gerarDadoFuncionalTipoMatricula() {
                ServidorDadoFuncionalMatricula servidorDadoFuncional = new ServidorDadoFuncionalMatriculaBuilder()
                        .comMatricula(NUMERO_MATRICULA_96754522)
                        .comDigitoMatricula(DIGITO_MATRICULA_0)
                        .comNumeroOrdem(NUMERO_ORDEM_3542)
                        .comSituacaoServidor(SEQUENCIAL_SITUACAO_SERVIDOR_ATIVO_1)
                        .comDataNomeacao(DATA_INICIO_01_01_2011)
                        .comDataPosse(DATA_INICIO_01_01_2011)
                        .comDataExercicio(DATA_INICIO_01_01_2011)
                        .comFuncao(gerarFuncaoGratificada(SEQUENCIAL_FUNCAO_ANALISTA_SISTEMAS_19))
                        .comOrgaoOrigem(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20)
                        .comTipoRegimeTrabalho(TIPO_REGIME_TRABALHO_NORMAL_N)
                        .comFormaIngresso(gerarFormaIngresso(FormaIngresso.FORMA_INGRESSO_COMISSIONADO, TipoVinculo.COMISSIONADO))
                        .comDataInicio(DATA_INICIO_01_01_2011)
                        .comCargaHoraria(CARGA_HORARIA_10)
                        .comOrgaoLotacao(gerarOrgao(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20))
                        .comUnidadeLotacao(gerarUnidade(SEQUENCIAL_UNIDADE_HOSPITAL_GERAL_ESTADO_25))
                        .comSetor(gerarSetor(CODIGO_SETOR_INFORMATICA_100))
                .build();

                return servidorDadoFuncional;
        }

        private ServidorDadoFuncional gerarDadoFuncionalTipoMatriculaExonerado() {
                ServidorDadoFuncionalMatricula servidorDadoFuncional = new ServidorDadoFuncionalMatriculaBuilder()
                        .comMatricula(NUMERO_MATRICULA_9889424)
                        .comDigitoMatricula(DIGITO_MATRICULA_8)
                        .comNumeroOrdem(NUMERO_ORDEM_1357)
                        .comSituacaoServidor(SEQUENCIAL_SITUACAO_SERVIDOR_EXONERADO_2)
                        .comDataNomeacao(DATA_INICIO_01_01_2011)
                        .comDataPosse(DATA_INICIO_01_01_2011)
                        .comDataExercicio(DATA_INICIO_01_01_2011)
                        .comFuncao(gerarFuncaoCargoComissionado(SEQUENCIAL_FUNCAO_ASSESSOR_TECNICO_23))
                        .comOrgaoOrigem(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20)
                        .comTipoRegimeTrabalho(TIPO_REGIME_TRABALHO_NORMAL_N)
                        .comFormaIngresso(gerarFormaIngresso(FormaIngresso.FORMA_INGRESSO_COMISSIONADO, TipoVinculo.COMISSIONADO))
                        .comDataInicio(DATA_INICIO_01_01_2011)
                        .comCargaHoraria(CARGA_HORARIA_10)
                        .comOrgaoLotacao(gerarOrgao(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20))
                        .comUnidadeLotacao(gerarUnidade(SEQUENCIAL_UNIDADE_HOSPITAL_GERAL_ESTADO_25))
                        .comSetor(gerarSetor(CODIGO_SETOR_INFORMATICA_100))
                .build();

                return servidorDadoFuncional;
        }
       
        private ServidorDadoFuncional gerarDadoFuncionalTipoMatriculaCarreira() {
                ServidorDadoFuncionalMatriculaCarreira servidorDadoFuncional = new ServidorDadoFuncionalMatriculaCarreiraBuilder()
                        .comUnidadeExercicio(SEQUENCIAL_UNIDADE_SEDE_33)
                        .comCargo(SEQUENCIAL_CARGO_ANALISTA_SISTEMAS_13)
                        .comCarreira(SEQUENCIAL_CARREIRA_MEDICA_8)
                        .comTipoClasse(TIPO_CLASSE_A)
                        .comTipoNivel(TIPO_NIVEL_4)
                        .comMatricula(NUMERO_MATRICULA_96754522)
                        .comDigitoMatricula(DIGITO_MATRICULA_0)
                        .comNumeroOrdem(NUMERO_ORDEM_3542)
                        .comSituacaoServidor(SEQUENCIAL_SITUACAO_SERVIDOR_ATIVO_1)
                        .comDataNomeacao(DATA_INICIO_01_01_2011)
                        .comDataPosse(DATA_INICIO_01_01_2011)
                        .comDataExercicio(DATA_INICIO_01_01_2011)
                        .comFuncao(gerarFuncaoGratificada(SEQUENCIAL_FUNCAO_ANALISTA_SISTEMAS_19))
                        .comOrgaoOrigem(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20)
                        .comTipoRegimeTrabalho(TIPO_REGIME_TRABALHO_NORMAL_N)
                        .comFormaIngresso(gerarFormaIngresso(FormaIngresso.FORMA_INGRESSO_CONCURSADO, TipoVinculo.EFETIVO))
                        .comDataInicio(DATA_INICIO_01_01_2011)
                        .comCargaHoraria(CARGA_HORARIA_10)
                        .comOrgaoLotacao(gerarOrgao(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20))
                        .comUnidadeLotacao(gerarUnidade(SEQUENCIAL_UNIDADE_HOSPITAL_GERAL_ESTADO_25))
                        .comSetor(gerarSetor(CODIGO_SETOR_INFORMATICA_100))
                        .build();
               
                return servidorDadoFuncional;
        }
       
        private ServidorDadoFuncional gerarDadoFuncionalTipoEstagiario() {
                ServidorDadoFuncionalContratadoEstagiario servidorDadoFuncional = new ServidorDadoFuncionalContratadoEstagiarioBuilder()
                        .comInstituicao(CODIGO_INSTITUICAO_CESMAC_3)
                        .comCursoEstagio(CODIGO_CURSO_MEDICINA_1)
                        .comIndicadorObrigatorio(OBRIGATORIO_NAO)
                        .comIndicadorRemunerado(DESCRICAO_SIM)
                        .comTipoNivel(NIVEL_ENSINO_SUPERIOR_S)
                        .comNumeroContrato(NUMERO_CONTRATO_354_2010)
                        .comDataFim(DATA_ATUAL_MAIS_365_DIA)
                        .comDataRescisao(DATA_ATUAL_MAIS_1_DIA)
                        .comFormaIngresso(gerarFormaIngresso(FormaIngresso.FORMA_INGRESSO_ESTAGIARIO, TipoVinculo.CONTRATADO))
                        .comDataInicio(DATA_INICIO_01_01_2011)
                        .comCargaHoraria(CARGA_HORARIA_10)
                        .comOrgaoLotacao(gerarOrgao(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20))
                        .comUnidadeLotacao(gerarUnidade(SEQUENCIAL_UNIDADE_HOSPITAL_GERAL_ESTADO_25))
                        .comSetor(gerarSetor(CODIGO_SETOR_INFORMATICA_100))
                        .build();
               
                return servidorDadoFuncional;
        }
       
        private ServidorDadoFuncional gerarDadoFuncionalTipoPrestador() {
                ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo servidorDadoFuncional = new ServidorDadoFuncionalContratadoPrestadorProcessoSeletivoBuilder()
                        .comCargo(SEQUENCIAL_CARGO_ANALISTA_SISTEMAS_13)
                        .comOrgaoOrigem(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20)
                        .comNumeroContrato(NUMERO_CONTRATO_35_2013)
                        .comDataFim(DATA_ATUAL_MAIS_1_DIA)
                        .comFormaIngresso(gerarFormaIngresso(FormaIngresso.FORMA_INGRESSO_PRESTADOR, TipoVinculo.CONTRATADO))
                        .comDataInicio(DATA_INICIO_01_01_2011)
                        .comCargaHoraria(CARGA_HORARIA_20)
                        .comOrgaoLotacao(gerarOrgao(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20))
                        .comUnidadeLotacao(gerarUnidade(SEQUENCIAL_UNIDADE_HOSPITAL_GERAL_ESTADO_25))
                        .comSetor(gerarSetor(CODIGO_SETOR_INFORMATICA_100))
                        .build();
               
                return servidorDadoFuncional;
        }
       
        private ServidorDadoFuncional gerarDadoFuncionalTipoPrestadorInativo() {
                ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo servidorDadoFuncional = new ServidorDadoFuncionalContratadoPrestadorProcessoSeletivoBuilder()
                        .comCargo(SEQUENCIAL_CARGO_ANALISTA_SISTEMAS_13)
                        .comOrgaoOrigem(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20)
                        .comNumeroContrato(NUMERO_CONTRATO_905_2013)
                        .comDataFim(DATA_ATUAL_MENOS_1_DIA)
                        .comFormaIngresso(gerarFormaIngresso(FormaIngresso.FORMA_INGRESSO_PROCESSO_SELETIVO, TipoVinculo.CONTRATADO))
                        .comDataInicio(DATA_INICIO_01_01_2011)
                        .comCargaHoraria(CARGA_HORARIA_20)
                        .comOrgaoLotacao(gerarOrgao(SEQUENCIAL_ORGAO_SECRETARIA_ESTADO_SAUDE_20))
                        .comUnidadeLotacao(gerarUnidade(SEQUENCIAL_UNIDADE_HOSPITAL_GERAL_ESTADO_25))
                        .comSetor(gerarSetor(CODIGO_SETOR_INFORMATICA_100))
                        .build();
               
                return servidorDadoFuncional;
        }
       
        private List<Restricoes> gerarListaRestricoesConsultarServidorMesmaMatricula(ServidorDadoFuncional dadoFuncional) {
                List<Restricoes> listaRestricoes = new ArrayList<Restricoes>();

                listaRestricoes.add(Restricoes.igualComAlias("df", "matriculaServidor", ((ServidorDadoFuncionalMatricula)dadoFuncional).getMatriculaServidor()));
                listaRestricoes.add(Restricoes.igualComAlias("df", "situacaoServidor.codigo", SituacaoServidor.CODIGO_SITUACAO_ATIVO_1));
                if(VerificadorUtil.naoEstaNulo(dadoFuncional.getSequencial())) {
                        listaRestricoes.add(Restricoes.diferenteDeComAlias("df", "sequencial", dadoFuncional.getSequencial()));
                }
               
                return listaRestricoes;
        }
       
        private List<Restricoes> gerarListaRestricoesConsultarServidorMesmoNumeroOrdem(ServidorDadoFuncional dadoFuncional) {
                List<Restricoes> listaRestricoes = new ArrayList<Restricoes>();

                listaRestricoes.add(Restricoes.igual("ordem", ((ServidorDadoFuncionalMatricula)dadoFuncional).getOrdem()));
                if(VerificadorUtil.naoEstaNulo(dadoFuncional.getSequencial())) {
                        listaRestricoes.add(Restricoes.diferenteDe("sequencial", dadoFuncional.getSequencial()));
                }
               
                return listaRestricoes;
        }
       
        private List<Restricoes> gerarListaRestricoesConsultarServidorExiste(Servidor entidade) {
                List<Restricoes> listaRestricoes = new ArrayList<Restricoes>();
                listaRestricoes.add(Restricoes.igual("pessoa", entidade.getPessoa()));

                return listaRestricoes;
        }
       
        private CargoDTO gerarCargoComVagas() {
                CargoDTO cargo = gerarCargo();
                cargo.setQuantidadeVagasOcupadas(20L);
                return cargo;
        }
       
        private CargoDTO gerarCargoSemVagas() {
                CargoDTO cargo = gerarCargo();
                cargo.setQuantidadeVagasOcupadas(30L);
                return cargo;
        }
       
        private FuncaoDTO gerarFuncaoComVagas() {
                FuncaoDTO funcao = gerarFuncao();
                funcao.setQuantidadeVagasOcupadas(6L);
                return funcao;
        }
       
        private FuncaoDTO gerarFuncaoSemVagas() {
                FuncaoDTO funcao = gerarFuncao();
                funcao.setQuantidadeVagasOcupadas(10L);
                return funcao;
        }
       
        private CargoDTO gerarCargo() {
                CargoDTO cargo = new CargoDTO();
                cargo.setCodigo(new Integer(SEQUENCIAL_CARGO_ANALISTA_SISTEMAS_13));
                cargo.setDescricao(DESCRICAO_CARGO_ANALISTA_SISTEMAS);
                cargo.setQuantidadeVagas(30L);
                return cargo;
        }
       
        private FuncaoDTO gerarFuncao() {
                FuncaoDTO funcao = new FuncaoDTO();
                funcao.setCodigo(new Integer(SEQUENCIAL_FUNCAO_ANALISTA_SISTEMAS_19));
                funcao.setDescricao(DESCRICAO_FUNCAO_ANALISTA_SISTEMAS);
                funcao.setNivel(NIVEL_AS3);
                funcao.setTipo(TipoFuncao.CARGO_COMISSIONADO);
                funcao.setQuantidadeVagas(10L);
                return funcao;
        }
       
        private UsuarioView gerarUsuarioComPermissoesCompletas() {
                UsuarioView usuario = new UsuarioViewBuilder()
                        .comSequencial(SEQUENCIAL_PESSOA_13)
                        .comPermissao(gerarPermissao(PAPEL_SERVIDOR_TECNICO_SIF_SEM_PREFIXO_ROLE))
                        .comPermissao(gerarPermissao(PAPEL_SERVIDOR_TECNICO_SER_SEM_PREFIXO_ROLE))
                        .comPermissao(gerarPermissao(PAPEL_SERVIDOR_TECNICO_SAFP_SEM_PREFIXO_ROLE))
                        .build();

                return usuario;
        }
       
        private UsuarioView gerarUsuarioComPermissaoTecnicoSER() {
                UsuarioView usuario = new UsuarioViewBuilder()
                        .comSequencial(SEQUENCIAL_PESSOA_13)
                        .comPermissao(gerarPermissao(PAPEL_SERVIDOR_TECNICO_SER_SEM_PREFIXO_ROLE))
                        .build();

                return usuario;
        }
       
        private UsuarioView gerarUsuarioComPermissaoTecnicoSAFP() {
                UsuarioView usuario = new UsuarioViewBuilder()
                        .comSequencial(SEQUENCIAL_PESSOA_13)
                        .comPermissao(gerarPermissao(PAPEL_SERVIDOR_TECNICO_SAFP_SEM_PREFIXO_ROLE))
                        .build();

                return usuario;
        }
       
        private PermissaoView gerarPermissao(String descricaoPermissao) {
                PermissaoView permissao = new PermissaoView();
                permissao.setRole(descricaoPermissao);
                return permissao;
        }
       
        private Parametro gerarParametroConsultaQuantidadeVagasFuncaoGratificada() {
                Parametro parametro = new Parametro();
                parametro.setCodigo(CODIGO_PARAMETRO_QUANTIDADE_VAGAS_FUNCAO_GRATIFICADA_1);
                return parametro;
        }
       
        private Parametro gerarParametroQuantidadeVagasFuncaoGratificada() {
                Parametro parametro = new Parametro();
                parametro.setCodigo(Integer.parseInt(CODIGO_PARAMETRO_1));
                parametro.setDescricao(DESCRICAO_PARAMETRO_QUANTIDADE_VAGAS_FUNCAO);
                parametro.setValor(VALOR_PARAMETRO_QUANTIDADE_VAGAS_FUNCAO);
                return parametro;
        }

}