Veranderingen van variabelen tussen tests in unittest volhouden?

Hoe kan ik wijzigingen behouden die zijn aangebracht binnen hetzelfde object dat is overgenomen van TestCasein unitttest?

from unittest import TestCase, main as unittest_main
class TestSimpleFoo(TestCase):
    foo = 'bar'
    def setUp(self):
        pass
    def test_a(self):
        self.assertEqual(self.foo, 'bar')
        self.foo = 'can'
    def test_f(self):
        self.assertEqual(self.foo, 'can')
if __name__ == '__main__':
    unittest_main()

D.w.z.: ik wil dat die twee tests hierboven slagen

Antwoord 1, autoriteit 100%

Zoals sommige opmerkingen hebben herhaald, is het op deze manier structureren van uw tests waarschijnlijk een ontwerpfout in de tests zelf en moet u overwegen ze te herstructureren. Als u dit echter wilt doen en erop vertrouwt dat de testrunner die u gebruikt ze in alfabetische (schijnbaar) volgorde uitvoert, raad ik u het volgende aan.

Vergelijkbaar met wat @Matthias zei, maar ik zou één ding anders doen voor de gevallen waarin je op een later tijdstip zou besluiten om van de klas te erven.

from unittest import TestCase, main as unittest_main
class TestSimpleFoo(TestCase):
    foo = 'bar'
    def setUp(self):
        pass
    def test_a(self):
        self.assertEqual(self.__class__.foo, 'bar')
        self.__class__.foo = 'can'
    def test_f(self):
        self.assertEqual(self.__class__.foo, 'can')
if __name__ == '__main__':
    unittest_main()

Het verschil tussen dit antwoord en het antwoord van @Matthias dat je hebt geaccepteerd, is de expliciete verklaring van de klasse versus het opzoeken van de klassereferentie.

TestSimpleFoo vs self.__class__

Ik geef de voorkeur aan de dynamiek, zodat ik de tests later kan erven en beide testklassen achter elkaar kan uitvoeren en geen kruising tussen de twee heb. Omdat als u ervoor zou kiezen om van deze klasse te erven, het expliciet benoemen van de klasseverwijzing ertoe zou leiden dat beide testklassen tegen die referentie worden uitgevoerd in plaats van hun eigen respectievelijke klassen.

Antwoord 2, autoriteit 21%

Ik vind je eigen antwoord leuk vanwege de eenvoud, maar als je afzonderlijke unit-tests wilt behouden:

Blijkbaar voert unittest afzonderlijke tests uit met nieuwe exemplaren van de TestCase. Welnu, bind de objecten die moeten worden volgehouden gewoon aan iets anders dan aan zichzelf. Bijvoorbeeld:

from unittest import TestCase, main as unittest_main
class TestSimpleFoo(TestCase):
    def setUp(self):
        pass
    def test_a(self):
        TestSimpleFoo.foo = 'can'
    def test_f(self):
        self.assertEqual(TestSimpleFoo.foo, 'can')
if __name__ == '__main__':
    unittest_main()

Misschien ben je ook geïnteresseerd in setUpClass en tearDownClass:
https://docs.python.org/3/library/unittest.html#setupclass- en-teardownclass

Let ook op de uitvoeringsvolgorde van uw unit-tests:
https://docs.python.org/2/library/unittest.html#unittest. TestLoader.sortTestMethodsGebruik

Antwoord 3, autoriteit 3%

Kon het niet achterhalen; dus heb ik het uiteindelijk gehackt met meerdere niet-test_vooraf ingestelde functies:

def test_password_credentials_grant(self):
    for user in self.user_mocks:
        self.register(user)
        self.login(user)
        self.access_token(user, self.assertEqual)  # Ensures access_token is generated+valid
        self.logout(user)
        self.access_token(user, self.assertNotEqual)  # Ensures access_token is now invalid
        self.unregister(user)