示例#1
0
class TestLances(unittest.TestCase):
    def setUpClass():
        # SetUp antes de todos os testes da classe
        pass

    def setUp(self):
        # SetUp antes de cada testes da classe
        self.phyl = Cliente("Phyl")
        self.lance_do_phyl = Lance(self.phyl, 150.0)
        self.leilao = Leilao("1 Saco de Arroz de 5kg")

    def test_maior_e_menor_valor_de_um_lance_quando_adicionados_ordem_crescente(
            self):
        igor = Cliente("Igor")
        lance_do_igor = Lance(igor, 100.0)

        self.leilao.propoe(lance_do_igor)
        self.leilao.propoe(self.lance_do_phyl)

        menor_valor_esperado = 100.0
        maior_valor_esperado = 150.0

        self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
        self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    def test_maior_e_menor_valor_de_um_lance_quando_adicionados_ordem_decrescente(
            self):
        luana = Cliente("Luana")
        lance_do_luana = Lance(luana, 80.0)

        self.leilao.propoe(self.lance_do_phyl)
        self.leilao.propoe(lance_do_luana)

        menor_valor_esperado = 80.0
        maior_valor_esperado = 150.0

        self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
        self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    def test_mesmo_valor_para_o_maior_e_menor_lance_quando_leilao_tiver_um_lance(
            self):
        self.leilao.propoe(self.lance_do_phyl)

        self.assertEqual(150.0, self.leilao.menor_lance)
        self.assertEqual(150.0, self.leilao.maior_lance)

    def test_maior_e_menor_valor_quando_o_leilao_tiver_tres_lances(self):
        igor = Cliente("Igor")
        lance_do_igor = Lance(igor, 10.0)
        sarah = Cliente("Sarah")

        lance_da_sarah = Lance(sarah, 200.0)

        self.leilao.propoe(lance_do_igor)
        self.leilao.propoe(self.lance_do_phyl)
        self.leilao.propoe(lance_da_sarah)

        menor_valor_esperado = 100.0
        maior_valor_esperado = 200.0

        self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
        self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    def tearDown(self):
        # TearDown depois de cada teste
        pass

    def tearDownClass():
        # TearDown depois de todos os testes da classe
        pass
示例#2
0
class TestLeilao(TestCase):
    def setUp(self):
        self.gui = Usuario('Gui', 500.0)
        self.lance_do_gui = Lance(self.gui, 150.0)

        self.leilao = Leilao('Celular')

    def test_deve_retornar_o_maior_e_o_menor_valor_de_um_lance_quando_adicionados_em_ordem_crescente(
            self):

        yuri = Usuario('Yuri', 500.0)
        lance_do_yuri = Lance(yuri, 100.0)

        self.leilao.propoe(lance_do_yuri)
        self.leilao.propoe(self.lance_do_gui)

        menor_valor_esperado = 100.0
        maior_valor_esperado = 150.0

        self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
        self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    def test_não_deve_permitir_um_lance_em_ordem_decrescente(self):
        with self.assertRaises(LanceInvalido):
            yuri = Usuario('Yuri', 500.0)
            lance_do_yuri = Lance(yuri, 100.0)
            self.leilao.propoe(self.lance_do_gui)
            self.leilao.propoe(lance_do_yuri)

    def test_deve_retornar_o_mesmo_valor_para_maior_e_menor_lance_quando_leilao_tiver_um_lance(
            self):
        self.leilao.propoe(self.lance_do_gui)

        self.assertEqual(150.0, self.leilao.menor_lance)
        self.assertEqual(150.0, self.leilao.maior_lance)

    def test_deve_retornar_o_maior_e_menor_valor_quando_o_leilao_tiver_tres_lances(
            self):
        yuri = Usuario('Yuri', 500.0)
        lance_do_yuri = Lance(yuri, 100.0)

        vini = Usuario('Vini', 500.0)
        lance_do_vini = Lance(vini, 200.0)

        self.leilao.propoe(lance_do_yuri)
        self.leilao.propoe(self.lance_do_gui)
        self.leilao.propoe(lance_do_vini)

        menor_valor_esperado = 100.0
        maior_valor_esperado = 200.0

        self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
        self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    # Se o leilão não tiver lances, deve permitir propor um lance.
    def test_deve_permitir_propor_um_lance_caso_o_leilao_nao_tenha_lances(
            self):
        self.leilao.propoe(self.lance_do_gui)

        quantidade_de_lances_recebidos = len(self.leilao.lances)
        self.assertEqual(1, quantidade_de_lances_recebidos)

    # Se o ulitmo usuario for diferente, deve permitir propor o lance
    def test_deve_permitir_propor_um_lance_caso_o_ultimo_usuario_seja_diferente(
            self):
        yuri = Usuario('Yuri', 500.0)
        lance_do_yuri = Lance(yuri, 200.0)

        self.leilao.propoe(self.lance_do_gui)
        self.leilao.propoe(lance_do_yuri)

        quantidade_de_lances_recebidos = len(self.leilao.lances)
        self.assertEqual(2, quantidade_de_lances_recebidos)

    # se o ultimo usuario for o mesmo, não deve permitir propor o lance

    def test_nao_deve_permitir_propor_o_lance_se_o_ultimo_usuario_for_o_mesmo(
            self):
        lance_do_gui200 = Lance(self.gui, 200.0)

        with self.assertRaises(LanceInvalido):
            self.leilao.propoe(self.lance_do_gui)
            self.leilao.propoe(lance_do_gui200)
