Significado de unittest.main() en Python unittest module



unit tests in python (2)

Internamente, unittest.main() utiliza algunos trucos para averiguar el nombre del módulo (archivo fuente) que contiene la llamada a main() .

Luego importa estos módulos, los examina, obtiene una lista de todas las clases y funciones que podrían probarse (según la configuración) y luego crea un caso de prueba para cada uno de ellos.

Cuando la lista está lista, ejecuta cada prueba sucesivamente.

Estaba intentando aprender pruebas de unidad en Python, específicamente el módulo de prueba de unidad.

Considera las siguientes líneas:

import unittest

class abc(unittest.TestCase):
    def xyz():
      ...

if __name__ == "__main__":
    unittest.main()

Pude ver todos mis casos de prueba ejecutándose debido a la llamada a unittest.main() .

Tenía curiosidad por saber cómo esta llamada está haciendo que se ejecuten todos los casos de prueba.

Lo sé, ya que heredé de unittest.TestCase para cada clase de prueba, está haciendo toda la magia. ¿Alguna idea?


El principal asociado con unittest es en realidad una instancia de TestProgram que, cuando se crea una instancia, ejecuta todas las pruebas.

A continuación se muestra el código relevante copiado de la fuente de unittest en http://pythonhosted.org/gchecky/unittest-pysrc.html :

735  class TestProgram: 
752 -    def __init__(self, module='__main__', defaultTest=None, 
753                   argv=None, testRunner=None, testLoader=defaultTestLoader): 
754          if type(module) == type(''): 
755              self.module = __import__(module) 
756              for part in module.split('.')[1:]: 
757                  self.module = getattr(self.module, part) 
758          else: 
759              self.module = module 
760          if argv is None: 
761              argv = sys.argv 
762          self.verbosity = 1 
763          self.defaultTest = defaultTest 
764          self.testRunner = testRunner 
765          self.testLoader = testLoader 
766          self.progName = os.path.basename(argv[0]) 
767          self.parseArgs(argv) 
768          self.runTests() 
769   
770 -    def usageExit(self, msg=None): 
771          if msg: print msg 
772          print self.USAGE % self.__dict__ 
773          sys.exit(2) 
774   
775 -    def parseArgs(self, argv): 
776          import getopt 
777          try: 
778              options, args = getopt.getopt(argv[1:], 'hHvq', 
779                                            ['help','verbose','quiet']) 
780              for opt, value in options: 
781                  if opt in ('-h','-H','--help'): 
782                      self.usageExit() 
783                  if opt in ('-q','--quiet'): 
784                      self.verbosity = 0 
785                  if opt in ('-v','--verbose'): 
786                      self.verbosity = 2 
787              if len(args) == 0 and self.defaultTest is None: 
788                  self.test = self.testLoader.loadTestsFromModule(self.module) 
789                  return 
790              if len(args) > 0: 
791                  self.testNames = args 
792              else: 
793                  self.testNames = (self.defaultTest,) 
794              self.createTests() 
795          except getopt.error, msg: 
796              self.usageExit(msg) 
797   
798 -    def createTests(self): 
799          self.test = self.testLoader.loadTestsFromNames(self.testNames, 
800                                                         self.module) 
801   
802 -    def runTests(self): 
803          if self.testRunner is None: 
804              self.testRunner = TextTestRunner(verbosity=self.verbosity) 
805          result = self.testRunner.run(self.test) 
806          sys.exit(not result.wasSuccessful()) 
807   
808  main = TestProgram 

de modo que cuando ejecuta unittest.main() , se crea un objeto de TestProgram que llama self.runTests() en la línea 768. El constructor también toma su archivo actual como el módulo predeterminado que contiene las pruebas ( module='__main__' ). Cuando se llama a runTests() , a su vez se llama self.testrunner.run() . Cuando se refiere al método "ejecutar" de la clase TextTestRunner , encontrará que realmente se ejecuta e informa de todos los resultados de sus pruebas. TestProgram.parseArgs realiza la TestProgram.parseArgs de TestProgram.parseArgs en la línea 775 cuando llama a unittest.main (). self.createTests en la línea 798 es realmente responsable de descubrir todos sus casos de prueba y de crear un conjunto de pruebas. Esto es toda la magia.





python-internals