So testen oder verspotten Sie den Inhalt von "if __name__ == '__main__'"

Angenommen, ich habe ein Modul mit folgenden Eigenschaften:

def main():
    pass

if __name__ == "__main__":
    main()

Ich möchte einen Unit-Test für die untere Hälfte schreiben (ich möchte eine 100% ige Abdeckung erreichen). Ich habe das eingebaute runpy-Modul entdeckt, das den Import / __name__Setting-Mechanismus ausführt, aber ich kann nicht herausfinden, wie man die main () -Funktion verspottet oder auf andere Weise überprüft .

Folgendes habe ich bisher versucht:

import runpy
import mock

@mock.patch('foobar.main')
def test_main(self, main):
    runpy.run_module('foobar', run_name='__main__')
    main.assert_called_once_with()

Ich werde eine andere Alternative wählen, die darin besteht, den if __name__ == '__main__'Bericht aus dem Bericht auszuschließen. Natürlich können Sie dies nur tun, wenn Sie bereits einen Testfall für Ihre main () - Funktion in Ihren Tests haben.

Der Grund, warum ich mich dafür entscheide, einen neuen Testfall für das gesamte Skript auszuschließen, anstatt ihn zu schreiben, liegt main()darin, dass Sie, wie bereits erwähnt, bereits einen Testfall für Ihre Funktion haben, weil Sie einen anderen Testfall für das Skript hinzufügen (nur um einen zu haben) 100% Deckung) wird nur eine doppelte sein.

Um das auszuschließen if __name__ == '__main__', können Sie eine Coverage-Konfigurationsdatei schreiben und im Abschnittsbericht hinzufügen:

[report]

exclude_lines =
    if __name__ == .__main__.:

Weitere Informationen zur Coverage-Konfigurationsdatei finden Sie hier .

Hoffe das kann helfen.

Sie können dies mit dem impModul und nicht mit der importAnweisung tun . Das Problem mit der importAnweisung besteht darin, dass der Test für '__main__'als Teil der Importanweisung ausgeführt wird, bevor Sie die Möglichkeit erhalten, ihn zuzuweisen runpy.__name__.

Zum Beispiel könnten Sie imp.load_source()so verwenden:

import imp
runpy = imp.load_source('__main__', '/path/to/runpy.py')

Der erste Parameter wird dem __name__importierten Modul zugewiesen .

Whoa, ich bin ein bisschen zu spät zur Party, aber ich bin kürzlich auf dieses Problem gestoßen und ich denke, ich habe eine bessere Lösung gefunden, also hier ist es ...

Ich habe an einem Modul gearbeitet, das ungefähr ein Dutzend Skripte enthielt, die alle mit genau dieser Copypasta endeten:

if __name__ == '__main__':
    if '--help' in sys.argv or '-h' in sys.argv:
        print(__doc__)
    else:
        sys.exit(main())

Sicher nicht schrecklich, aber auch nicht testbar. Meine Lösung bestand darin, eine neue Funktion in eines meiner Module zu schreiben:

def run_script(name, doc, main):
    """Act like a script if we were invoked like a script."""
    if name == '__main__':
        if '--help' in sys.argv or '-h' in sys.argv:
            sys.stdout.write(doc)
        else:
            sys.exit(main())

und platzieren Sie dieses Juwel am Ende jeder Skriptdatei:

run_script(__name__, __doc__, main)

Technisch gesehen wird diese Funktion bedingungslos ausgeführt, unabhängig davon, ob Ihr Skript als Modul importiert oder als Skript ausgeführt wurde. Dies ist jedoch in Ordnung, da die Funktion nur dann etwas tut , wenn das Skript als Skript ausgeführt wird. Die Codeabdeckung sieht also, dass die Funktion ausgeführt wird und sagt "Ja, 100% Codeabdeckung!" In der Zwischenzeit habe ich drei Tests geschrieben, um die Funktion selbst abzudecken:

@patch('mymodule.utils.sys')
def test_run_script_as_import(self, sysMock):
    """The run_script() func is a NOP when name != __main__."""
    mainMock = Mock()
    sysMock.argv = []
    run_script('some_module', 'docdocdoc', mainMock)
    self.assertEqual(mainMock.mock_calls, [])
    self.assertEqual(sysMock.exit.mock_calls, [])
    self.assertEqual(sysMock.stdout.write.mock_calls, [])

