public void SeAdicionarUmaListaDeRegistrosNoContextoORepositorioNaoDeveSerModificadoEOsItensDevemSerEncontrados()
        {
            var contexto = new ContextoFake();

            var repositorio = contexto.Repositorio <ObjetoDeTestes>();

            repositorio.Quantidade
            .Should()
            .Be(0);

            var lista = CriarListaPadrao();

            contexto.AdicionarRegistros(lista);

            repositorio.Quantidade
            .Should()
            .Be(0);

            var indice = 0;

            foreach (var item in repositorio.Buscar.Todos())
            {
                ValidarItemDaListaPadrao(indice, item);
                indice++;
            }

            indice
            .Should()
            .Be(2);
        }
        public void SeAdicionarUmaListaDeRegistrosNoContextoORepositorioCorretoDeveserModificado()
        {
            var contexto = new ContextoFake();

            var repositorio = contexto.Repositorio <ObjetoDeTestes>();

            repositorio.Quantidade
            .Should()
            .Be(0);

            var lista = new List <ObjetoDeTestes>
            {
                new ObjetoDeTestes()
                {
                    Codigo = 1, Nome = "Nome Valido Para Adicao"
                },
                new ObjetoDeTestes()
                {
                    Codigo = 2, Nome = "Novo Nome Valido Para Adicao"
                }
            };

            contexto.AdicionarRegistros(lista);

            repositorio.Quantidade
            .Should()
            .Be(2);
        }
        public void SeAdicionarRegistrosFilhosNoContextoORepositorioNaoDeveSerModificadoMasDeveSerConsultado()
        {
            var contexto = new ContextoFake();

            var repositorioPai   = contexto.Repositorio <ObjetoDeTestes>();
            var repositorioFilho = contexto.Repositorio <FilhoDoObjetoDeTestes>();

            repositorioPai.Quantidade
            .Should()
            .Be(0);

            repositorioFilho.Quantidade
            .Should()
            .Be(0);

            contexto.AdicionarRegistro(new ObjetoDeTestes()
            {
                Codigo = 1,
                Nome   = "Nome Valido Para Adicao",
                Filhos = new List <FilhoDoObjetoDeTestes>()
                {
                    new FilhoDoObjetoDeTestes()
                    {
                        IdPai = 999,
                        Id    = 2,
                        Nome  = "Filho Valido Para Adicao"
                    }
                }
            });

            repositorioPai.Quantidade
            .Should()
            .Be(0);

            repositorioFilho.Quantidade
            .Should()
            .Be(0);

            var config = repositorioFilho.Buscar.CriarQuery()
                         .AdicionarCondicao(c => c.Id).Igual(2);

            var registroFilho = repositorioFilho.Buscar.Um(config);

            registroFilho
            .Should()
            .NotBeNull();

            registroFilho.Id
            .Should()
            .Be(2);

            registroFilho.IdPai
            .Should()
            .Be(1);

            registroFilho.Nome
            .Should()
            .Be("Filho Valido Para Adicao");
        }
        public void SeConsultarRepositorioDeFormasDiferentesDeveEncontrarMesmoRepositorio()
        {
            var contexto = new ContextoFake();

            var repositorioUm = contexto.Repositorio <ObjetoDeTestes>();

            var repositorioDois = contexto.Repositorio(typeof(ObjetoDeTestes));

            repositorioUm
            .Should()
            .BeSameAs(repositorioDois);
        }
        public void SeDefinirResultadoProcedureSemProcedureDeveGerarErro()
        {
            var contexto = new ContextoFake();
            var lista    = new List <ObjetoDeTestes>();

            Action nomeNulo = () => contexto.DefinirResultadoProcedure(null, lista);

            nomeNulo
            .ShouldThrow <ArgumentNullException>();

            Action nomeVazio = () => contexto.DefinirResultadoProcedure(string.Empty, lista);

            nomeVazio
            .ShouldThrow <ArgumentNullException>();
        }
        public void SeDefinirResultadoScalarProcedureOValorScalarDeveSerRetornado()
        {
            var contexto = new ContextoFake();

            double constante = 123.56;

            contexto.DefinirResultadoScalarProcedure("proc", constante);

            var repositorio = contexto.Repositorio <ObjetoDeTestes>();

            var config = repositorio.Buscar.CriarProcedure("proc");
            var valor  = repositorio.Buscar.Scalar(config);

            valor
            .Should()
            .BeOfType <double>()
            .And
            .Be(constante);
        }
        public void SeDefinirResultadoProcedureOsMesmosDevemSerLocalizados()
        {
            var contexto = new ContextoFake();

            var lista = CriarListaPadrao();

            contexto.DefinirResultadoProcedure("proc", lista);

            var repositorio = contexto.Repositorio <ObjetoDeTestes>();

            var indice = 0;
            var config = repositorio.Buscar.CriarProcedure("proc");

            foreach (var item in repositorio.Buscar.Varios(config))
            {
                ValidarItemDaListaPadrao(indice, item);
                indice++;
            }
        }
        public void SeAdicionarRegistrosNoContextoORepositorioCorretoDeveserModificado()
        {
            var contexto = new ContextoFake();

            var repositorio = contexto.Repositorio <ObjetoDeTestes>();

            repositorio.Quantidade
            .Should()
            .Be(0);

            contexto.AdicionarRegistro(new ObjetoDeTestes()
            {
                Codigo = 1, Nome = "Nome Valido Para Adicao"
            });

            repositorio.Quantidade
            .Should()
            .Be(1);
        }
        public void SeDefinirResultadoNonQueryProcedureMultiplasVezesOValorScalarDeveSerRetornado()
        {
            var contexto = new ContextoFake();

            contexto.DefinirResultadoNonQueryProcedure("proc", 11);

            var repositorio = contexto.Repositorio <ObjetoDeTestes>();
            var config      = repositorio.Buscar.CriarProcedure("proc");

            var valor = repositorio.Buscar.NonQuery(config);

            valor
            .Should()
            .Be(11);

            contexto.DefinirResultadoNonQueryProcedure("proc", 17);

            var novoValor = repositorio.Buscar.NonQuery(config);

            novoValor
            .Should()
            .Be(17);
        }
        public void SeDefinirResultadoNonQueryProcedureOValorNonQueryDeveSerRetornado()
        {
            var contexto   = new ContextoFake();
            var procs      = new[] { "procA", "procB", "procC" };
            var resultados = new[] { 11, 17, 23 };

            for (int n = 0; n < 3; n++)
            {
                contexto.DefinirResultadoNonQueryProcedure(procs[n], resultados[n]);
            }

            var repositorio = contexto.Repositorio <ObjetoDeTestes>();

            for (int n = 0; n < 3; n++)
            {
                var config = repositorio.Buscar.CriarProcedure(procs[n]);
                var valor  = repositorio.Buscar.NonQuery(config);

                valor
                .Should()
                .Be(resultados[n]);
            }
        }
        public void SeAdicionarRegistrosNoContextoORepositorioNaoDeveSerModificadoMasDeveSerConsultado()
        {
            var contexto = new ContextoFake();

            var repositorio = contexto.Repositorio <ObjetoDeTestes>();

            repositorio.Quantidade
            .Should()
            .Be(0);

            contexto.AdicionarRegistro(new ObjetoDeTestes()
            {
                Codigo = 1, Nome = "Nome Valido Para Adicao"
            });

            repositorio.Quantidade
            .Should()
            .Be(0);

            var config = repositorio.Buscar.CriarQuery()
                         .AdicionarCondicao(c => c.Codigo).Igual(1);

            var registro = repositorio.Buscar.Um(config);

            registro
            .Should()
            .NotBeNull();

            registro.Codigo
            .Should()
            .Be(1);

            registro.Nome
            .Should()
            .Be("Nome Valido Para Adicao");
        }
        public void SeAdicionarRegistrosNetosNoContextoORepositorioNaoDeveSerModificadoMasDeveSerConsultado()
        {
            var contexto = new ContextoFake();

            var repositorioPai   = contexto.Repositorio <ObjetoDeTestes>();
            var repositorioFilho = contexto.Repositorio <FilhoDoObjetoDeTestes>();
            var repositorioNeto  = contexto.Repositorio <NetoDoObjetoDeTestes>();

            repositorioPai.Quantidade
            .Should()
            .Be(0);

            repositorioFilho.Quantidade
            .Should()
            .Be(0);

            repositorioNeto.Quantidade
            .Should()
            .Be(0);

            contexto.AdicionarRegistro(new ObjetoDeTestes()
            {
                Codigo = 1,
                Nome   = "Nome Valido Para Adicao",
                Filhos = new List <FilhoDoObjetoDeTestes>()
                {
                    new FilhoDoObjetoDeTestes()
                    {
                        IdPai = 1,
                        Id    = 2,
                        Nome  = "Filho Valido Para Adicao",
                        Netos = new List <NetoDoObjetoDeTestes>()
                        {
                            new NetoDoObjetoDeTestes()
                            {
                                CodigoFilho = 999,
                                CodigoNeto  = 3,
                                NomeNeto    = "Neto Valido Para Adicao",
                                Opcao       = EnumDeTestes.Opcao2,
                                Letra       = EnumDeStrings.OpcaoC
                            }
                        }
                    }
                }
            });

            repositorioPai.Quantidade
            .Should()
            .Be(0);

            repositorioFilho.Quantidade
            .Should()
            .Be(0);

            repositorioNeto.Quantidade
            .Should()
            .Be(0);

            var config = repositorioNeto.Buscar.CriarQuery()
                         .AdicionarCondicao(c => c.CodigoNeto).Igual(3);

            var registroNeto = repositorioNeto.Buscar.Um(config);

            registroNeto
            .Should()
            .NotBeNull();

            registroNeto.CodigoNeto
            .Should()
            .Be(3);

            registroNeto.CodigoFilho
            .Should()
            .Be(2);

            registroNeto.NomeNeto
            .Should()
            .Be("Neto Valido Para Adicao");
        }