Esempio n. 1
0
        public void RetornaValorDadoLeilaoComPeloMenosUmLance(double valor, double[] ofertas)
        {
            // give when then
            // Arrange Act Assert
            // Arranje - cenário de entrada
            // Dado(give) leilão com 2 clientes sendo que fulado deu dois Lances, um de 800 e outro de 1000
            // e maria deu um lance 900

            MaiorValor modalidade = new MaiorValor();
            var        leilao     = new Leilao("Jogos", modalidade);
            var        fulano     = new Interessada("Fulano", leilao);
            var        maria      = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            foreach (var oferta in ofertas)
            {
                leilao.RecebeLance(fulano, oferta);
            }

            // Act - método sob teste
            // Quando o leilão/pregão termina
            leilao.TerminaPregao();

            // Assert
            // Então o valor esperado é o maior valor, no caso é 100
            var valorEsperado = valor;
            var valorObtido   = leilao.Ganhador.Valor;

            Assert.Equal(valorEsperado, valorObtido);
        }
Esempio n. 2
0
        public void RetornaMaiorValorDadoLeilaoComPeloMenosUmLance(double valorEsperado, double[] ofertas)
        {
            //Arranje - Cenário.
            //Dado leilao com lances sem ordemd e valor
            var modalidade = new MaiorValor();
            var leilao     = new Leilao("Van Gogh", modalidade);
            var fulano     = new Interessada("Fulano", leilao);
            var maria      = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];

                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(fulano, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            //Act - método sobre teste.
            //Quando o pregão/leilão termina
            leilao.TerminaPregao();

            //Assert.
            //Então o valor esperado é o maior valor
            var valorObtido = leilao.Ganhador.Valor;

            Assert.Equal(valorEsperado, valorObtido);
        }
