public void SeSincronizarValoresDePropriedadesEnumOValorDoGetHashCodeQueDeveSerSincronizado()
{
var comando = new SqlCommand();
var dicionario = new Dicionario(typeof(NetoDoObjetoDeTestes));
CommandBuilder.DefinirParametrosParaTodosOsCampos(dicionario, comando);
var objeto = new NetoDoObjetoDeTestes()
{
CodigoFilho = 123,
NomeNeto = "ABC",
Opcao = EnumDeTestes.Opcao3
};
CommandBuilder.SincronizarParametrosDeTodosOsCampos(dicionario, comando, objeto);
comando.Parameters["@p3"].Value
.Should()
.Be(3);
}
public void SeSincronizarValoresDePropriedadesEnumSemDefaultValueOEnumQueDeveSerSincronizado()
{
var comando = new SqlCommand();
var dicionario = new Dicionario(typeof(NetoDoObjetoDeTestes));
CommandBuilder.DefinirParametrosParaTodosOsCampos(dicionario, comando);
var objeto = new NetoDoObjetoDeTestes()
{
CodigoFilho = 123,
NomeNeto = "ABC",
Letra = EnumDeStrings.SemOpcao
};
CommandBuilder.SincronizarParametrosDeTodosOsCampos(dicionario, comando, objeto);
comando.Parameters["@p4"].Value
.Should()
.Be("SemOpcao");
}
public void SeConsultarScalarTipadoDaQuantidadeDeRegistrosDeveRetornarNumeroValido()
{
var comando = CriarComando();
var dicionario = new Dicionario(typeof(ObjetoDeTestes));
var config = new ConfiguradorQuery <ObjetoDeTestes>(comando.CriarComando(), dicionario, new QueryBuilder());
config.DefinirTabela();
config.AdicionarResultadoAgregado(Agregadores.Count);
var scalar = comando.Scalar(config);
scalar
.Should()
.BeOfType <int>();
((int)scalar)
.Should()
.BeGreaterThan(0);
}
public void SeConsultarOsCamposChavesMapeadosDeveRetornarOsCamposEsperados()
{
var dicionarioDupla = new Dicionario(typeof(ObjetoMapeadoComChaveDupla));
dicionarioDupla.QuantidadeCamposNaChave
.Should().Be(2);
var campos = dicionarioDupla.ConsultarCamposChave().GetEnumerator();
campos.MoveNext().Should().BeTrue();
campos.Current.Should().NotBeNull();
campos.Current.Alias.Should().Be("MapeadoComChaveBase");
campos.Current.Nome.Should().Be("ChaveBase");
campos.MoveNext().Should().BeTrue();
campos.Current.Should().NotBeNull();
campos.Current.Alias.Should().Be("MapeadoComChaveAutoIncremento");
campos.Current.Nome.Should().Be("ChaveAutoIncremento");
campos.MoveNext().Should().BeFalse();
}
public void SeGerarScriptDezMilhoesDeVezesDeveGerarUmScriptValido()
{
var builder = new QueryBuilder();
var dicionario = new Dicionario(typeof(ObjetoDeTestes));
builder.DefinirTabela(dicionario.Nome);
var consulta =
"select " +
"[Codigo],[CodigoNulo],[Nome],[Duplo],[DuploNulo]," +
"[Decimal],[DecimalNulo],[Logico],[DataHora],[DataHoraNulo] " +
"from[ObjetoVirtual]";
for (int i = 0; i < 10_000_000; i++)
{
if (!string.Equals(builder.GerarScript(dicionario), consulta))
{
throw new Exception("Script gerado errado!");
}
}
}
private void VerificarAnagramas(string prefixo, string palavra)
{
if (palavra.Length <= 1)
{
var palavraFinal = prefixo.ToUpper() + palavra.ToUpper();
if (Dicionario.Contains(palavraFinal) && !PalavrasEncontradas.Contains(palavraFinal))
{
PalavrasEncontradas.Add(palavraFinal);
}
}
else
{
for (int i = 0; i < palavra.Length; i++)
{
var cursor = palavra.Substring(i, 1);
var antes = palavra.Substring(0, i);
var depois = palavra.Substring(i + 1);
VerificarAnagramas(prefixo + cursor, antes + depois);
}
}
}
public void SeSincronizarValoresDePropriedadesEnumOValorDoDefaultValueQueDeveSerSincronizado()
{
var comando = new SqlCommand();
var dicionario = new Dicionario(typeof(NetoDoObjetoDeTestes));
CommandBuilder.DefinirParametrosParaTodosOsCampos(dicionario, comando);
var objeto = new NetoDoObjetoDeTestes()
{
CodigoFilho = 123,
NomeNeto = "ABC",
Letra = EnumDeStrings.OpcaoC
};
CommandBuilder.SincronizarParametrosDeTodosOsCampos(dicionario, comando, objeto);
var campoNome = dicionario.ConsultarPorPropriedade("Letra");
comando.Parameters["@p" + campoNome.Id.ToString()].Value
.Should()
.Be("C");
}
public void SeCriarScriptConsultaRelacionamentoAscendenteDeveGerarUmScriptSqlCorretamente()
{
var queryBuilder = new QueryBuilder();
var dicionarioFilhos = new Dicionario(typeof(FilhoDoObjetoDeTestes));
queryBuilder.DefinirTabela(dicionarioFilhos.Nome);
queryBuilder.AdicionarCondicao("CodigoFilho", (int)Operadores.Igual, 1);
var scriptQueConsultaFilhoQueTeraPaiCarregado = queryBuilder.GerarScript(dicionarioFilhos);
var chaveEstrangeira = DataAnnotationHelper.ConsultarForeignKey(dicionarioFilhos.ConsultarPorCampo("Pai").Propriedade);
var dicionarioPai = new Dicionario(typeof(ObjetoDeTestes));
var relacionamentoAscendente = new Relacionamento(TiposRelacionamento.Ascendente, dicionarioPai, chaveEstrangeira);
var relacionamentoBuilder = new RelacionamentoBuilder();
relacionamentoBuilder.CriarScriptConsultaRelacionamentoAscendente(relacionamentoAscendente, scriptQueConsultaFilhoQueTeraPaiCarregado)
.Should()
.Be("select" +
"[Codigo],[CodigoNulo],[Nome],[Duplo],[DuploNulo],[Decimal]," +
"[DecimalNulo],[Logico],[DataHora],[DataHoraNulo]" +
"from(" +
"select" +
"[Codigo],[CodigoNulo],[Nome],[Duplo],[DuploNulo],[Decimal],[DecimalNulo]," +
"[Logico],[DataHora],[DataHoraNulo]" +
"from[ObjetoVirtual]" +
")[t]" +
"where(exists(" +
"select top 1 1 " +
"from(" +
"select " +
"[CodigoFilho]as[Id],[NomeFilho]as[Nome],[CodigoPai]as[IdPai] " +
"from[ObjetoVirtualFilho]" +
"where([CodigoFilho]=@_p0) " +
")[d]" +
"where(t.[Codigo]=d.[IdPai])))" +
"order by t.[Codigo]");
}
public void SeSincronizarParametrosDeTodosOsCamposDeveDefinirValoresCorretamente()
{
var comando = new SqlCommand();
var dicionario = new Dicionario(typeof(ObjetoComChaveDupla));
CommandBuilder.DefinirParametrosParaTodosOsCampos(dicionario, comando);
var objeto = new ObjetoComChaveDupla()
{
ChaveBase = 123,
Nome = "ABC"
};
CommandBuilder.SincronizarParametrosDeTodosOsCampos(dicionario, comando, objeto);
comando.Parameters["@p0"].Value
.Should()
.Be(123);
comando.Parameters["@p2"].Value
.Should()
.Be("ABC");
}
public void SeDefinirParametrosParaTodosOsCamposDaChaveApenasCamposChaveDevemSerDefinidos()
{
var comando = new SqlCommand();
var dicionario = new Dicionario(typeof(ObjetoDeTestes));
CommandBuilder.DefinirParametrosParaTodosOsCamposDaChave(dicionario, comando);
comando.Parameters.Count
.Should()
.Be(dicionario.QuantidadeCamposNaChave);
foreach (var itemDicionario in dicionario.ConsultarCamposChave())
{
var parametro = comando.Parameters["@p" + itemDicionario.Id.ToString()];
parametro
.Should()
.NotBeNull();
parametro.DbType
.Should()
.Be(itemDicionario.TipoBanco);
}
}
public void SeConsultarRegistrosTipadosNoBancoDeveGerarDataReaderComEstruturaCorreta()
{
var comando = CriarComando();
var dicionario = new Dicionario(typeof(ObjetoDeTestes));
var config = new ConfiguradorQuery <ObjetoDeTestes>(comando.CriarComando(), dicionario, new QueryBuilder());
config.DefinirTabela();
config.DefinirLimite(0);
var registros = comando.ConsultarRegistro(config);
registros
.Should()
.NotBeNull();
registros.FieldCount
.Should()
.Be(dicionario.QuantidadeCampos);
registros.Read()
.Should()
.BeFalse();
}
public void SeCriarDataTableDeveGerarUmDataTableComEstruturaEsperada()
{
var dicionario = new Dicionario(typeof(ObjetoDeTestes));
var tabela = DataTableBuilder.CriarDataTable(dicionario);
tabela
.Should()
.NotBeNull();
tabela.Columns
.Should()
.HaveCount(10, "devem existir 10 colunas!");
ValidarColuna(tabela.Columns[0], nome: "Codigo", tipo: typeof(int), permiteNulo: false);
ValidarColuna(tabela.Columns[1], nome: "CodigoNulo", tipo: typeof(int), permiteNulo: true);
ValidarColuna(tabela.Columns[2], nome: "Nome", tipo: typeof(string), permiteNulo: false, tamanhoMaximo: 50);
ValidarColuna(tabela.Columns[3], nome: "Duplo", tipo: typeof(double), permiteNulo: false);
ValidarColuna(tabela.Columns[4], nome: "DuploNulo", tipo: typeof(double), permiteNulo: true);
ValidarColuna(tabela.Columns[5], nome: "Decimal", tipo: typeof(decimal), permiteNulo: false);
ValidarColuna(tabela.Columns[6], nome: "DecimalNulo", tipo: typeof(decimal), permiteNulo: true);
ValidarColuna(tabela.Columns[7], nome: "Logico", tipo: typeof(bool), permiteNulo: false);
ValidarColuna(tabela.Columns[8], nome: "DataHora", tipo: typeof(DateTime), permiteNulo: false);
ValidarColuna(tabela.Columns[9], nome: "DataHoraNulo", tipo: typeof(DateTime), permiteNulo: true);
}
public async Task <IActionResult> UploadFile(IFormFile file)
{
try
{
var sr = new StreamReader(file.OpenReadStream());
var dt = Util.ConvertCSVtoDataTable(sr);
if (dt == null)
{
TempData["Error"] = "Arquivo em branco";
}
else
{
if (Util.validaColunas(Dicionario.RetornaColunasClientes(), dt.Columns))
{
var clientes = PopulaListaClientes(dt);
var mensagem = ValidaInformacoes(clientes);
if (Util.validaCampo(mensagem))
{
TempData["Error"] = mensagem;
}
else
{
foreach (var cliente in clientes)
{
try
{
var result = await CadastrarCliente(cliente);
if (!result.Succeeded)
{
TempData["Error"] = result.Errors;
break;
}
}
catch (Exception ex)
{
var user = await _userManager.FindByEmailAsync(cliente.Email);
if (user != null)
{
await _userManager.DeleteAsync(user);
}
throw ex;
}
}
}
}
else
{
TempData["Error"] = "As colunas do arquivo estão inválidas";
}
}
}
catch
{
TempData["Error"] = "Algum erro desconhecido ocorreu, tente novamente";
}
return(RedirectToAction(nameof(Index)));
}
public int SaveData(Dicionario dicionario)
{
return(dbConn.Insert(dicionario));
}
public int DeleteData(Dicionario dicionario)
{
return(dbConn.Delete(dicionario));
}
public int UpdateData(Dicionario dicionario)
{
return(dbConn.Update(dicionario));
}
private DataTable CriarTabelaDoObjetoDeTestes()
{
var dicionario = new Dicionario(typeof(ObjetoDeTestes));
return(DataTableBuilder.CriarDataTable(dicionario));
}
public void SeConverterItemEmDataRowDeveGerarUmDataRowEsperado()
{
var dicionario = new Dicionario(typeof(ObjetoDeTestes));
var tabela = DataTableBuilder.CriarDataTable(dicionario);
var agora = DateTime.Now;
var objeto = new ObjetoDeTestes()
{
Codigo = 1,
CodigoNulo = 2,
Nome = "ABC",
Duplo = 123.56,
DuploNulo = 123.5,
Decimal = 234.67M,
DecimalNulo = 234.6M,
Logico = true,
DataHora = agora,
DataHoraNulo = agora.AddDays(1)
};
var registro = DataTableBuilder.ConverterItemEmDataRow(tabela, objeto);
registro.RowState
.Should()
.Be(DataRowState.Detached);
registro["Codigo"]
.Should()
.Be(1);
registro["CodigoNulo"]
.Should()
.Be(2);
registro["Nome"]
.Should()
.Be("ABC");
registro["Duplo"]
.Should()
.Be(123.56);
registro["DuploNulo"]
.Should()
.Be(123.5);
registro["Decimal"]
.Should()
.Be(234.67M);
registro["DecimalNulo"]
.Should()
.Be(234.6M);
registro["Logico"]
.Should()
.Be(true);
registro["DataHora"]
.Should()
.Be(agora);
registro["DataHoraNulo"]
.Should()
.Be(agora.AddDays(1));
}
public ConfiguradorProcedure(IDbCommand comando, Dicionario dicionario)
: base(comando, dicionario)
{
}
public PersistenciaFake(Dicionario dicionario)
: base(dicionario)
{
}
public BuscadorLoader(IComando comando, Dicionario dicionario, IRelacionamentoBuilder relacionamentoBuilder)
{
_comando = comando;
_dicionario = dicionario;
_relacionamentoBuilder = relacionamentoBuilder;
}
public static Script Consultar(Dicionario dicionario)
{
return(Scripts.GetOrAdd(dicionario, CriarScriptParaObjeto));
}
public string GerarScriptExistencia(Dicionario dicionario)
{
return(_script);
}
public string GerarScript(Dicionario dicionario)
{
return(_script);
}
public ValidadorDicionario(Dicionario dicionario, IList <IValidadorEntidadeAttribute> validacoes)
{
_validacoes = validacoes;
Dicionario = dicionario;
Quantidade = _validacoes.Count;
}
private static Adapter <ObjetoDeTestes> CriarAdapterDoObjetoDeTestes()
{
var dicionario = new Dicionario(typeof(ObjetoDeTestes));
return(new Adapter <ObjetoDeTestes>(dicionario));
}
public Adapter(Dicionario dicionario)
{
_dicionario = dicionario;
}
public Relacionamento(TiposRelacionamento tipo, Dicionario dicionario, string chaveEstrangeira)
{
_tipo = tipo;
_dicionario = dicionario;
_chaveEstrangeira = chaveEstrangeira.Split(',');
}
public ConfiguradorQuery(IDbCommand comando, Dicionario dicionario, IQueryBuilder queryBuilder)
: base(comando, dicionario)
{
_dicionario = dicionario;
_queryBuilder = queryBuilder;
}
protected PersistenciaBase(Dicionario dicionario)
{
_dicionario = dicionario;
}
