Tests unitaires en python avec nez: Faire des tests séquentiels

Question

J'apprends juste à faire des tests unitaires. Je suis sur Python/nose/wing IDE.

(The project que j'écris des tests pour un cadre de simulations, et entre autres choses, il vous permet d'exécuter des simulations à la fois synchrone et asynchrone, et les résultats de la simulation doivent être les mêmes dans les deux.)

Le truc, c'est que certains de mes tests utilisent des résultats de simulation créés dans d'autres tests. Par exemple, synchronous_test calcule une certaine simulation en mode synchrone, mais je veux ensuite la calculer en mode asynchrone et vérifier que les résultats sont identiques.

Comment structurer ceci? Est-ce que je les mets tous dans une fonction de test, ou fais un asynchronous_test séparé? Est-ce que je passe ces objets d'une fonction de test à une autre? De plus, gardez à l'esprit que tous ces tests passeront par un générateur de test, donc je peux faire les tests pour chacun des paquets de simulation inclus avec mon programme.

Answer 1

Vous pouvez ajouter des tests qui ont besoin de calculer une fois par classe à la « configuration » de cette classe. A titre d'exemple:

from nose.tools import * 
class Test_mysim(): 
    def setup(self): 
     self.ans = calculate_it_once() 

    def test_sync(self): 
     ans=calculate_it_sync() 
     assert_equal(ans,self.ans) 

    def test_async(self): 
     ans=calculate_it_async() 
     assert_equal(ans,self.ans) 

Answer 2

En général, je recommanderais pas en faisant dépendre un test d'un autre. Faites le synchrone_test, faites le test asynchrone, comparez-les chacun à la sortie correcte attendue, pas les uns aux autres.

donc quelque chose comme:

class TestSimulate(TestCase): 
    def setup(self): 
     self.simpack = SimpackToTest() 
     self.initial_state = pickle.load("initial.state") 
     self.expected_state = pickle.load("known_good.state") 

    def test_simulate(self): 
     state = simulate(self.simpack, self.initial_state) 
     # assert_equal will require State to implement __eq__ in a meaningful 
     # way. If it doesn't, you'll want to define your own comparison 
     # function. 
     self.assert_equal(self.expected_state, state) 

    def test_other_simulate(self): 
     foo = OtherThing(self.simpack) 
     blah = foo.simulate(self.initial_state) 
     state = blah.state 
     self.assert_equal(self.expected_state, state)