示例#3
0
class TestLeilao(TestCase):

    def setUp(self):
        self.luan = Usuario("luan", 500.0)
        self.lance_do_luan = Lance(self.luan, 150.0)
        self.leilao = Leilao("Celular")

    def test_deve_retornar_o_maior_e_o_menor_valor_de_um_lance_quando_adicionados_em_ordem_crescente(self):
        lucas = Usuario("lucas", 500.0)
        lance_do_lucas = Lance(lucas, 250.0)

        self.leilao.propoe(self.lance_do_luan)
        self.leilao.propoe(lance_do_lucas)

        # avaliador = Avaliador()
        # avaliador.avalia(self.leilao)

        menor_valor_esperado = 150.0
        maior_valor_esperado = 250.0
        self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
        self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    # def test_deve_retornar_o_maior_e_o_menor_valor_de_um_lance_quando_adicionados_em_ordem_decrescente(self):
    #     lucas = Usuario("lucas")
    #     lance_do_lucas = Lance(lucas, 250.0)
    #     self.leilao.propoe(lance_do_lucas)
    #     self.leilao.propoe(self.lance_do_luan)

    #     # avaliador = Avaliador()
    #     # avaliador.avalia(self.leilao)

    #     menor_valor_esperado = 150.0
    #     maior_valor_esperado = 250.0
    #     self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
    #     self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    def test_nao_deve_permitir_propor_um_lance_em_ordem_descrescente(self):
        with self.assertRaises(LanceInvalido):
            lucas = Usuario("lucas", 500.0)
            lance_do_lucas = Lance(lucas, 250.0)
            self.leilao.propoe(lance_do_lucas)
            self.leilao.propoe(self.lance_do_luan)

            # avaliador = Avaliador()
            # avaliador.avalia(self.leilao)

            # menor_valor_esperado = 150.0
            # maior_valor_esperado = 250.0
            # self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
            # self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    def test_deve_retornar_o_mesmo_valor_para_o_maior_e_menor_lance_quando_leilao_tiver_um_lance(self):
        self.leilao.propoe(self.lance_do_luan)

        # avaliador = Avaliador()
        # avaliador.avalia(self.leilao)

        self.assertEqual(150.0, self.leilao.menor_lance)
        self.assertEqual(150.0, self.leilao.maior_lance)

    def test_deve_retornar_o_maior_e_o_menor_valor_quando_o_leilao_tiver_tres_lances(self):
        lucas = Usuario("lucas", 500.0)
        lance_do_lucas = Lance(lucas, 250.0)
        dale = Usuario("Dale", 500.0)
        lance_do_dale = Lance(dale, 500.0)

        self.leilao.propoe(self.lance_do_luan)
        self.leilao.propoe(lance_do_dale)
        self.leilao.propoe(lance_do_lucas)

        # avaliador = Avaliador()
        # avaliador.avalia(self.leilao)

        menor_valor_esperado = 150.0
        maior_valor_esperado = 500.0
        self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
        self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    def test_dev_permitir_propor_um_lance_caso_o_leolaio_nao_tenha_lances(self):
        self.leilao.propoe(self.lance_do_luan)

        quantidade_de_lances_recebida = len(self.leilao.lances)
        self.assertEqual(1, quantidade_de_lances_recebida)

    def test_deve_permitir_propor_um_lance_caso_o_ultimo_usuario_seja_diferente(self):
        lucas = Usuario("lucas", 500.0)
        lance_do_lucas = Lance(lucas, 250.0)

        self.leilao.propoe(self.lance_do_luan)
        self.leilao.propoe(lance_do_lucas)

        quantidade_de_lances_recebida = len(self.leilao.lances)

        self.assertEqual(2, quantidade_de_lances_recebida)

    def test_nao_deve_permitir_propor_lance_caso_o_usuario_seja_o_mesmo(self):
        lance_do_luan2 = Lance(self.luan, 200.0)

        with self.assertRaises(LanceInvalido):
            self.leilao.propoe(self.lance_do_luan)
            self.leilao.propoe(lance_do_luan2)
