public void Avalia(Leilao leilao)
        {
            var sumValores = 0d;

            if (leilao.Lances.Count == 0)
            {
                throw new ArgumentNullException("O leilão não possui lances");
            }

            foreach (Lance lance in leilao.Lances)
            {
                if (lance.ValorLance <= 0 )
                {
                    throw new ArgumentException("O valor do lance deve ser maior que 0");
                }

                if (lance.ValorLance > maiordeTodos)
                {
                    this.MaiorLance = lance.ValorLance;
                }

                if (lance.ValorLance < this.menorDeTodos)
                {
                    this.MenorLance = lance.ValorLance;
                }

                sumValores += lance.ValorLance;

                PegaMaioresLances(leilao);

            }

            ValorMedio = sumValores / leilao.Lances.Count;

        }
        public void deveEncerrarLeiloesQueComecaramUmaSemanaAntes()
        {
            DateTime data = new DateTime(2014, 05, 05);

            Leilao leilao1 = new Leilao("Tv 20 polegadas",data);
            Leilao leilao2 = new Leilao("Play 2",data);
      
            List<Leilao> leiloesAntigos = new List<Leilao>();

            leiloesAntigos.Add(leilao1);
            leiloesAntigos.Add(leilao2);

            // criando o mock
            var dao = new Mock<LeilaoDaoFalso>();
            // ensinando a retornar os leiloes antigos quando chamar o correntes
            dao.Setup(m => m.correntes()).Returns(leiloesAntigos);

            var carteiro = new Mock<Carteiro>();

            EncerradorDeLeilao encerrador = new EncerradorDeLeilao(dao.Object, carteiro.Object);
            encerrador.Encerra();


            Assert.AreEqual(2, leiloesAntigos.Count);
            Assert.IsTrue(leiloesAntigos[0].encerrado);
            Assert.IsTrue(leiloesAntigos[1].encerrado);

            //verifica se o método f oi invocado
            dao.Verify(m => m.atualiza(leilao1),Times.Once());
            dao.Verify(m => m.atualiza(leilao2),Times.Once());


        }
        public void MaximoCincoLancePorUsuario()
        {

            var leilao = new Leilao("Yamaha Fazer 250");

            var tiao = new Usuario("Sebastiao");
            var tiago = new Usuario("Tiago");

            leilao.Propoe(new Lance(tiao, 1500));
            leilao.Propoe(new Lance(tiago, 2000));

            leilao.Propoe(new Lance(tiao, 2500));
            leilao.Propoe(new Lance(tiago, 3000));

            leilao.Propoe(new Lance(tiao, 3500));
            leilao.Propoe(new Lance(tiago, 4000));

            leilao.Propoe(new Lance(tiao, 4500));
            leilao.Propoe(new Lance(tiago, 5000));

            leilao.Propoe(new Lance(tiao, 5500));
            leilao.Propoe(new Lance(tiago, 6000));

            leilao.Propoe(new Lance(tiao, 5500));


            Assert.AreEqual(10, leilao.Lances.Count);
            Assert.AreEqual(tiago,leilao.Lances[leilao.Lances.Count-1].Usuario);
        }
 public virtual void Envia(Leilao leilao)
 {
     try
     {
         Console.Write("Opa!!! estou enviando");
     }
     catch (Exception)
     {
         Console.Write("Opa não deu");
     }
 }
        public void DeveReceberUmLance()
        {
            Leilao leilao = new Leilao("Motocicleta 150 cc");
            var usuario = new Usuario("Cesar");
                
            //validada se nenhum lance foi dado.
            Assert.AreEqual(0, leilao.Lances.Count);

            leilao.Propoe(new Lance(usuario, 1000d));

            //validade o teste com quantidade de lance e o valor que deve ser encontrado no lance único.
            Assert.AreEqual(1, leilao.Lances.Count);
            Assert.AreEqual(1000d, leilao.Lances[0].ValorLance);
        }
        public void NaoPodeTerDoisLancesSeguidosDoMesmoUSuario()
        {
            var leilao = new Leilao("Yamaha Fazer 250");

            var tiao = new Usuario("Sebastiao");
            var tiago = new Usuario("Tiago");

            leilao.Propoe(new Lance(tiao,1500));
            leilao.Propoe(new Lance(tiago, 2000));
            leilao.Propoe(new Lance(tiago, 3000));

            Assert.AreEqual(1, leilao.Lances.Count);
            Assert.AreEqual(3000, leilao.Lances[leilao.Lances.Count - 1].ValorLance);

        }
        public void DeveReceberVariosLances()
        {
            var leilao = new Leilao("Play Station 3 Novo");

            var leonardo = new Usuario("Leonardo");
            var leandro = new Usuario("Leandro");

            leilao.Propoe(new Lance(leonardo, 1500));
            leilao.Propoe(new Lance(leandro, 2000));
            leilao.Propoe(new Lance(leonardo, 3000));
            leilao.Propoe(new Lance(leandro, 3600));

            Assert.AreEqual(4,leilao.Lances.Count);
            Assert.AreEqual(1500, leilao.Lances[0].ValorLance);
            Assert.AreEqual(3600, leilao.Lances[3].ValorLance);

        }
        public void DeveEncerrarLeiloesQueComecaramUmaSemanaAntes()
        {
            DateTime data = new DateTime(2016, 01, 01);
            Leilao leilao1 = new Leilao("tv 20 polegadas",data);
            Leilao leilao2 = new Leilao("PlayStation", data);
            var carteiro = new Mock<Carteiro>();

            //LeilaoDaoFalso dao = new LeilaoDaoFalso();
            //dao.salva(leilao1);
            //dao.salva(leilao2);

            List<Leilao> leiloesAntigos = new List<Leilao>();
            leiloesAntigos.Add(leilao1);
            leiloesAntigos.Add(leilao2);

            var dao = new Mock<LeilaoDaoFalso>();
            dao.Setup(m => m.correntes()).Returns(leiloesAntigos);

            EncerradorDeLeilao encerrador = new EncerradorDeLeilao(dao.Object,carteiro.Object);

            encerrador.Encerra();

            Assert.AreEqual(2, encerrador.total);
            Assert.IsTrue(leilao1.encerrado);
            Assert.IsTrue(leilao2.encerrado);

            //leiloesAntigos = encerrador.Encerra().ToList();

            //Assert.AreEqual(2, leiloesAntigos.Count);

            //Console.Write(leiloesAntigos.Count);
            //Console.Write(encerrador.ComecouSemanaPassada(leiloesAntigos[1]));

            //Assert.IsTrue(leiloesAntigos[0].encerrado);
            //Assert.IsTrue(leiloesAntigos[1].encerrado);
        }
 public bool ComecouSemanaPassada(Leilao leilao)
 {
     return(DiasEntre(leilao.dataInicio, DateTime.Now) >= 7);
 }
        public void NaoDeveInvocarOEnvio()
        {
            DateTime data = new DateTime(2014, 05, 05);
            Leilao leilao1 = new Leilao("Tv 20 polegadas", data);

            Leilao leilao2 = new Leilao("Play 2", data);


            List<Leilao> listaRetorno = new List<Leilao>();
            listaRetorno.Add(leilao1);
            listaRetorno.Add(leilao2);

            var dao = new Mock<LeilaoDaoFalso>();
            dao.Setup(m => m.correntes()).Returns(listaRetorno);

            var carteiro = new Mock<Carteiro>();

            //aqui indico quanndo devo gerar a exceção em que método
            dao.Setup(m => m.atualiza(leilao1)).Throws(new Exception());
            dao.Setup(m => m.atualiza(leilao2)).Throws(new Exception());

            EncerradorDeLeilao encerrador = new EncerradorDeLeilao(dao.Object, carteiro.Object);
            encerrador.Encerra();

            dao.Verify(m => m.atualiza(leilao2));
            carteiro.Verify(c => c.Envia(leilao1),Times.Never());
            carteiro.Verify(c => c.Envia(leilao2),Times.Never());
        }
 public bool ComecouSemanaPassada(Leilao leilao)
 {
     return DiasEntre(leilao.dataInicio,DateTime.Now) >= 7;
 }
 public void PegaMaioresLances(Leilao leilao)
 {
     maiores = new List <Lance>(leilao.Lances.OrderByDescending(x => x.ValorLance));
     maiores = maiores.GetRange(0, leilao.Lances.Count >= 3 ? 3 : leilao.Lances.Count);
 }
 public void salva(Leilao leilao)
 {
     leiloes.Add(leilao);
 }
 public virtual Leilao atualiza(Leilao leilao)
 {
     return leilao;
 }