@patch('mymodule.utils.sys')
def test_run_script_as_script(self, sysMock):
    """Invoke main() when run as a script."""
    mainMock = Mock()
    sysMock.argv = []
    run_script('__main__', 'docdocdoc', mainMock)
    mainMock.assert_called_once_with()
    sysMock.exit.assert_called_once_with(mainMock())
    self.assertEqual(sysMock.stdout.write.mock_calls, [])

@patch('mymodule.utils.sys')
def test_run_script_with_help(self, sysMock):
    """Print help when the user asks for help."""
    mainMock = Mock()
    for h in ('-h', '--help'):
        sysMock.argv = [h]
        run_script('__main__', h*5, mainMock)
        self.assertEqual(mainMock.mock_calls, [])
        self.assertEqual(sysMock.exit.mock_calls, [])
        sysMock.stdout.write.assert_called_with(h*5)

Schuld! Jetzt können main()Sie ein Testobjekt schreiben , es als Skript aufrufen, eine 100% ige Testabdeckung haben und müssen keinen Code in Ihrem Abdeckungsbericht ignorieren.

Ein Ansatz besteht darin, die Module als Skripte (z. B. os.system (...)) auszuführen und ihre stdout- und stderr-Ausgabe mit den erwarteten Werten zu vergleichen.

Python 3-Lösung:

import os
from importlib.machinery import SourceFileLoader
from importlib.util import spec_from_loader, module_from_spec
from importlib import reload
from unittest import TestCase
from unittest.mock import MagicMock, patch
    

class TestIfNameEqMain(TestCase):
    def test_name_eq_main(self):
        loader = SourceFileLoader('__main__',
                                  os.path.join(os.path.dirname(os.path.dirname(__file__)),
                                               '__main__.py'))
        with self.assertRaises(SystemExit) as e:
            loader.exec_module(module_from_spec(spec_from_loader(loader.name, loader)))

Verwenden Sie die alternative Lösung zum Definieren Ihrer eigenen kleinen Funktion:

# module.py
def main():
    if __name__ == '__main__':
        return 'sweet'
    return 'child of mine'

Sie können testen mit:

# Override the `__name__` value in your module to '__main__'
with patch('module_name.__name__', '__main__'):
    import module_name
    self.assertEqual(module_name.main(), 'sweet')

with patch('module_name.__name__', 'anything else'):
    reload(module_name)
    del module_name
    import module_name
    self.assertEqual(module_name.main(), 'child of mine')

Meine Lösung besteht darin imp.load_source(), eine Ausnahme zu verwenden und zu erzwingen, dass sie frühzeitig main()ausgelöst wird, indem kein erforderliches CLI-Argument angegeben wird, ein fehlerhaftes Argument angegeben wird, Pfade so festgelegt werden, dass eine erforderliche Datei nicht gefunden wird usw.

import imp    
import os
import sys

def mainCond(testObj, srcFilePath, expectedExcType=SystemExit, cliArgsStr=''):
    sys.argv = [os.path.basename(srcFilePath)] + (
        [] if len(cliArgsStr) == 0 else cliArgsStr.split(' '))
    testObj.assertRaises(expectedExcType, imp.load_source, '__main__', srcFilePath)

Dann können Sie in Ihrer Testklasse diese Funktion folgendermaßen verwenden:

def testMain(self):
    mainCond(self, 'path/to/main.py', cliArgsStr='-d FailingArg')

Ich fand diese Lösung hilfreich. Funktioniert gut, wenn Sie eine Funktion verwenden, um Ihren gesamten Skriptcode zu behalten. Der Code wird als eine Codezeile behandelt. Es spielt keine Rolle, ob die gesamte Zeile für den Abdeckungszähler ausgeführt wurde (obwohl dies bei einer 100% igen Abdeckung eigentlich nicht zu erwarten ist). Der Trick wird auch als Pylint akzeptiert. ;-);

if __name__ == '__main__': \
    main()