Python unittest übergeben Argumente

Wie würde ich in Python ein Argument von der Befehlszeile an eine unittest-Funktion übergeben? Hier ist der Code bis jetzt ... Ich weiß, dass er falsch ist.

class TestingClass(unittest.TestCase):

    def testEmails(self):
        assertEqual(email_from_argument, "[email protected]")


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

Also sagen die Ärzte hier: "Sie sagen, das tut weh? Dann tun Sie das nicht!" sind wahrscheinlich richtig. Aber wenn Sie wirklich wollen, gibt es eine Möglichkeit, Argumente an einen Test zu übergeben:

import sys
import unittest

class MyTest(unittest.TestCase):
    USERNAME = "jemima"
    PASSWORD = "password"

    def test_logins_or_something(self):
        print('username : {}'.format(self.USERNAME))
        print('password : {}'.format(self.PASSWORD))


if __name__ == "__main__":
    if len(sys.argv) > 1:
        MyTest.USERNAME = sys.argv.pop()
        MyTest.PASSWORD = sys.argv.pop()
    unittest.main()

das lässt dich laufen mit:

python mytests.py ausername apassword

Sie benötigen das argv.pops, damit Ihre Befehlszeilenparameter nicht mit den eigenen von unittest herumspielen ...

[Update] Das andere, was Sie vielleicht untersuchen möchten, ist die Verwendung von Umgebungsvariablen:

import os
import unittest

class MyTest(unittest.TestCase):
    USERNAME = "jemima"
    PASSWORD = "password"

    def test_logins_or_something(self):
        print('username : {}'.format(self.USERNAME))
        print('password : {}'.format(self.PASSWORD))


if __name__ == "__main__":
    MyTest.USERNAME = os.environ.get('TEST_USERNAME', MyTest.USERNAME)            
    MyTest.PASSWORD = os.environ.get('TEST_PASSWORD', MyTest.PASSWORD)
    unittest.main()

Damit können Sie laufen mit:

TEST_USERNAME=ausername TEST_PASSWORD=apassword python mytests.py

und es hat den Vorteil, dass Sie nicht mit der Analyse der eigenen Argumente von unittest herumspielen. Nachteil ist, dass es unter Windows nicht so funktioniert ...

Eine andere Methode für diejenigen, die dies trotz der richtigen Bemerkungen, die Sie nicht tun sollten, wirklich tun möchten:

import unittest

class MyTest(unittest.TestCase):

    def __init__(self, testName, extraArg):
        super(MyTest, self).__init__(testName)  # calling the super class init varies for different python versions.  This works for 2.7
        self.myExtraArg = extraArg

    def test_something(self):
        print(self.myExtraArg)

# call your test
suite = unittest.TestSuite()
suite.addTest(MyTest('test_something', extraArg))
unittest.TextTestRunner(verbosity=2).run(suite)

Auch wenn die Testgurus sagen, wir sollten es nicht tun: Ich tue es. In manchen Zusammenhängen ist es sehr sinnvoll, Parameter zu haben, um den Test in die richtige Richtung zu lenken, zum Beispiel:

• Welche der Dutzend identischen USB-Karten sollte ich jetzt für diesen Test verwenden?
• Welchen Server soll ich jetzt für diesen Test verwenden?
• Welches XXX soll ich verwenden?

Für mich ist die Verwendung der Umgebungsvariablen für diese Puprose gut genug, da Sie keinen dedizierten Code schreiben müssen, um Ihre Parameter weiterzugeben. es wird von Python unterstützt. Es ist sauber und einfach.

Natürlich befürworte ich keine vollständig parametrierbaren Tests. Aber wir müssen pragmatisch sein und wie gesagt, in manchen Zusammenhängen brauchen Sie ein oder zwei Parameter. Wir sollten nicht darüber nachdenken :)

import os
import unittest


class MyTest(unittest.TestCase):
    def setUp(self):
        self.var1 = os.environ["VAR1"]
        self.var2 = os.environ["VAR2"]

    def test_01(self):
        print("var1: {}, var2: {}".format(self.var1, self.var2))

Dann von der Kommandozeile (unter Linux getestet)

$ export VAR1=1
$ export VAR2=2
$ python -m unittest MyTest
var1: 1, var2: 2
.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK

Wenn Sie den Ansatz von steffens21 mit verwenden möchtenunittest.TestLoader , können Sie den ursprünglichen Testlader ändern (siehe unittest.py):

import unittest
from unittest import suite

class TestLoaderWithKwargs(unittest.TestLoader):
    """A test loader which allows to parse keyword arguments to the
       test case class."""
    def loadTestsFromTestCase(self, testCaseClass, **kwargs):
        """Return a suite of all tests cases contained in 
           testCaseClass."""
        if issubclass(testCaseClass, suite.TestSuite):
            raise TypeError("Test cases should not be derived from "\
                            "TestSuite. Maybe you meant to derive from"\ 
                            " TestCase?")
        testCaseNames = self.getTestCaseNames(testCaseClass)
        if not testCaseNames and hasattr(testCaseClass, 'runTest'):
            testCaseNames = ['runTest']

        # Modification here: parse keyword arguments to testCaseClass.
        test_cases = []
        for test_case_name in testCaseNames:
            test_cases.append(testCaseClass(test_case_name, **kwargs))
        loaded_suite = self.suiteClass(test_cases)

        return loaded_suite 

# call your test
loader = TestLoaderWithKwargs()
suite = loader.loadTestsFromTestCase(MyTest, extraArg=extraArg)
unittest.TextTestRunner(verbosity=2).run(suite)

Habe das gleiche Problem. Meine Lösung besteht darin, nach dem Parsen von Argumenten mit argparse oder auf andere Weise Argumente aus sys.argv zu entfernen

sys.argv = sys.argv[:1]  

Bei Bedarf können Sie unittest Argumente aus main.parseArgs () filtern.

Unit-Tests dienen zum Testen der grundlegenden Funktionen (Funktionen der untersten Ebene der Anwendung), um sicherzustellen, dass Ihre Anwendungsbausteine ordnungsgemäß funktionieren. Es gibt wahrscheinlich keine formale Definition dessen, was das genau bedeutet, aber Sie sollten andere Arten von Tests für die größere Funktionalität in Betracht ziehen - siehe Integrationstests . Das Unit-Test-Framework ist möglicherweise nicht ideal für diesen Zweck.