Beispiel #15
0
 public void salva(Leilao leilao)
 {
     leiloes.Add(leilao);
 }
        public void NaoDeveInvocarOEnvioItIsAny()
        {
            DateTime data = new DateTime(2014, 05, 05);
            Leilao leilao1 = new Leilao("Tv 20 polegadas", data);

            Leilao leilao2 = new Leilao("Play 2", data);


            List<Leilao> listaRetorno = new List<Leilao>();
            listaRetorno.Add(leilao1);
            listaRetorno.Add(leilao2);

            var dao = new Mock<LeilaoDaoFalso>();
            dao.Setup(m => m.correntes()).Returns(listaRetorno);

            var carteiro = new Mock<Carteiro>();

            //aqui indico quanndo devo gerar a exceção em que método
            dao.Setup(m => m.atualiza(leilao1)).Throws(new Exception());
            dao.Setup(m => m.atualiza(leilao2)).Throws(new Exception());

            EncerradorDeLeilao encerrador = new EncerradorDeLeilao(dao.Object, carteiro.Object);
            encerrador.Encerra();

            //carteiro.Verify(c => c.Envia(leilao1), Times.Never());
            //carteiro.Verify(c => c.Envia(leilao2), Times.Never());

            //aqui informo que quero verificar todas as vezes que o método foi executado inependente de quem ele está enviado

            carteiro.Verify(c => c.Envia(It.IsAny<Leilao>()), Times.Never());

            //verify(carteiroFalso,never()).envia(NaoDeveInvocarOEnvioItIsAny(Leilao.class));
        }
 public void PegaMaioresLances(Leilao leilao)
 {
     maiores = new List<Lance>(leilao.Lances.OrderByDescending(x => x.ValorLance));
     maiores = maiores.GetRange(0, leilao.Lances.Count >= 3 ? 3 : leilao.Lances.Count);
 }
