public void Domain_ResultadoConcurso_Nao_Deveria_Ter_Concurso_Vazio()
{
_resultadoConcurso = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoSemConcurso();
Action action = () => _resultadoConcurso.Validar();
action.Should().Throw <InvalidConcursoException>();
}
public void Integration_ResultadoConcurso_Excluir_Deveria_Retornar_Excecao()
{
ResultadoConcurso resultado = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoConcursoComId();
Action action = () => _service.Excluir(resultado);
action.Should().Throw <UnsupportedOperationException>();
}
public void Service_CSV_Exportar_Resultado()
{
_concurso = ObjectMother.GetConcursoComId();
ResultadoConcurso resultadoConcurso = new ResultadoConcurso(_concurso);
FaturamentoLoterica faturamento = Loterica.Common.Tests.Lotericas.ObjectMother.GetFaturamentoComId();
List <Aposta> apostas = Loterica.Common.Tests.Apostas.ObjectMother.GetApostas();
_apostaRepository
.Setup(x => x.GetByConcursoId(It.IsAny <int>()))
.Returns(apostas);
_apostaRepository
.Setup(x => x.GetByConcursoIdComBolao(It.IsAny <int>()))
.Returns(apostas);
_resultadoConcursoRepository
.Setup(y => y.Adicionar(It.IsAny <ResultadoConcurso>()));
randomMoq
.Setup(r => r.Next(1, 61))
.Returns(() => numeroAleatorio++);
resultadoConcurso = _resultadoConcurso.GerarResultadoConcurso(resultadoConcurso, randomMoq.Object);
List <ResultadoConcurso> resultado = new List <ResultadoConcurso>();
resultado.Add(resultadoConcurso);
_csvService.ExportarCSV(resultado, file);
FileAssert.Exists(file);
}
public void Service_ResultadoConcurso_GerarResultadoConcurso_Deveria_Gerar_Dados()
{
_concurso = ObjectMother.GetConcursoComId();
ResultadoConcurso resultado = new ResultadoConcurso(_concurso);
List <Aposta> apostas = Loterica.Common.Tests.Apostas.ObjectMother.GetApostas();
_apostaRepository
.Setup(x => x.GetByConcursoId(It.IsAny <int>()))
.Returns(apostas);
_apostaRepository
.Setup(x => x.GetByConcursoIdComBolao(It.IsAny <int>()))
.Returns(apostas);
randomMoq
.Setup(r => r.Next(1, 61))
.Returns(() => numeroAleatorio++);
resultado = _service.GerarResultadoConcurso(resultado, randomMoq.Object);
_apostaRepository
.Verify(x => x.GetByConcursoId(_concurso.Id));
resultado.premioTotal.Should().Be(7200.9);
resultado.numerosResultado.Count().Should().Be(6);
foreach (var item in resultado.numerosResultado)
{
if (item > 60 || item < 1)
{
Assert.Fail();
}
}
}
public void Domain_ResultadoConcurso_Deveria_Adicionar_Ganhador_6_Acertos()
{
Aposta aposta = ObjectMother.GetApostaComId();
_resultadoConcurso = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoConcurso();
_resultadoConcurso.AdicionarGanhador(aposta, 6);
_resultadoConcurso.ganhadores.Count.Should().Be(1);
_resultadoConcurso.qtdAcertadoresSena.Should().Be(1);
}
public static ResultadoConcurso GetResultadoSemConcurso()
{
Concurso concurso = Loterica.Common.Tests.Concursos.ObjectMother.GetConcurso();
ResultadoConcurso resultado = new ResultadoConcurso(concurso);
resultado.CalculaNumeroResultado(random);
resultado.CalcularPremioTotal();
return(resultado);
}
public void Integration_ResultadoConcurso_Deveria_Editar_Corretamente()
{
ResultadoConcurso resultado = _service.BuscarPorConcursoId(2);
resultado = _service.GerarResultadoConcurso(resultado, random);
_service.Editar(resultado);
ResultadoConcurso r = _service.Get(resultado.Id);
r.numerosResultado.Should().BeEquivalentTo(resultado.numerosResultado);
}
public void Integration_ResultadoConcurso_Deveria_Adicionar_Corretamente()
{
_concurso = ObjectMother.GetConcursoComId();
ResultadoConcurso resultado = new ResultadoConcurso(_concurso);
resultado = _service.GerarResultadoConcurso(resultado, random);
_service.Adicionar(resultado);
ResultadoConcurso r = _service.Get(2);
r.numerosResultado.Should().BeEquivalentTo(resultado.numerosResultado);
}
public void Infra_ResultadoConcurso_SQLRepository_Deveria_Adicionar()
{
_resultadoConcurso = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoConcursoComGanhadores();
List <Aposta> aposta = Loterica.Common.Tests.Apostas.ObjectMother.Get3Apostas();
foreach (var item in aposta)
{
_apostaRepository.Adicionar(item);
}
_resultadoConcurso = _resultadoConcursoRepository.Adicionar(_resultadoConcurso);
_resultadoConcurso.Id.Should().BeGreaterThan(0);
}
public void Domain_ResultadoConcurso_Deveria_Calcular_Premio_Aposta_6()
{
Aposta aposta = ObjectMother.GetApostaComId();
_resultadoConcurso = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoConcurso();
_resultadoConcurso.premioTotal = 10000;
_resultadoConcurso.qtdAcertadoresSena = 1;
_resultadoConcurso.CalcularPremioPorAposta();
_resultadoConcurso.premioQuadraPorJogador.Should().Be(0);
_resultadoConcurso.premioQuinaPorJogador.Should().Be(0);
_resultadoConcurso.premioSenaPorJogador.Should().Be(10000);
}
public void Infra_ResultadoConcurso_SQLRepository_Nao_Deveria_Adicionar_Concurso_Sem_Id()
{
_resultadoConcurso = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoSemConcurso();
List <Aposta> aposta = Loterica.Common.Tests.Apostas.ObjectMother.Get3Apostas();
foreach (var item in aposta)
{
_apostaRepository.Adicionar(item);
}
Action action = () => _resultadoConcursoRepository.Adicionar(_resultadoConcurso);
action.Should().Throw <InvalidConcursoException>();
}
public void Domain_ResultadoConcursoT_Deveria_Calcular_Numeros_Resultado()
{
Concurso concurso = Loterica.Common.Tests.Concursos.ObjectMother.GetConcursoComId();
_resultadoConcurso = new ResultadoConcurso(concurso);
_resultadoConcurso.numerosResultado.Count().Should().Be(6);
foreach (var item in _resultadoConcurso.numerosResultado)
{
if (item > 60 || item < 1)
{
Assert.Fail();
}
}
}
public void Infra_ResultadoConcurso_SQLRepository_Deveria_Editar()
{
List <Aposta> aposta = Loterica.Common.Tests.Apostas.ObjectMother.Get3Apostas();
foreach (var item in aposta)
{
_apostaRepository.Adicionar(item);
}
_resultadoConcurso = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoConcursoComGanhadoresComId();
_resultadoConcursoRepository.Editar(_resultadoConcurso);
ResultadoConcurso resultadoConcursoGet = _resultadoConcursoRepository.GetById(1);
resultadoConcursoGet.ganhadores.Count.Should().Be(3);
}
public void Integration_ResultadoConcurso_GerarResultadoConcurso_Deveria_Gerar_Dados()
{
_concurso = ObjectMother.GetConcursoComId();
ResultadoConcurso resultado = new ResultadoConcurso(_concurso);
resultado = _service.GerarResultadoConcurso(resultado, random);
foreach (var item in resultado.numerosResultado)
{
if (item > 60 || item < 1)
{
Assert.Fail();
}
}
}
public void Integration_CalcularResultadoFinal_Corretamente()
{
_aposta = ObjectMother.GetAposta();
List <int> numerosResultado = new List <int> {
2, 4, 1, 6, 9, 11
};
ResultadoConcurso resultadoConcurso = new ResultadoConcurso(_aposta.concurso);
resultadoConcurso.numerosResultado.Clear();
resultadoConcurso.numerosResultado = numerosResultado;
_resultadoConcursoRepository.Setup(x => x.GetByConcursoId(It.IsAny <int>())).Returns(resultadoConcurso);
int acertos = _service.CalcularResultadoFinal(_aposta);
acertos.Should().Be(4);
}
public void Domain_ResultadoConcurso_Deveria_LimparCamposGanhadores()
{
_resultadoConcurso = new ResultadoConcurso(new Concurso());
_resultadoConcurso.AdicionarGanhador(new Aposta(new Concurso()), 4);
_resultadoConcurso.AdicionarGanhador(new Aposta(new Concurso()), 5);
_resultadoConcurso.AdicionarGanhador(new Aposta(new Concurso()), 6);
_resultadoConcurso.qtdAcertadoresQuadra = 3;
_resultadoConcurso.qtdAcertadoresQuina = 2;
_resultadoConcurso.qtdAcertadoresSena = 1;
_resultadoConcurso.LimparCamposGanhadores();
_resultadoConcurso.ganhadores.Count.Should().Be(0);
_resultadoConcurso.qtdAcertadoresQuadra.Should().Be(0);
_resultadoConcurso.qtdAcertadoresQuina.Should().Be(0);
_resultadoConcurso.qtdAcertadoresSena.Should().Be(0);
}
public ResultadoConcurso Adicionar(ResultadoConcurso entidade)
{
entidade.Validar();
entidade.Id = Db.Insert(_sqlAddResultadoConcurso, TakeResultadoConcurso(entidade));
foreach (var item in entidade.ganhadores)
{
item.ResultadoConcursoId = entidade.Id;
Db.Update(_sqlAddGanhador, TakeGanhador(item));
}
entidade.faturamento = _faturamentoLotericaRepository.Adicionar(entidade.faturamento);
return(entidade);
}
public void Service_ResultadoConcurso_BuscarPorId_Deveria_Buscar_ResultadoConcurso()
{
ResultadoConcurso resultado = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoConcursoComId();
_resultadoConcursoRepository
.Setup(x => x.GetById(It.IsAny <int>()))
.Returns(resultado);
ResultadoConcurso resultadoRecebido = _service.Get(resultado.Id);
_resultadoConcursoRepository
.Verify(x => x.GetById(resultado.Id));
resultadoRecebido.Id.Should().Be(1);
}
private Dictionary <string, object> TakeResultadoConcurso(ResultadoConcurso resultadoConcurso)
{
return(new Dictionary <string, object>
{
{ "Id", resultadoConcurso.Id },
{ "PremioTotal", resultadoConcurso.premioTotal },
{ "PremioQuadraPorJogador", resultadoConcurso.premioQuadraPorJogador },
{ "PremioQuinaPorJogador", resultadoConcurso.premioQuinaPorJogador },
{ "PremioSenaPorJogador", resultadoConcurso.premioSenaPorJogador },
{ "QtdAcertadoresQuadra", resultadoConcurso.qtdAcertadoresQuadra },
{ "QtdAcertadoresQuina", resultadoConcurso.qtdAcertadoresQuina },
{ "QtdAcertadoresSena", resultadoConcurso.qtdAcertadoresSena },
{ "NumerosResultado", ConverterNumerosResultadoParaString(resultadoConcurso.numerosResultado) },
{ "ConcursoId", resultadoConcurso.concurso.Id }
});
}
public ResultadoConcurso GetById(int Id)
{
Dictionary <string, object> parms = new Dictionary <string, object> {
{ "Id", Id }
};
ResultadoConcurso resultadoConcurso = Db.Get(_sqlGetResultadoConcursoById, MakeResultadoConcurso, parms);
if (resultadoConcurso != null)
{
resultadoConcurso.ganhadores = Db.GetAll(_sqlGetGanhadorByResultadoConcursoId, MakeGanhador, parms);
resultadoConcurso.faturamento = _faturamentoLotericaRepository.GetByConcursoId(resultadoConcurso.concurso.Id);
}
return(resultadoConcurso);
}
public void Service_ResultadoConcurso_Deveria_Adicionar_ResultadoConcurso_Sem_Aposta()
{
_concurso = ObjectMother.GetConcursoSemApostas();
ResultadoConcurso resultado = new ResultadoConcurso(_concurso);
List <Aposta> apostas = new List <Aposta>();
_apostaRepository
.Setup(x => x.GetByConcursoId(It.IsAny <int>()))
.Returns(apostas);
_apostaRepository
.Setup(x => x.GetByConcursoIdComBolao(It.IsAny <int>()))
.Returns(apostas);
_resultadoConcursoRepository
.Setup(y => y.Adicionar(It.IsAny <ResultadoConcurso>()));
randomMoq
.Setup(r => r.Next(1, 61))
.Returns(() => numeroAleatorio++);
resultado = _service.GerarResultadoConcurso(resultado, randomMoq.Object);
_service.Adicionar(resultado);
_apostaRepository
.Verify(x => x.GetByConcursoId(_concurso.Id));
_resultadoConcursoRepository
.Verify(y => y.Adicionar(resultado));
resultado.premioTotal.Should().Be(0);
resultado.numerosResultado.Count().Should().Be(6);
resultado.premioQuadraPorJogador.Should().Be(0);
resultado.premioQuinaPorJogador.Should().Be(0);
resultado.premioSenaPorJogador.Should().Be(0);
resultado.qtdAcertadoresQuadra.Should().Be(0);
resultado.qtdAcertadoresQuina.Should().Be(0);
resultado.qtdAcertadoresSena.Should().Be(0);
resultado.ganhadores.Count.Should().Be(0);
foreach (var item in resultado.numerosResultado)
{
if (item > 60 || item < 1)
{
Assert.Fail();
}
}
}
public void Domain_ResultadoConcurso_Deveria_Adicionar_Premio_Por_Ganhador()
{
Aposta aposta = ObjectMother.GetApostaComId();
_resultadoConcurso = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoConcurso();
_resultadoConcurso.AdicionarGanhador(aposta, 3);
_resultadoConcurso.AdicionarGanhador(aposta, 4);
_resultadoConcurso.AdicionarGanhador(aposta, 5);
_resultadoConcurso.AdicionarGanhador(aposta, 6);
_resultadoConcurso.premioTotal = 10000;
_resultadoConcurso.CalcularPremioPorAposta();
_resultadoConcurso.AdicionarPremioPorGanhador();
_resultadoConcurso.ganhadores.Count.Should().Be(3);
_resultadoConcurso.ganhadores[0].valorPremio.Should().Be(1000);
_resultadoConcurso.ganhadores[1].valorPremio.Should().Be(2000);
_resultadoConcurso.ganhadores[2].valorPremio.Should().Be(7000);
}
public static ResultadoConcurso GetResultadoConcursoComGanhadores()
{
List <Aposta> apostas = new List <Aposta>();
apostas = Loterica.Common.Tests.Apostas.ObjectMother.Get3Apostas();
Concurso concurso = Loterica.Common.Tests.Concursos.ObjectMother.GetConcursoComId();
ResultadoConcurso resultado = new ResultadoConcurso(concurso);
resultado.CalculaNumeroResultado(random);
resultado.CalcularPremioTotal();
foreach (var item in apostas)
{
resultado.AdicionarGanhador(item, 4);
}
resultado.CalcularPremioPorAposta();
return(resultado);
}
public void Service_ResultadoConcurso_BuscarTodos_Deveria_Buscar_ResultadosConcurso()
{
List <ResultadoConcurso> resultados = new List <ResultadoConcurso>();
ResultadoConcurso resultado = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoConcursoComId();
resultados.Add(resultado);
resultados.Add(resultado);
resultados.Add(resultado);
_resultadoConcursoRepository
.Setup(x => x.GetAll())
.Returns(resultados);
List <ResultadoConcurso> resultadosRecebidos = _service.PegarTodos();
_resultadoConcursoRepository.Verify(x => x.GetAll());
resultadosRecebidos.Should().BeEquivalentTo(resultados);
}
public void Editar(ResultadoConcurso entidade)
{
entidade.Validar();
Dictionary <string, object> parms = new Dictionary <string, object> {
{ "Id", entidade.Id }
};
Db.Delete(_sqlDeleteGanhadorByResultadoConcursoId, parms);
Db.Update(_sqlUpdateResultadoConcurso, TakeResultadoConcurso(entidade));
foreach (var item in entidade.ganhadores)
{
item.ResultadoConcursoId = entidade.Id;
Db.Update(_sqlAddGanhador, TakeGanhador(item));
}
_faturamentoLotericaRepository.Editar(entidade.faturamento);
}
public void Service_Aposta_Deveria_Calcular_Resultado_Com_Quatro_Acertos()
{
_aposta = ObjectMother.GetAposta();
List <int> numerosResultado = new List <int> {
2, 4, 1, 6, 9, 11
};
ResultadoConcurso resultadoConcurso = new ResultadoConcurso(_aposta.concurso);
resultadoConcurso.numerosResultado.Clear();
resultadoConcurso.numerosResultado = numerosResultado;
_resultadoConcursoRepository
.Setup(x => x.GetByConcursoId(It.IsAny <int>()))
.Returns(resultadoConcurso);
int acertos = _service.CalcularResultadoFinal(_aposta);
acertos.Should().Be(4);
}
private ResultadoConcurso MakeResultadoConcurso(IDataReader reader)
{
ResultadoConcurso resultadoConcurso = new ResultadoConcurso();
resultadoConcurso.concurso = new Concurso();
resultadoConcurso.ganhadores = new List <Ganhador>();
resultadoConcurso.Id = Convert.ToInt32(reader["Id"]);
resultadoConcurso.premioTotal = Convert.ToDouble(reader["PremioTotal"]);
resultadoConcurso.premioQuadraPorJogador = Convert.ToDouble(reader["PremioQuadraPorJogador"]);
resultadoConcurso.premioQuinaPorJogador = Convert.ToDouble(reader["PremioQuinaPorJogador"]);
resultadoConcurso.premioSenaPorJogador = Convert.ToDouble(reader["PremioSenaPorJogador"]);
resultadoConcurso.qtdAcertadoresQuadra = Convert.ToInt32(reader["QtdAcertadoresQuadra"]);
resultadoConcurso.qtdAcertadoresQuina = Convert.ToInt32(reader["QtdAcertadoresQuina"]);
resultadoConcurso.qtdAcertadoresSena = Convert.ToInt32(reader["QtdAcertadoresSena"]);
resultadoConcurso.numerosResultado = ConverterStringParaNumerosResultado(Convert.ToString(reader["NumerosResultado"]));
resultadoConcurso.concurso.Id = Convert.ToInt32(reader["ConcursoId"]);
resultadoConcurso.concurso.dataFechamento = Convert.ToDateTime(reader["DataFechamento"]);
resultadoConcurso.concurso.valorTotalApostas = Convert.ToDouble(reader["ValorTotalApostas"]);
return(resultadoConcurso);
}
public void Integration_ResultadoConcurso_GetByConcursoId_Deveria_Buscar_Corretamente()
{
ResultadoConcurso resultado = _service.BuscarPorConcursoId(2);
resultado.Should().NotBeNull();
}
public int CalcularResultadoFinal(Aposta aposta)
{
ResultadoConcurso resultado = _resultadoConcursoService.BuscarPorConcursoId(aposta.concurso.Id);
return(aposta.CalcularResultadoBilhete(resultado.numerosResultado));
}
public void Domain_ResultadoConcurso_Deveria_Calcular_Premio_Total()
{
_resultadoConcurso = Loterica.Common.Tests.ResultadoConcursos.ObjectMother.GetResultadoConcurso();
_resultadoConcurso.CalcularPremioTotal();
_resultadoConcurso.premioTotal.Should().Be(7200.9);
}
