come accedere all'impostazione unittest.main (verbosity) in unittest.TestCase

Question

In base alla documentazione, è possibile impostare il livello di verbosità di un python unittest quando si chiama unittest.main, ad es.

unittest.main(verbosity=2) 

Come posso accedere a queste informazioni all'interno di un unittest.TestCase?

Answer 1

Un modo per ottenere questo è sottoclasse unittest.TestCase e unittest.main in un file. Qui, si definisce una variabile (es globalverb) la può essere utilizzato globalmente o come classe o Singleton, e poi si ignora unittest.main:

def main(*args, **kwargs): 

    # parse arguments etc to get the verbosity number or whatever 
    # ... 
    # set this number to the defined class 
    globalverb = verbose_number 
    return unittest.main(*args, **kwargs) 

Successivamente, sottoclasse unittest.TestCase:

class MyTestCase(unittest.TestCase): 
    def my_special_function(self): 
     if globalverb ... 

Con questo approccio è possibile utilizzare verbose, verbosità o qualsiasi altro numero e informazione in un TestCase (derivato), da argomenti passati a un unittest.

commenti benvenuto.

Answer 2

Non sono riuscito a far funzionare la soluzione di Martjin Pieters, credo perché unittest.main esegue i test quando viene inizializzato, prima che il suo risultato sia stato assegnato al globale.

Invece, ho sostituito il mio initialiation con:

 
    def new_parseArgs(self, argv): 
     global old_parseArgs,verbosity 
     old_parseArgs(self, argv) 
     verbosity = self.verbosity 

    if __name__ == '__main__': 
     # monkeypatch unittest.TestProgram.parseArgs() to save verbosity 
     # in a global variable 
     old_parseArgs = unittest.TestProgram.parseArgs 
     unittest.TestProgram.parseArgs = new_parseArgs 

     unittest.main() 

Nei casi di test che hanno bisogno di conoscere il livello di dettaglio, io uso qualcosa di simile:

 
      global verbosity 

    ... 

      if verbosity >= 2: 
       print("Keys' order: %s" % dd.keys()) 

Answer 3

Il problema con qualsiasi metodo basato sulla patch o sottoclasse unittest.TestProgram è che è necessario ottenere la patch in loco prima che sia avviato unittest.TestProgram. Ma questo non sara 'possibile se il caso di test viene eseguito tramite la scoperta:

python -m unittest discover -v 

Un approccio che funziona nel caso di scoperta è quella di utilizzare il modulo inspect per cercare lo stack fino a quando viene trovato un metodo su unittest.TestProgram :

import inspect 
import unittest 

def unittest_verbosity(): 
    """Return the verbosity setting of the currently running unittest 
    program, or 0 if none is running. 

    """ 
    frame = inspect.currentframe() 
    while frame: 
     self = frame.f_locals.get('self') 
     if isinstance(self, unittest.TestProgram): 
      return self.verbosity 
     frame = frame.f_back 
    return 0 

Answer 4

La mia soluzione era molto diversa. Invece della monkeypatching ho approfittato del fatto che tutti i miei test sono stati avviati tramite script di lancio appositamente predisposti. Raccoglie varie variabili di configurazione e ambiente di setup, quindi è stato abbastanza semplice aggiungere solo un'esportazione extra.

Potrebbe essere una soluzione ragionevole per i casi più generici, invece di eseguire test direttamente, creare test-runner.sh (o qualsiasi altra cosa) che farà esattamente la stessa chiamata di shell ma con un'esportazione extra prefissata.

Perché uno un'immagine vale migliaia di parole:

Questo è il mio test runner:

#!/usr/bin/env bash 

VERBOSE=false 

while getopts ":vt:" opt; do 
    case $opt in 
     t) 
      TEST_TO_RUN=$OPTARG 
      ;; 
     v) 
      VERBOSE=true 
      ;; 
     \?) 
      echo "Invalid option: -$OPTARG" >&2 
      exit 1 
      ;; 
     :) 
      echo "Option -$OPTARG requires an argument." >&2 
      exit 1 
     ;; 
    esac 
done 

ENVS="" 
ENVS+=" PYTHONPATH=$PYTHONPATH:$PWD" 

PARAMS="" 
PARAMS+=" -s --nologcapture --with-id" 
PARAMS+=" --cov-config=.apirc --cov-report html --with-cov" 

SERVER_PRIMER="coverage run --rcfile=.apirc" 

if [[ ! -z "$TEST_TO_RUN" ]]; then 
    PARAMS+=" $TEST_TO_RUN" 
fi 

if [[ "$VERBOSE" = true ]]; then 
    PARAMS+=" -v" 
    ENVS+=" TEST_VERBOSITY=2" 
fi 

eval "$ENVS nosetests $PARAMS" 

RESULT_TEST=$? 

E poi ho questo metodo su unit test:

@property 
def verbosity(self): 
    return int(os.environ.get('TEST_VERBOSITY', 0)) 

Answer 5

scalare la pila , trova l'istanza "TestProgram" creata da unittest.main() e accedi al campo della verbosità:

class MyTestCase(unittest.TestCase): 

    def test_verbosity(self): 
     """Return current verbosity""" 
     for f in inspect.getouterframes(inspect.currentframe()): 
      args, _,_, local_dict = inspect.getargvalues(f[0]) 
      if args: 
       first_arg = args[0] 
       first_value = local_dict[first_arg] 
       if type(first_value).__name__ == "TestProgram": 
        return first_value.verbosity 

Answer 6

Se si desidera accedere all'opzione -v, è possibile verificarla con self._resultForDoCleanups.showAll nel test (ereditando da unittest.TestCase). Il campo è vero se è richiesto il -v per quel test.