Esempio n. 3
0
        public void RetornaValorSuperiorMaisProximoDadoLeilaoNessaModalidade(
            double valorDestino, double valorEsperado, double[] ofertas)
        {
            // Arrange
            IModalidadeAvaliacao modalidade = new OfertaSuperiorMaisProxima(valorDestino);
            var leilao = new Leilao("Van Gogh", modalidade);
            var fulano = new Interessada("Fulano", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (var i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];

                if (i % 2 == 0)
                {
                    leilao.RecebeLance(fulano, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            // Act
            leilao.TerminaPregao();

            // Assert
            var valorObtido = leilao.Ganhador.Valor;

            Assert.Equal(valorEsperado, valorObtido);
        }
        public void RetornaMaiorValorDadoLeilaoComLances1(double esperado, List <double> valores)
        {
            //Arrange
            var leilao = new Leilao("Van gogh");
            var joao   = new Interessada("Joao", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < valores.Count; i++)
            {
                var valor = valores[i];
                if (i % 2 == 0)
                {
                    leilao.RecebeLance(joao, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            //Act
            leilao.TerminaPregao();

            var obtido = leilao.Ganhador.Valor;

            //Assert
            Assert.Equal(esperado, obtido);
        }
Esempio n. 5
0
        private void RetornaMaiorValorDadoLeilaoComPeloMenosUmLance(double valorEsperado, double[] ofertas)
        {
            IModalidadeAvaliacao modalidade = new MaiorOferta();
            var leilao  = new Leilao("Van Gogh", modalidade);
            var pessoa1 = new Interessada("Fulano", leilao);
            var pessoa2 = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];

                if (i % 2 == 0)
                {
                    leilao.RecebeLance(pessoa1, valor);
                }
                else
                {
                    leilao.RecebeLance(pessoa2, valor);
                }
            }

            leilao.TerminaPregao();

            var valorObtido = leilao.Ganhador.Valor;

            Assert.Equal(valorEsperado, valorObtido);
        }
Esempio n. 6
0
        public void NaoPermiteNovosLancesDadoLeilaoFinalizado(
            int quantidadeLaces,
            double[] ofertas)
        {
            //Arrange
            IModalidadeAvaliacao modalidade
                = new MaiorValor();
            var leilao = new Leilao("Van gogh", modalidade);
            var jose   = new Interessada("Jose", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();
            for (int i = 0; i < ofertas.Length; i++)
            {
                if (i % 2 == 0)
                {
                    leilao.RecebeLance(jose, ofertas[i]);
                }
                else
                {
                    leilao.RecebeLance(maria, ofertas[i]);
                }
            }
            leilao.TerminaPregao();

            //Act - método sob teste
            leilao.RecebeLance(jose, 1500);

            //Assert
            var valorObtido = leilao.Lances.Count();

            Assert.Equal(quantidadeLaces, valorObtido);
        }
Esempio n. 7
0
        public void NaoPermiteNovosLancesDadoLeilaoFinalizado(int qtd, double[] ofertas)
        {
            var modalidade = new MaiorValor();
            var leilao     = new Leilao("Estatua de Zeus", modalidade);
            var fulano     = new Interessada("Fulano", leilao);
            var maria      = new Interessada("Maria", leilao);

            leilao.IniciaPregao();
            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];
                if (i % 2 == 0)
                {
                    leilao.RecebeLance(fulano, valor);
                }
                leilao.RecebeLance(maria, valor);
            }
            //foreach (var valor in ofertas)
            //{
            //    leilao.RecebeLance(fulano, valor);
            //}

            leilao.TerminaPregao();

            //Act metodo sob test
            leilao.RecebeLance(fulano, 1000);
            //Assert
            var quantidadeObtida = leilao.Lances.Count();

            Assert.Equal(qtd, quantidadeObtida);
        }
        public void NaoPermiteNovosLancesDadoLeilaoFinalizado(int valorEsperada, double[] ofertas)
        {
            //arranjo - cenario
            var modalidade = new MaiorValor();
            var leilao     = new Leilao("Vanh Gogh", modalidade);
            var fulano     = new Interessada("Fulano", leilao);
            var maria      = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Length; i++)
            {
                if (i % 2 == 0)
                {
                    leilao.RecebeLance(fulano, ofertas[i]);
                }
                else
                {
                    leilao.RecebeLance(maria, ofertas[i]);
                }
            }

            leilao.TerminaPregao();

            //act -  execução sob teste
            leilao.RecebeLance(fulano, 1100);

            //assert
            Assert.Equal(valorEsperada, leilao.Lances.Count());
        }
        public void DefineGanhadorIdAoFinalizarLeilao()
        {
            //Arranje - cenário
            var leiloadoPor = "789456";
            var andre       = "1234456789";
            var bruno       = "789456123";

            var titulo      = "Novo Leilão";
            var inicio      = DateTime.Now.AddDays(-1);
            var fim         = DateTime.Now.AddDays(2);
            var lanceMinimo = 200;
            var leilao      = new Leilao(leiloadoPor, titulo, null, inicio, fim, lanceMinimo);

            leilao.IniciaPregao();

            var lance1 = new Lance(andre, 300, "456456");

            leilao.RecebeLance(lance1);

            var lance2 = new Lance(bruno, 400, "456456");

            leilao.RecebeLance(lance2);

            //Act - método sob teste.
            leilao.FinalizarLeilao();


            //Assert
            var valorObtido = leilao.LanceGanhadorId;

            Assert.Equal(lance2.Id, valorObtido);
        }
        public void NaoPermiteNovosLancesDadoLeilaoFinalizado(
            int qtdeEsperada, double[] ofertas)
        {
            //Arranje - cenário
            var leilao = new Leilao("Van Gogh"); //modalidade padrão maiorValor()
            var fulano = new Interessada("Fulano", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Count(); i++)
            {
                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(fulano, ofertas[i]);
                }
                else
                {
                    leilao.RecebeLance(maria, ofertas[i]);
                }
            }

            leilao.TerminaPregao();

            //Act - método sob teste
            leilao.RecebeLance(fulano, 1000);

            //Assert
            var qtdeObtida = leilao.Lances.Count();

            Assert.Equal(qtdeEsperada, qtdeObtida);
        }
Esempio n. 11
0
        public void NaoPermiteNovosLancesDadoLeilaoFinalizado(int qtdEsperada, double[] ofertas)
        {
            MaiorValor modalidade = new MaiorValor();

            // Arranje - cenário
            var leilao = new Leilao("Bicicleta", modalidade);

            leilao.IniciaPregao();

            var interassado1 = new Interessada("Leandro", leilao);
            var interassado2 = new Interessada("Priscila", leilao);

            foreach (var oferta in ofertas)
            {
                leilao.RecebeLance(interassado1, oferta);
            }

            leilao.TerminaPregao();

            // Act - método sob teste
            leilao.RecebeLance(interassado2, 532);
            var quantidadeDeLancesEsperado = qtdEsperada;

            Assert.Equal(leilao.Lances.Count(), quantidadeDeLancesEsperado);
            Assert.Equal(100, leilao.Lances.First().Valor);
        }
Esempio n. 12
0
        private void NaoPermiteNovosLancesDadoLeilaoFinalizado(int qtdeEsperada, double[] ofertas)
        {
            var modalidade = new MaiorOferta();
            var leilao     = new Leilao("Van Gogh", modalidade);
            var pessoa1    = new Interessada("Fulano", leilao);
            var pessoa2    = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];

                if (i % 2 == 0)
                {
                    leilao.RecebeLance(pessoa1, valor);
                }
                else
                {
                    leilao.RecebeLance(pessoa2, valor);
                }
            }

            leilao.TerminaPregao();

            var qtdeObtida = leilao.Lances.Count();

            Assert.Equal(qtdeObtida, qtdeEsperada);
        }
        [InlineData(1200, 1250, new double[] { 800, 1150, 1400, 1250 })] // Passando Dado
        public void RetornaValorSuperiorMaisProximoDadoLeilaoNessaModalidade(
            double valorDestino,
            double valoresperado,
            double[] ofertas)
        {
            //Arranjo - cenário de entrada
            IModalidadeAvaliacao modalidade = new OfertaSuperiorMaisProxima(valorDestino);
            var leilao = new Leilao("Van Gogh", modalidade);
            var fulano = new Interessada("Fulano", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];

                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(fulano, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            // Act - método sobre teste
            leilao.TerminaPregao();

            //Assert resultado esperado

            Assert.Equal(valoresperado, leilao.Ganhador.Valor);
        }
        public void NaoPermiteNovosLancesDadoLeilaoFinalizado(int qtdeEsperada, double[] ofertas)
        {
            // Arranje - Cenário
            // Dado leilão apenas com 1 lance
            var modalidade = new MaiorValor();
            var leilao     = new Leilao("Bleach", modalidade);
            var pessoa1    = new Interessada("Zaraki", leilao);
            var pessoa2    = new Interessada("Kurosaki", leilao);

            leilao.IniciaPregao();
            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];
                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(pessoa1, valor);
                }
                else
                {
                    leilao.RecebeLance(pessoa2, valor);
                }
            }

            leilao.TerminaPregao();

            // Act - método sob teste
            // Quando o leilão acabar
            leilao.RecebeLance(pessoa1, 1000);

            //Assert
            // Então o valor esperado é o maior valor
            var qtdeObtida = leilao.Lances.Count();

            Assert.Equal(qtdeEsperada, qtdeObtida);
        }
        public void RetornaValorSuperiorMaisProximoDestino(double valorDestino, double valorEsperado, double[] ofertas)
        {
            //Arranje - cenário
            //Valor aguardado seria 1250 quando valor destino de 1200
            var modalidade = new OfertaSuperiorMaisProxima(valorDestino);
            var leilao     = new Leilao("Van Gogh", modalidade);
            var fulano     = new Interessada("Fulano", leilao);
            var maria      = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Count(); i++)
            {
                if ((i % 2) == 0) //garante input de clientes alternados
                {
                    leilao.RecebeLance(fulano, ofertas[i]);
                }
                else
                {
                    leilao.RecebeLance(maria, ofertas[i]);
                }
            }

            //Act - método sob teste
            leilao.TerminaPregao();

            //Assert
            var valorObtido = leilao.Ganhador.Valor;

            Assert.Equal(valorEsperado, valorObtido);
        }
        public void DefineMaiorLanceComoGanhadorAoFinalizarLeilao(double maiorLance, double[] lanceValores)
        {
            //Arranje - cenário
            var leiloadoPor = "789456";
            var andre       = "1234456789";
            var bruno       = "789456123";

            var titulo      = "Novo Leilão";
            var inicio      = DateTime.Now.AddDays(-1);
            var fim         = DateTime.Now.AddDays(2);
            var lanceMinimo = 200;
            var leilao      = new Leilao(leiloadoPor, titulo, null, inicio, fim, lanceMinimo);

            leilao.IniciaPregao();

            //Act - método sob teste.
            for (int i = 0; i < lanceValores.Length; i++)
            {
                if (i % 2 == 0)
                {
                    leilao.RecebeLance(new Lance(bruno, lanceValores[i], "456456"));
                }
                else
                {
                    leilao.RecebeLance(new Lance(andre, lanceValores[i], "456456"));
                }
            }

            leilao.FinalizarLeilao();

            //Assert
            var valorObtido = leilao.LanceGanhador.Valor;

            Assert.Equal(maiorLance, valorObtido);
        }
