Wie schreibt man Tests für den Argparse-Teil eines Python-Moduls? [geschlossen]

Ich habe ein Python-Modul, das die Argparse-Bibliothek verwendet. Wie schreibe ich Tests für diesen Abschnitt der Codebasis?

Sie sollten Ihren Code umgestalten und die Analyse in eine Funktion verschieben:

def parse_args(args):
    parser = argparse.ArgumentParser(...)
    parser.add_argument...
    # ...Create your parser as you like...
    return parser.parse_args(args)

Dann mainsollten Sie es in Ihrer Funktion einfach aufrufen mit:

parser = parse_args(sys.argv[1:])

(wobei das erste Element sys.argv, das den Skriptnamen darstellt, entfernt wird, um ihn während des CLI-Vorgangs nicht als zusätzlichen Switch zu senden.)

In Ihren Tests können Sie dann die Parser-Funktion mit einer beliebigen Liste von Argumenten aufrufen, mit denen Sie sie testen möchten:

def test_parser(self):
    parser = parse_args(['-l', '-m'])
    self.assertTrue(parser.long)
    # ...and so on.

Auf diese Weise müssen Sie niemals den Code Ihrer Anwendung ausführen, nur um den Parser zu testen.

Wenn Sie später in Ihrer Anwendung Optionen ändern und / oder Optionen zu Ihrem Parser hinzufügen müssen, erstellen Sie eine Factory-Methode:

def create_parser():
    parser = argparse.ArgumentParser(...)
    parser.add_argument...
    # ...Create your parser as you like...
    return parser

Sie können es später bearbeiten, wenn Sie möchten, und ein Test könnte folgendermaßen aussehen:

class ParserTest(unittest.TestCase):
    def setUp(self):
        self.parser = create_parser()

    def test_something(self):
        parsed = self.parser.parse_args(['--something', 'test'])
        self.assertEqual(parsed.something, 'test')

"argparse portion" ist etwas vage, daher konzentriert sich diese Antwort auf einen Teil: die parse_argsMethode. Dies ist die Methode, die mit Ihrer Befehlszeile interagiert und alle übergebenen Werte abruft. Grundsätzlich können Sie verspotten, was parse_argszurückgegeben wird, damit keine Werte über die Befehlszeile abgerufen werden müssen. Das mock Paket kann über pip für Python-Versionen 2.6-3.2 installiert werden. Es ist Teil der Standardbibliothek unittest.mockab Version 3.3.

import argparse
try:
    from unittest import mock  # python 3.3+
except ImportError:
    import mock  # python 2.6-3.2


@mock.patch('argparse.ArgumentParser.parse_args',
            return_value=argparse.Namespace(kwarg1=value, kwarg2=value))
def test_command(mock_args):
    pass

Sie müssen alle Argumente Ihrer Befehlsmethode einschließen, Namespace auch wenn sie nicht übergeben werden. Geben Sie diesen Argumenten den Wert von None. (siehe Dokumentation ) Dieser Stil ist nützlich, um schnell Tests für Fälle durchzuführen, in denen für jedes Methodenargument unterschiedliche Werte übergeben werden. Wenn Sie sich Namespacein Ihren Tests dafür entscheiden, sich selbst zu verspotten, um sich nicht auf Vertrauen zu verlassen, stellen Sie sicher, dass es sich ähnlich wie die eigentliche NamespaceKlasse verhält .

Unten sehen Sie ein Beispiel mit dem ersten Snippet aus der Argparse-Bibliothek.

# test_mock_argparse.py
import argparse
try:
    from unittest import mock  # python 3.3+
except ImportError:
    import mock  # python 2.6-3.2


def main():
    parser = argparse.ArgumentParser(description='Process some integers.')
    parser.add_argument('integers', metavar='N', type=int, nargs='+',
                        help='an integer for the accumulator')
    parser.add_argument('--sum', dest='accumulate', action='store_const',
                        const=sum, default=max,
                        help='sum the integers (default: find the max)')

    args = parser.parse_args()
    print(args)  # NOTE: this is how you would check what the kwargs are if you're unsure
    return args.accumulate(args.integers)


@mock.patch('argparse.ArgumentParser.parse_args',
            return_value=argparse.Namespace(accumulate=sum, integers=[1,2,3]))
def test_command(mock_args):
    res = main()
    assert res == 6, "1 + 2 + 3 = 6"


if __name__ == "__main__":
    print(main())

Lassen Sie Ihre main()Funktion argvals Argument nehmen, anstatt sie standardmäßig lesen zusys.argv lassen :

# mymodule.py
import argparse
import sys


def main(args):
    parser = argparse.ArgumentParser()
    parser.add_argument('-a')
    process(**vars(parser.parse_args(args)))
    return 0