示例#4
0
class TestLeilao(TestCase):
    def setUp(self):
        self.arthur = Usuario('arthur', 500.0)
        self.lance_do_arthur = Lance(self.arthur, 150.0)
        self.leilao = Leilao('Celular')

    def test_deve_retornar_o_maior_e_o_menor_valor_de_um_lance_quando_adicionados_em_ordem_crescente(
            self):
        pedro = Usuario('pedro', 500.0)
        lance_do_pedro = Lance(pedro, 100.0)

        self.leilao.propoe(lance_do_pedro)
        self.leilao.propoe(self.lance_do_arthur)

        menor_valor_esperado = 100.0
        maior_valor_esperado = 150.0

        self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
        self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    def test_nao_deve_permitir_propor_um_lance_em_ordem_decrescente(self):

        with self.assertRaises(LanceInvalido):
            pedro = Usuario('pedro', 500.0)
            lance_do_pedro = Lance(pedro, 100.0)

            self.leilao.propoe(self.lance_do_arthur)
            self.leilao.propoe(lance_do_pedro)

    def test_deve_retornar_o_mesmo_valor_para_o_maior_e_menor_lance_quando_leilao_tiver_um_lance(
            self):
        self.leilao.propoe(self.lance_do_arthur)

        self.assertEqual(150.0, self.leilao.menor_lance)
        self.assertEqual(150.0, self.leilao.maior_lance)

    def test_deve_retornar_o_maior_e_o_menor_valor_quando_o_leilao_tiver_tres_lances(
            self):
        pedro = Usuario('pedro', 500.0)
        lance_do_pedro = Lance(pedro, 100.0)
        vini = Usuario('vini', 500.0)

        lance_do_vini = Lance(vini, 200.0)

        self.leilao.propoe(lance_do_pedro)
        self.leilao.propoe(self.lance_do_arthur)
        self.leilao.propoe(lance_do_vini)

        menor_valor_esperado = 100.0
        maior_valor_esperado = 200.0

        self.assertEqual(menor_valor_esperado, self.leilao.menor_lance)
        self.assertEqual(maior_valor_esperado, self.leilao.maior_lance)

    def test_deve_permitir_propor_um_lance_caso_o_leilao_nao_tenha_lances(
            self):
        self.leilao.propoe(self.lance_do_arthur)

        quantidade_de_lances_recebido = len(self.leilao.lances)
        self.assertEqual(1, quantidade_de_lances_recebido)

    def test_deve_permitir_propor_um_lance_caso_o_ultimo_usuario_seja_diferente(
            self):
        pedro = Usuario('pedro', 500.0)
        lance_do_pedro = Lance(pedro, 200.0)

        self.leilao.propoe(self.lance_do_arthur)
        self.leilao.propoe(lance_do_pedro)

        quantidade_de_lances_recebido = len(self.leilao.lances)

        self.assertEqual(2, quantidade_de_lances_recebido)

    def test_nao_deve_permitir_propor_lance_caso_o_usuario_seja_o_mesmo(self):
        lance_do_arthur200 = Lance(self.arthur, 200.0)

        with self.assertRaises(LanceInvalido):
            self.leilao.propoe(self.lance_do_arthur)
            self.leilao.propoe(lance_do_arthur200)