Come saltare un intero modulo unittest Python in fase di esecuzione?

Question

Vorrei che il mio modulo di unificatore di Python dicesse al test runner di saltare la sua interezza in alcune situazioni (come non essere in grado di importare un modulo o localizzare una risorsa critica).

Posso usare @unittest.skipIf(...) per saltare una classe unittest.TestCase, ma come faccio a saltare l'intero modulo ? L'applicazione dei salti a ogni classe non è sufficiente perché le definizioni di classe stesse potrebbero causare eccezioni se un modulo non riesce a importare.

Answer 1

Dopo guardando l'altro answe qui, questa è la migliore risposta che ho trovato. È brutto, incorporando l'intera suite di test nella gestione delle eccezioni, ma sembra che faccia ciò che vuoi. Saltare in modo specifico i test quando le importazioni non funzionano.

Supponendo che si stia utilizzando l'uso di nosetest -x per l'esecuzione dei test, dovrebbe passare oltre i test che saltano, almeno a quanto sembrava quando l'ho provato.

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() 

Se l'importazione fallisce, sostituisce l'esecuzione di test con un singolo test che salta semplicemente. Ho anche cercato di assicurarmi che non ingerisse eccezioni involontariamente. Questa soluzione deve molto a tutte le altre risposte e commenti alla domanda.

Se lo si esegue in modalità dettagliata si vedrà questo quando si salta,

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

Answer 2

Potrebbe essere sporco di mettere tutte le definizioni unittest.TestCase sottoclasse in un blocco try...except ma che avrebbe funzionato:

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

Nessuno dei sottoclassi sarebbe definito se l'importazione eggs fallisce e tutti coloro classi() vengono saltate. Non si rifletterebbe nell'output (buono o cattivo a seconda di ciò che si desidera).

Answer 3

Se si guarda la definizione di unittest.skipIf e unittest.skip, è possibile vedere che la chiave sta facendo raise unittest.SkipTest(reason) quando il test viene eseguito. Se stai bene con avere lo mostrano come uno saltati prova invece di più nel testrunner, si può semplicemente sollevare unittest.SkipTest te stesso durante l'importazione:

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

Running with nosetests -v dà:

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

Prova la definizione di una funzione personalizzata load_tests nel vostro modulo:

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

ho trovato che l'uso di skipTest nel programma di installazione ha funzionato bene. Se hai bisogno di un modulo importato, puoi utilizzare un blocco try per impostare ad es. module_failed = True, e nella chiamata setUp skipTest se è impostato. Questo riporta il numero corretto di salti di prova con solo un breve blocco try necessario:

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

Il solution proposto da opere Oto ed è più facile che la soluzione accettata a mio parere. Ma c'è almeno un aspetto negativo.Se si esegue una query my_module in un decoratore di saltare un singolo test, come

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

si otterrà un NameError: name 'my_module' is not defined. La soluzione viene messa la cesta all'interno la definizione della funzione:

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

Answer 7

Combinando le risposte menzionate e utilizzando 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

Per pitone 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)) 
...