Beispiel #18
0
 public CriadorDeLeiloes Para(string produtoLeilao)
 {
     this.leilao = new Leilao(produtoLeilao);
     return(this);
 }
        public void NaoDeveDobrarCasoNaoHajaLanceAnterior()
        {
            Leilao leilao = new Leilao("Macbook Pro 15");
            Usuario steveJobs = new Usuario("Steve Jobs");

            leilao.DobraLance(steveJobs);

            Assert.AreEqual(0, leilao.Lances.Count);
        }
        public void DeveEncontrarOsTresMaioresLances()
        {
            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(Usuarios[0], 100.0));
            leilao.Propoe(new Lance(Usuarios[1], 200.0));
            leilao.Propoe(new Lance(Usuarios[0], 300.0));
            leilao.Propoe(new Lance(Usuarios[1], 400.0));

            leiloeiro.Avalia(leilao);

            IList<Lance> maiores = leiloeiro.TresMaiores;

            Assert.AreEqual(3, maiores.Count);
            Assert.AreEqual(400, maiores[0].ValorLance, 0.00001);
            Assert.AreEqual(300, maiores[1].ValorLance, 0.00001);
            Assert.AreEqual(200, maiores[2].ValorLance, 0.00001);
        }
        public void ValorMedio()
        {

            Leilao leilao = new Leilao("playStation 3");

            double medioEsperado = (250.00 + 300.00 + 400.00) / 3;

            leilao.Propoe(new Lance(Usuarios[0], 250.00));
            leilao.Propoe(new Lance(Usuarios[1], 300.00));
            leilao.Propoe(new Lance(Usuarios[2], 400.00));

            leiloeiro.Avalia(leilao);


            Assert.AreEqual(medioEsperado, leiloeiro.ValorMedio);

        }
 public CriadorDeLeiloes Para(string produtoLeilao)
 {
     this.leilao = new Leilao(produtoLeilao);
     return this;
 }
        public void MaximoCincoLancePorUsuarioDobraLance()
        {

            var leilao = new Leilao("Yamaha Fazer 250");

            var tiao = new Usuario("Sebastiao");
            var tiago = new Usuario("Tiago");

            leilao.Propoe(new Lance(tiao, 1000));
            leilao.Propoe(new Lance(tiago, 1100));

            leilao.DobraLance(tiao);
            leilao.DobraLance(tiago);
            leilao.DobraLance(tiao);
            leilao.DobraLance(tiago);
            leilao.DobraLance(tiao);
            leilao.DobraLance(tiago);
            leilao.DobraLance(tiao);
            leilao.DobraLance(tiago);
            leilao.DobraLance(tiao);
            leilao.DobraLance(tiago);

            Assert.AreEqual(10, leilao.Lances.Count);
            Assert.AreEqual(tiago, leilao.Lances[leilao.Lances.Count - 1].Usuario);
            Assert.AreEqual(17600d, leilao.Lances[leilao.Lances.Count - 1].ValorLance);
        }
 public CriadorDeLeiloes Para(string produtoLeilao,DateTime data)
 {
     this.leilao = new Leilao(produtoLeilao,data);
     return this;
 }
Beispiel #25
0
 public virtual Leilao atualiza(Leilao leilao)
 {
     return(leilao);
 }
Beispiel #26
0
 public CriadorDeLeiloes Para(string produtoLeilao, DateTime data)
 {
     this.leilao = new Leilao(produtoLeilao, data);
     return(this);
 }
        public void NaoDeveAtualizaOsLeiloesComAteUmaSemana()
        {
            DateTime data = new DateTime(2016, 02, 06);
            Leilao leilao1 = new Leilao("Tv 20 polegadas",data);
            List<Leilao> listaRetorno = new List<Leilao>();
            listaRetorno.Add(leilao1);

            var dao = new Mock<LeilaoDaoFalso>();
            dao.Setup(m => m.correntes()).Returns(listaRetorno);

            var carteiro = new Mock<Carteiro>();

            EncerradorDeLeilao encerrador = new EncerradorDeLeilao(dao.Object, carteiro.Object);
            encerrador.Encerra();

            dao.Verify(m => m.atualiza(leilao1), Times.Never  ());
        }