¿Cómo omito un módulo de prueba de unidad de Python completo en tiempo de ejecución?

Question

Me gustaría que mi módulo de prueba de Python le diga al corredor de prueba que omita todo en algunas situaciones (como no poder importar un módulo o localizar un recurso crítico).

puedo usar @unittest.skipIf(...) saltarse una clase unittest.TestCase, pero ¿cómo puedo saltar la totalidad módulo? Aplicar saltos a cada clase no es suficiente porque las propias definiciones de clase podrían causar excepciones si un módulo no puede importar.

Answer 1

Después de mirar en el otro answe Aquí, esta es la mejor respuesta que he encontrado. Es feo, integra todo el conjunto de pruebas en el manejo de excepciones, pero parece hacer lo que quiere. Saltarse las pruebas específicamente cuando las importaciones no funcionan.

Suponiendo que está hablando de usar nosetests -x para ejecutar las pruebas, debe pasar las pruebas que omiten, al menos cuando lo probé.

import unittest 
try: 
    import PyQt4 
    # the rest of the imports 


    # actual tests go here. 
    class TestDataEntryMixin(unittest.TestCase): 
     def test_somefeature(self): 
      # .... 

except ImportError, e: 
    if e.message.find('PyQt4') >= 0: 
     class TestMissingDependency(unittest.TestCase): 

      @unittest.skip('Missing dependency - ' + e.message) 
      def test_fail(): 
       pass 
    else: 
     raise 

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

Si la importación falla, reemplaza la ejecución de prueba con una sola prueba que simplemente omite. También intenté asegurarme de que no se traga ninguna excepción involuntariamente. Esta solución debe mucho a todas las demás respuestas y comentarios a la pregunta.

Si lo ejecuta en modo detallado verá esto cuando se salta,

test_fail (test_openihm_gui_interface_mixins.TestMissingDependency) ... skipped 'Missing dependency - No module named PyQt4' 

Answer 2

Podría ser sucia para poner todas las unittest.TestCase definiciones de subclases en un bloque try...except pero funcionaría:

import unittest 
try: 
    import eggs 
    class Spam(unittest.TestCase): 
     pass 
    class Ham(unittest.TestCase): 
     pass 
    # ... 
except ImportError: 
    # print 'could not import eggs' 
    pass 

Ninguna de las subclases se definiría si la importación eggs falla y todos aquellos las clases() se saltan. No se reflejaría en el resultado (bueno o malo según lo que desee).

Answer 3

Si nos fijamos en la definición de unittest.skipIf y unittest.skip, puede ver que la clave está haciendo raise unittest.SkipTest(reason) cuando se ejecuta la prueba. Si estás de acuerdo con tener que aparece como uno saltado prueba en lugar de varios en la TestRunner, sólo tiene que levantar unittest.SkipTest a sí mismo en la importación:

import unittest 
try: 
    # do thing 
except SomeException: 
    raise unittest.SkipTest("Such-and-such failed. Skipping all tests in foo.py") 

Correr con nosetests -v da:

Failure: SkipTest (Such-and-such failed. Skipping all tests in foo.py) ... SKIP: 
Such-and-such failed. Skipping all tests in foo.py 

---------------------------------------------------------------------- 
Ran 1 test in 0.002s 

OK (SKIP=1) 

Answer 4

Intenta definir una función personalizada load_tests en su módulo:

import unittest 
try: 
    (testcases) 
except ImportError as e: 
    def load_tests(*args, **kwargs): 
     print("Failed to load tests: skipping") 
     return unittest.TestSuite() # no tests 

Answer 5

He encontrado que el uso de skipTest en la Configuración del funcionó bien. Si necesita importar un módulo, use un bloque de prueba para configurar, p. module_failed = Verdadero, y en setUp call skipTest si está configurado. Informa del número correcto de saltos de prueba con sólo una corta bloque try necesario:

import unittest 

try: 
    import my_module 
    module_failed = False 
except ImportError: 
    module_failed = True 

class MyTests(unittest.TestCase): 
    def setUp(self): 
     if module_failed: 
      self.skipTest('module not tested') 

    def test_something(self): 
      #... 

Answer 6

El solution propuesto por obras Oto y es más fácil que la solución aceptada en mi opinión. Pero hay al menos un inconveniente.Si consulta my_module en un decorador de saltarse una sola prueba como

@unittest.skipIf(my_module.support_foo, 'foo not supported') 
def test_foo(self): 
... 

obtendrá un NameError: name 'my_module' is not defined. La solución se puso el salto dentro la definición de función:

def test_foo(self): 
    if not my_module.support_foo: 
     self.skipTest('foo not supported') 

Answer 7

La combinación de las respuestas mencionados y el uso de this answer:

import unittest 
def module_exists(module_name): 
    try: 
     __import__(module_name) 
    except ImportError: 
     return False 
    else: 
     return True 

class TestClass(unittest.TestCase): 

    @unittest.skipUnless(module_exists("moduleA"), 'ModuleA not installed') 
    def test_something(self): 
     # test something with moduleA 

Answer 8

para Python 2.7+ (o usando backport unittest2):

... 

import unittest 

def setUpModule(): 
    try: 
     import something 
    except ImportError as err: 
     raise unittest.SkipTest(str(err)) 

class Tests(unittest.TestCase): 
    @classmethod 
    def setUpClass(cls): 
     try: 
      import something 
     except ImportError as err: 
      raise unittest.SkipTest(str(err)) 
...