Esempio n. 17
0
        public void ClienteNaoPodeRealizarDoisLancesSeguidos(
            int quantidadeLaces,
            double[] ofertas)
        {
            //Arrange
            IModalidadeAvaliacao modalidade
                = new MaiorValor();
            var leilao = new Leilao("Van gogh", modalidade);
            var maria  = new Interessada("Maria", leilao);
            var jose   = new Interessada("Jose", leilao);

            leilao.IniciaPregao();
            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];
                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(jose, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }
            leilao.TerminaPregao();

            //Act - método sob teste
            leilao.RecebeLance(jose, 1500);

            //Assert
            var valorObtido = leilao.Lances.Count();

            Assert.Equal(quantidadeLaces, valorObtido);
        }
        public void NaoPermiteNovosLancesDadosLeilaoFinalizado(
            double valorEsperado, double[] lances)
        {
            //Arranje - cenário
            var modalidade = new MaiorValor();
            var leilao     = new Leilao("Van Gogh", modalidade);
            var fulano     = new Interessada("Fulano", leilao);
            var maria      = new Interessada("Maria", leilao);

            var i = 0;

            leilao.IniciaPregao();

            for (; i < valorEsperado; i++)
            {
                var ofertante = i % 2 == 0 ? fulano : maria;
                leilao.RecebeLance(ofertante, lances[i]);
            }

            leilao.TerminaPregao();

            //Act - método sob teste

            for (; i < lances.Length; i++)
            {
                var ofertante = i % 2 == 0 ? fulano : maria;
                leilao.RecebeLance(ofertante, lances[i]);
            }

            //Assert - resultado
            var numeroDeLances = leilao.Lances.Count();

            Assert.Equal(valorEsperado, numeroDeLances);
        }
        [InlineData(new double[] { 800, 900, 990, 1000 }, 1000)] //Cenario 3 - leilao com varios lances, ordenados por valor
        public void RetornaMaiorValorDadoLeilaoComPeloMenosUmLance(double [] lances, double valorEsperado)
        {
            //Arranje - cenário
            IModalidadeAvaliacao modalidade = new MaiorValor();
            var leilao = new Leilao("Van Gogh", modalidade);

            leilao.IniciaPregao();
            var fulano = new Interessada("Fulano", leilao);
            var maria  = new Interessada("Maria", leilao);

            for (int i = 0; i < lances.Length; i++)
            {
                var valor = lances[i];

                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(fulano, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            //Act - método sob teste
            leilao.TerminaPregao();

            //Assert - valor esperado
            var valorObtido = leilao.Ganhador.Valor;//como não utizamos a pessoa no teste não passado

            Assert.Equal(valorEsperado, valorObtido);
        }
        public void RetornaMaiorValorDadoleilaoComPeloMenosUmLance(double[] ofertas)
        {
            var leilao = new Leilao("Van Gogh");
            var fulano = new Interessada("fulano", leilao);
            var maria  = new Interessada("maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];

                if ((i % 2 == 0))
                {
                    leilao.RecebeLance(fulano, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            leilao.TerminaPregao();

            var qtdeEsperada = 4;
            var qtdeObtida   = leilao.Lances.Count();

            Assert.Equal(qtdeEsperada, qtdeObtida);
        }
Esempio n. 21
0
        public void RetornaMaiorValorDadoleilaoComPeloMenosUmLance(
            double valorEsperado,
            double[] ofertas)
        {
            var modalidade = new MaiorValor();
            //Arrange - cenário
            var leilao = new Leilao("Van Gogh", modalidade);
            var fulano = new Interessada("Fulano", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];
                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(fulano, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            //código omitido
        }
        public void RetornaOValorMaiorEMaisProximoDoDesejado(double valorDesejado,
                                                             double valorEsperado,
                                                             double[] lances)
        {
            //Arranje
            var leilao   = new Leilao("Van Gogh", new MaiorLanceProximoDoValorDesejado(valorDesejado));
            var fulano   = new Interessada("Fulano", leilao);
            var beltrano = new Interessada("Beltrano", leilao);

            leilao.IniciaPregao();

            for (var i = 0; i < lances.Length; i++)
            {
                if (i % 2 == 0)
                {
                    leilao.RecebeLance(fulano, lances[i]);
                    continue;
                }

                leilao.RecebeLance(beltrano, lances[i]);
            }


            //Act
            leilao.TerminaPregao();

            //Assert
            Assert.Equal(valorEsperado, leilao.Ganhador.Valor);
        }
Esempio n. 23
0
        public void NaoPermiteNovosLancesDadoLeilaoFinalizado(int quantidadeEsperada, double [] ofertas)
        {
            //Dado leilão finalizado com X lances
            var modalidade = new MaiorValor();
            var leilao     = new Leilao("Van Gogh", modalidade);
            var fulano     = new Interessada("Fulano", leilao);
            var maria      = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];
                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(fulano, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            leilao.TerminaPregao();

            //Quando leilão recebe nova oferta de lance
            leilao.RecebeLance(fulano, 1000);

            //Então a quantidade de lances continua sendo X
            var quantidadeObtida = leilao.Lances.Count();

            Assert.Equal(quantidadeEsperada, quantidadeObtida);
        }
Esempio n. 24
0
        public void RetornaMaiorValorDadoLeilaoComPeloMenosUmLance(double valorEsperado, double[] ofertas)
        {
            //Arrange
            IModalidadeAvaliacao modalidade = new MaiorValor();
            var leilao = new Leilao("Van Gogh", modalidade);
            var jose   = new Interessada("José", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();
            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];
                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(jose, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            //Action
            leilao.TerminaPregao();

            //Assert
            Assert.Equal(valorEsperado, leilao.Ganhador.Valor);
        }
Esempio n. 25
0
        public void NaoPermiteNovosLancesDadoLeilaoFinalizado(int qtdEsperada, double[] ofertas)
        {
            //Arrange - cenários
            var modalidade = new MaiorValor();
            var leilao     = new Leilao("Van Gogh", modalidade);
            var fulano     = new Interessada("Fulano", leilao);
            var maria      = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];
                if (i % 2 == 0)
                {
                    leilao.RecebeLance(fulano, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            leilao.TerminaPregao();

            //Act - método sob teste
            leilao.RecebeLance(fulano, 1000);

            //Assert
            var qtdObtida = leilao.Lances.Count();

            Assert.Equal(qtdEsperada, qtdObtida);
        }
Esempio n. 26
0
        public void NaoPermiteNovosLancesDadoLeilaoFinalizado(int quantidadeEsperada, double[] ofertas)
        {
            //Arrange
            IModalidadeAvaliacao modalidade = new MaiorValor();
            var leilao = new Leilao("Van Gogh", modalidade);
            var jose   = new Interessada("José", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();
            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];
                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(jose, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }
            leilao.TerminaPregao();

            //Action
            leilao.RecebeLance(jose, 1000);

            //Assert
            Assert.Equal(quantidadeEsperada, leilao.Lances.Count());
        }
Esempio n. 27
0
        public void NaoPermiteNovosLancesDadoLeilaoFinalizado(int qtdeEsperada, double[] ofertas)
        {
            IModalidadeAvaliacao modalidade = new MaiorLance();
            var leilao = new Leilao("Van Gogh", modalidade);
            var fulano = new Interessada("Fulano", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];
                if ((i % 2) == 0)
                {
                    leilao.RecebeLance(fulano, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            leilao.TerminaPregao();

            leilao.RecebeLance(fulano, 1000);

            var qtdeObtida = leilao.Lances.Count();

            Assert.Equal(qtdeEsperada, qtdeObtida);
        }
        public void RetornaMaiorValorDadoLeilaoComPeloMenosUmLance(
            double valorEsperado,
            double[] ofertas)
        {
            //Arranje - cenário
            var leilao = new Leilao("Van Gogh");    //modalidade padrão maiorValor()
            var fulano = new Interessada("Fulano", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (int i = 0; i < ofertas.Count(); i++)
            {
                if ((i % 2) == 0) //garante não input de usuarios consecutivos
                {
                    leilao.RecebeLance(fulano, ofertas[i]);
                }
                else
                {
                    leilao.RecebeLance(maria, ofertas[i]);
                }
            }

            //Act - método sob teste
            leilao.TerminaPregao();

            //Assert
            var valorObtido = leilao.Ganhador.Valor;

            Assert.Equal(valorEsperado, valorObtido);
        }
Esempio n. 29
0
        public void RetornaMaiorValorDadoLeilaoComPeloMenosUmLance(
            double valorEsperado, double[] ofertas)
        {
            // Arrange - cenário
            IModalidadeAvaliacao modalidade = new MaiorValor();
            var leilao = new Leilao("Van Gogh", modalidade);
            var fulano = new Interessada("Fulano", leilao);
            var maria  = new Interessada("Maria", leilao);

            leilao.IniciaPregao();

            for (var i = 0; i < ofertas.Length; i++)
            {
                var valor = ofertas[i];

                if (i % 2 == 0)
                {
                    leilao.RecebeLance(fulano, valor);
                }
                else
                {
                    leilao.RecebeLance(maria, valor);
                }
            }

            // Act - método sob teste
            leilao.TerminaPregao();

            // Assert
            var valorObtido = leilao.Ganhador.Valor;

            Assert.Equal(valorEsperado, valorObtido);
        }
Esempio n. 30
0
        public void RetornaValorMaisProximoDadoLeilaoComValorAlvo(float valorEsperado, double valorAlvo, float[] ofertas)
        {
            //Arrange - cenário do teste
            var modalidade = new ComValorAlvo(valorAlvo);
            var leilao     = new Leilao("Excalibur", modalidade);

            var sonic  = new Interessada("Sonic", leilao);
            var arthur = new Interessada("Arthur", leilao);

            leilao.IniciaPregao();
            for (int i = 0; i < ofertas.Length; i++)
            {
                var o = ofertas[i];
                if (i % 2 == 0)
                {
                    leilao.RecebeLance(sonic, o);
                }
                else
                {
                    leilao.RecebeLance(arthur, o);
                }
            }
            ;


            //Act - método em teste
            leilao.TerminaPregao();


            //Assert - Teste do resultado
            var valorObtido = leilao.Ganhador.Valor;

            Assert.Equal(valorEsperado, valorObtido);
        }