Exemplo n.º 1
0
        public void SeVagaEmpregoCriadaForInvalidaInserirVagaEmpresaComandoManipuladorDeveRetornarNotificacao()
        {
            var vagaEmpregoInvalida = new VagaEmprego(empresaValida,
                                                      new Nome(""),
                                                      new Texto(comandoValido.Descricao),
                                                      new Texto(comandoValido.Beneficios),
                                                      areaProfissionalValida,
                                                      new Descricao(comandoValido.HorarioTrabalho),
                                                      new DateTime(2500, 12, 31),
                                                      comandoValido.SalarioAcombinar,
                                                      new NumeroPositivo(comandoValido.Salario),
                                                      tipoContratacaoValida);

            empresaRepositorio.Setup(x => x.BuscaEmpresaPorId(comandoValido.EmpresaId)).Returns(empresaValida);
            areaProfissionalRepositorio.Setup(x => x.BuscaAreaProfissionalPorId(comandoValido.AreaProfissionalId)).Returns(areaProfissionalValida);
            tipoContratacaoRepositorio.Setup(x => x.BuscaTipoContratacaoPorId(comandoValido.TipoContratacaoId)).Returns(tipoContratacaoValida);

            vagaEmpregoMap.Setup(x => x.CriarVagaEmprego(comandoValido, empresaValida, areaProfissionalValida, tipoContratacaoValida)).Returns(vagaEmpregoInvalida);

            var vagaEmpregoManipulador = new VagaEmpregoComandoManipulador(vagaEmpregoRepositorio.Object,
                                                                           empresaRepositorio.Object,
                                                                           vagaEmpregoMap.Object,
                                                                           areaProfissionalRepositorio.Object,
                                                                           tipoContratacaoRepositorio.Object);

            Assert.IsNull(vagaEmpregoManipulador.Manipular(comandoValido));
            Assert.AreNotEqual(0, vagaEmpregoManipulador.Notifications.Count);

            vagaEmpregoMap.Verify(x => x.CriarVagaEmprego(comandoValido, empresaValida, areaProfissionalValida, tipoContratacaoValida), Times.Once);
            vagaEmpregoRepositorio.Verify(x => x.Adicionar(vagaEmpregoInvalida), Times.Never);
        }
Exemplo n.º 2
0
        public void SeVagaEmpregoForValidaInserirVagaEmpresaComandoManipuladorDeveRetornarInserirVagaEmpregoResultadoComando()
        {
            empresaRepositorio.Setup(x => x.BuscaEmpresaPorId(comandoValido.EmpresaId)).Returns(empresaValida);
            areaProfissionalRepositorio.Setup(x => x.BuscaAreaProfissionalPorId(comandoValido.AreaProfissionalId)).Returns(areaProfissionalValida);
            tipoContratacaoRepositorio.Setup(x => x.BuscaTipoContratacaoPorId(comandoValido.TipoContratacaoId)).Returns(tipoContratacaoValida);

            vagaEmpregoMap.Setup(x => x.CriarVagaEmprego(comandoValido, empresaValida, areaProfissionalValida, tipoContratacaoValida)).Returns(vagaEmpregoValida);

            var vagaEmpregoManipulador = new VagaEmpregoComandoManipulador(vagaEmpregoRepositorio.Object,
                                                                           empresaRepositorio.Object,
                                                                           vagaEmpregoMap.Object,
                                                                           areaProfissionalRepositorio.Object,
                                                                           tipoContratacaoRepositorio.Object);

            InserirVagaEmpregoResultadoComando resultado = vagaEmpregoManipulador.Manipular(comandoValido) as InserirVagaEmpregoResultadoComando;

            Assert.AreEqual(vagaEmpregoValida.Id, resultado.VagaEmpregoId);
            Assert.AreEqual(0, vagaEmpregoManipulador.Notifications.Count);

            empresaRepositorio.Verify(x => x.BuscaEmpresaPorId(comandoValido.EmpresaId), Times.Once);
            areaProfissionalRepositorio.Verify(x => x.BuscaAreaProfissionalPorId(comandoValido.AreaProfissionalId), Times.Once);
            tipoContratacaoRepositorio.Verify(x => x.BuscaTipoContratacaoPorId(comandoValido.TipoContratacaoId), Times.Once);
            vagaEmpregoMap.Verify(x => x.CriarVagaEmprego(comandoValido, empresaValida, areaProfissionalValida, tipoContratacaoValida), Times.Once);
            vagaEmpregoRepositorio.Verify(x => x.Adicionar(vagaEmpregoValida), Times.Once);
        }
        public async Task <IActionResult> CriarVagaEmprego([FromBody] InserirVagaEmpregoComando comando)
        {
            comando.EmpresaId = Guid.Parse(User.Claims.FirstOrDefault(x => x.Type == "EmpresaId").Value);

            var resultado = _vagaEmpregoComandoManipulador.Manipular(comando);

            return(await Resposta(resultado, _vagaEmpregoComandoManipulador.Notifications));
        }
Exemplo n.º 4
0
        public void SeInserirVagaEmpregoComandoForNuloManipularDeveAdicionarNotificacao()
        {
            var vagaEmpregoManipulador = new VagaEmpregoComandoManipulador(vagaEmpregoRepositorio.Object,
                                                                           empresaRepositorio.Object,
                                                                           vagaEmpregoMap.Object,
                                                                           areaProfissionalRepositorio.Object,
                                                                           tipoContratacaoRepositorio.Object);

            Assert.IsNull(vagaEmpregoManipulador.Manipular(null as InserirVagaEmpregoComando));
            Assert.AreNotEqual(0, vagaEmpregoManipulador.Notifications.Count);

            vagaEmpregoRepositorio.Verify(v => v.Adicionar(null), Times.Never);
            empresaRepositorio.Verify(v => v.BuscaEmpresaPorId(It.Is <Guid>(null)), Times.Never);
        }