Resumo : neste tutorial, você aprenderá sobre os equipamentos de teste do Python, incluindo setUp()os tearDown()métodos.
Introdução aos equipamentos de teste do Python
Por definição, um acessório de teste é uma função ou método executado antes e depois da execução de um bloco de código de teste. Ou seja, é uma etapa realizada antes ou depois de um teste.
Luminárias em nível de módulo
Suponha que você tenha um módulo de teste chamado test_my_module.py. No test_my_module.py, as funções setUpModule()e tearDownModule()são os fixtures no nível do módulo.
- A
setUpModule()função é executada antes de todos os métodos de teste no módulo de teste. - A
tearDownModule()função é executada após todos os métodos no módulo de teste.
Veja o exemplo a seguir:
import unittest
def setUpModule():
print('Running setUpModule')
def tearDownModule():
print('Running tearDownModule')
class TestMyModule(unittest.TestCase):
def test_case_1(self):
self.assertEqual(5+5, 10)
def test_case_2(self):
self.assertEqual(1+1, 2)Linguagem de código: Python ( python )Se você executar o teste:
python -m unittest -vLinguagem de código: Python ( python )Saída:
Running setUpModule
test_case_1 (test_my_module.TestMyModule) ... ok
test_case_2 (test_my_module.TestMyModule) ... ok
Running tearDownModule
----------------------------------------------------------------------
Ran 2 tests in 0.001s
OKLinguagem de código: Python ( python )Neste exemplo, a setUpModule()função é executada antes de todos os métodos de teste e a tearDownModule()função é executada depois de todos os métodos de teste.
Jogos de nível de classe
Os setUpClass()e tearDownClass()são acessórios de nível de classe:
- As
setUpClass()execuções antes de todos os métodos de teste de uma classe - O
tearDownClass()executa depois de todos os métodos de teste de uma classe.
Por exemplo:
import unittest
def setUpModule():
print('Running setUpModule')
def tearDownModule():
print('Running tearDownModule')
class TestMyModule(unittest.TestCase):
@classmethod
def setUpClass(cls):
print('Running setUpClass')
@classmethod
def tearDownClass(cls):
print('Running tearDownClass')
def test_case_1(self):
self.assertEqual(5+5, 10)
def test_case_2(self):
self.assertEqual(1+1, 2)Linguagem de código: Python ( python )Neste exemplo, adicionamos os métodos de classe: setUpClass()e tearDownClass()à TestMyModuleclasse.
Se você executar o teste, verá a seguinte saída:
Running setUpModule
Running setUpClass
test_case_1 (test_my_module.TestMyModule) ... ok
test_case_2 (test_my_module.TestMyModule) ... ok
Running tearDownClass
Running tearDownModule
----------------------------------------------------------------------
Ran 2 tests in 0.001s
OKLinguagem de código: Python ( python )Luminárias de nível de método
Os setUp()e tearDown()são fixtures de nível de método:
- É
setUp()executado antes de cada método de teste na classe de teste. - É
tearDown()executado após cada método de teste na classe de teste.
Por exemplo:
import unittest
def setUpModule():
print('Running setUpModule')
def tearDownModule():
print('Running tearDownModule')
class TestMyModule(unittest.TestCase):
@classmethod
def setUpClass(cls):
print('Running setUpClass')
@classmethod
def tearDownClass(cls):
print('Running tearDownClass')
def setUp(self):
print('')
print('Running setUp')
def tearDown(self):
print('Running tearDown')
def test_case_1(self):
print('Running test_case_1')
self.assertEqual(5+5, 10)
def test_case_2(self):
print('Running test_case_2')
self.assertEqual(1+1, 2)Linguagem de código: Python ( python )O seguinte mostra o resultado do teste:
Running setUpModule
Running setUpClass
test_case_1 (test_my_module.TestMyModule) ...
Running setUp
Running test_case_1
Running tearDown
ok
test_case_2 (test_my_module.TestMyModule) ...
Running setUp
Running test_case_2
Running tearDown
ok
Running tearDownClass
Running tearDownModule
----------------------------------------------------------------------
Ran 2 tests in 0.002s
OKLinguagem de código: Python ( python )Neste exemplo, setUp()and tearDown()é executado antes e depois de cada método de teste, incluindo test_case_1()and test_case_2().
Exemplo de acessórios de teste Python
Primeiro, defina as classes chamadas BankAccounte InsufficientFundas classes no bank_account.pymódulo:
class InsufficientFund(Exception):
pass
class BankAccount:
def __init__(self, balance: float) -> None:
if balance < 0:
raise ValueError('balance cannot be negative')
self._balance = balance
@property
def balance(self) -> float:
return self._balance
def deposit(self, amount: float) -> None:
if amount <= 0:
raise ValueError('The amount must be positive')
self._balance += amount
def withdraw(self, amount: float) -> None:
if amount <= 0:
raise ValueError('The withdrawal amount must be more than 0')
if amount > self._balance:
raise InsufficientFund('Insufficient ammount for withdrawal')
self._balance -= amountLinguagem de código: Python ( python )Segundo, defina a TestBankAccountclasse no test_bank_account.pymódulo:
import unittest
from bank_account import BankAccount
class TestBankAccount(unittest.TestCase):
def test_deposit(self):
self.bank_account = BankAccount(100)
self.bank_account.deposit(100)
self.assertEqual(self.bank_account.balance, 200)
def test_withdraw(self):
self.bank_account = BankAccount(100)
self.bank_account.withdraw(50)
self.assertEqual(self.bank_account.balance, 50)Linguagem de código: Python ( python )A TestBankAccountclasse possui dois métodos de teste:
test_– testar odeposit()deposit()método da conta bancária.test_– testar owithdraw()withdraw()método da conta bancária.
Ambos os métodos criam uma nova instância do BankAccount. É redundante.
Para evitar redundância, você pode criar uma instância da classe BankAccount no setUp()método e utilizá-la em todos os métodos de teste:
import unittest
from bank_account import BankAccount
class TestBankAccount(unittest.TestCase):
def setUp(self) -> None:
self.bank_account = BankAccount(100)
def test_deposit(self):
self.bank_account.deposit(100)
self.assertEqual(self.bank_account.balance, 200)
def test_withdraw(self):
self.bank_account.withdraw(50)
self.assertEqual(self.bank_account.balance, 50)Linguagem de código: Python ( python )No setUp()
- Primeiro, crie uma instância da
BankAccountclasse e atribua-a à variável de instânciaself.bank_account. - Em seguida, use
self.bank_accountinstância nos métodostest_deposit()etest_withdraw().
Ao executar métodos de teste test_deposit()e test_withdraw(), ele é setUp()executado antes de cada método de teste.
Para test_deposit()método:
setUp()
test_deposit()Linguagem de código: Python ( python )Para test_withdraw()método:
setUp()
test_withdraw()Linguagem de código: Python ( python )Se você executar o teste:
python -m unittest -vLinguagem de código: Python ( python )Ele produzirá o seguinte:
test_deposit (test_bank_account.TestBankAccount) ... ok
test_withdraw (test_bank_account.TestBankAccount) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.001s
OKLinguagem de código: Python ( python )O seguinte adiciona o tearDown()método ao TestBankAccount:
import unittest
from bank_account import BankAccount, InsufficientFund
class TestBankAccount(unittest.TestCase):
def setUp(self) -> None:
self.bank_account = BankAccount(100)
def test_deposit(self):
self.bank_account.deposit(100)
self.assertEqual(self.bank_account.balance, 200)
def test_withdraw(self):
self.bank_account.withdraw(50)
self.assertEqual(self.bank_account.balance, 50)
def tearDown(self) -> None:
self.bank_account = NoneLinguagem de código: Python ( python )O tearDown()método é atribuído Noneà self.bank_accountinstância.
Resumo
- Fixtures são funções e métodos executados antes e depois da execução dos blocos de código de teste.
- O
setUpModule()etearDownModule()é executado antes e depois de todos os métodos de teste no módulo. - O
setUpclass()andtearDownClass()é executado antes e depois de todos os métodos de teste em uma classe de teste. - O
setUp()etearDown()é executado antes e depois de cada método de teste de uma classe de teste.