def process(a=None):
    pass

if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))

Dann können Sie normal testen.

import mock

from mymodule import main


@mock.patch('mymodule.process')
def test_main(process):
    main([])
    process.assert_call_once_with(a=None)


@mock.patch('foo.process')
def test_main_a(process):
    main(['-a', '1'])
    process.assert_call_once_with(a='1')

1. Füllen Sie Ihre Arg-Liste mit sys.argv.append()und rufen Sie dann auf parse() , überprüfen Sie die Ergebnisse und wiederholen Sie den Vorgang.
2. Rufen Sie aus einer Batch- / Bash-Datei mit Ihren Flags und einem Dump-Args-Flag auf.
3. Fügen Sie alle Ihre Argumente in eine separate Datei und in die if __name__ == "__main__":Aufrufanalyse ein und sichern / bewerten Sie die Ergebnisse. Testen Sie diese dann anhand einer Batch- / Bash-Datei.

Ich wollte das ursprüngliche Serving-Skript nicht ändern, also habe ich den sys.argvTeil in Argparse nur verspottet .

from unittest.mock import patch

with patch('argparse._sys.argv', ['python', 'serve.py']):
    ...  # your test code here

Dies bricht ab, wenn sich die Implementierung von argparse ändert, aber genug für ein schnelles Testskript. Sensibilität ist sowieso viel wichtiger als Spezifität in Testskripten.

Eine einfache Möglichkeit zum Testen eines Parsers ist:

parser = ...
parser.add_argument('-a',type=int)
...
argv = '-a 1 foo'.split()  # or ['-a','1','foo']
args = parser.parse_args(argv)
assert(args.a == 1)
...

Eine andere Möglichkeit besteht darin, Änderungen vorzunehmen sys.argvund aufzurufenargs = parser.parse_args()

Es gibt viele Beispiele für Tests argparseinlib/test/test_argparse.py

parse_argswirft ein SystemExitund druckt auf stderr, Sie können beide fangen:

import contextlib
import io
import sys

@contextlib.contextmanager
def captured_output():
    new_out, new_err = io.StringIO(), io.StringIO()
    old_out, old_err = sys.stdout, sys.stderr
    try:
        sys.stdout, sys.stderr = new_out, new_err
        yield sys.stdout, sys.stderr
    finally:
        sys.stdout, sys.stderr = old_out, old_err

def validate_args(args):
    with captured_output() as (out, err):
        try:
            parser.parse_args(args)
            return True
        except SystemExit as e:
            return False

Sie inspizieren stderr (mit, err.seek(0); err.read()aber im Allgemeinen ist keine Granularität erforderlich.

Jetzt können Sie beliebige assertTrueTests verwenden oder verwenden:

assertTrue(validate_args(["-l", "-m"]))

Alternativ möchten Sie möglicherweise einen anderen Fehler abfangen und erneut auslösen (anstelle von SystemExit):

def validate_args(args):
    with captured_output() as (out, err):
        try:
            return parser.parse_args(args)
        except SystemExit as e:
            err.seek(0)
            raise argparse.ArgumentError(err.read())

Wenn argparse.ArgumentParser.parse_argsich Ergebnisse von an eine Funktion übergebe, verwende ich manchmal a namedtuple, um Argumente zum Testen zu verspotten.

import unittest
from collections import namedtuple
from my_module import main

class TestMyModule(TestCase):

    args_tuple = namedtuple('args', 'arg1 arg2 arg3 arg4')

    def test_arg1(self):
        args = TestMyModule.args_tuple("age > 85", None, None, None)
        res = main(args)
        assert res == ["55289-0524", "00591-3496"], 'arg1 failed'

    def test_arg2(self):
        args = TestMyModule.args_tuple(None, [42, 69], None, None)
        res = main(args)
        assert res == [], 'arg2 failed'

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

Zum Testen der CLI (Befehlszeilenschnittstelle) und nicht der Befehlsausgabe habe ich so etwas getan

import pytest
from argparse import ArgumentParser, _StoreAction

ap = ArgumentParser(prog="cli")
ap.add_argument("cmd", choices=("spam", "ham"))
ap.add_argument("-a", "--arg", type=str, nargs="?", default=None, const=None)
...

def test_parser():
    assert isinstance(ap, ArgumentParser)
    assert isinstance(ap, list)
    args = {_.dest: _ for _ in ap._actions if isinstance(_, _StoreAction)}
    
    assert args.keys() == {"cmd", "arg"}
    assert args["cmd"] == ("spam", "ham")
    assert args["arg"].type == str
    assert args["arg"].nargs == "?"
    ...