Πώς μπορείτε να δημιουργήσετε δυναμικές (παραμετροποιημένη) δοκιμές μονάδα στην πύθωνα;

ψήφοι
154

Έχω κάποια δεδομένα δοκιμών και θέλετε να δημιουργήσετε μια δοκιμή μονάδα για κάθε στοιχείο. Η πρώτη μου ιδέα ήταν να το κάνουμε κάπως έτσι:

import unittest

l = [[foo, a, a,], [bar, a, b], [lee, b, b]]

class TestSequence(unittest.TestCase):
    def testsample(self):
        for name, a,b in l:
            print test, name
            self.assertEqual(a,b)

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

Το μειονέκτημα αυτού είναι ότι χειρίζεται όλα τα δεδομένα σε ένα τεστ. Θα ήθελα να δημιουργήσει ένα τεστ για κάθε στοιχείο σχετικά με τη μύγα. Οποιεσδήποτε προτάσεις?

Δημοσιεύθηκε 28/08/2008 στις 16:49
πηγή χρήστη
Σε άλλες γλώσσες...                            


24 απαντήσεις

ψήφοι
114

μπορώ να χρησιμοποιήσω κάτι σαν αυτό:

import unittest

l = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]

class TestSequense(unittest.TestCase):
    pass

def test_generator(a, b):
    def test(self):
        self.assertEqual(a,b)
    return test

if __name__ == '__main__':
    for t in l:
        test_name = 'test_%s' % t[0]
        test = test_generator(t[1], t[2])
        setattr(TestSequense, test_name, test)
    unittest.main()

Το nose-parameterizedπακέτο μπορεί να χρησιμοποιηθεί για να αυτοματοποιήσει τη διαδικασία αυτή:

from nose_parameterized import parameterized

class TestSequence(unittest.TestCase):
    @parameterized.expand([
        ["foo", "a", "a",],
        ["bar", "a", "b"],
        ["lee", "b", "b"],
    ])
    def test_sequence(self, name, a, b):
        self.assertEqual(a,b)

Ποια θα δημιουργήσει τις δοκιμές:

test_sequence_0_foo (__main__.TestSequence) ... ok
test_sequence_1_bar (__main__.TestSequence) ... FAIL
test_sequence_2_lee (__main__.TestSequence) ... ok

======================================================================
FAIL: test_sequence_1_bar (__main__.TestSequence)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/usr/local/lib/python2.7/site-packages/nose_parameterized/parameterized.py", line 233, in <lambda>
    standalone_func = lambda *a: func(*(a + p.args), **p.kwargs)
  File "x.py", line 12, in test_sequence
    self.assertEqual(a,b)
AssertionError: 'a' != 'b'
Απαντήθηκε 28/08/2008 στις 17:02
πηγή χρήστη

ψήφοι
66

Η μύτη πλαίσιο ελέγχου υποστηρίζει αυτό .

Παράδειγμα (ο παρακάτω κώδικας είναι τα πλήρη περιεχόμενα του αρχείου που περιέχει τη δοκιμή):

param_list = [('a', 'a'), ('a', 'b'), ('b', 'b')]

def test_generator():
    for params in param_list:
        yield check_em, params[0], params[1]

def check_em(a, b):
    assert a == b

Η έξοδος της εντολής nosetests:

> nosetests -v
testgen.test_generator('a', 'a') ... ok
testgen.test_generator('a', 'b') ... FAIL
testgen.test_generator('b', 'b') ... ok

======================================================================
FAIL: testgen.test_generator('a', 'b')
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/usr/lib/python2.5/site-packages/nose-0.10.1-py2.5.egg/nose/case.py", line 203, in runTest
    self.test(*self.arg)
  File "testgen.py", line 7, in check_em
    assert a == b
AssertionError

----------------------------------------------------------------------
Ran 3 tests in 0.006s

FAILED (failures=1)

UPDATE - unittest υποστήριξη από το 3.4:

Από Python 3.4, η πρότυπη βιβλιοθήκη unittestπακέτο έχει το subTestδιευθυντή πλαίσιο, που επιτρέπει παρόμοια λειτουργικότητα με τη χρήση unittestμόνο.

Δείτε την τεκμηρίωση:

Παράδειγμα:

from unittest import TestCase

param_list = [('a', 'a'), ('a', 'b'), ('b', 'b')]

class TestDemonstrateSubtest(TestCase):
    def test_works_as_expected(self):
        for p1, p2 in param_list:
            with self.subTest():
                self.assertEqual(p1, p2)

Μπορείτε επίσης να καθορίσετε ένα προσαρμοσμένο μήνυμα και τιμές παραμέτρων για subTest():

with self.subTest(msg="Checking if p1 equals p2", p1=p1, p2=p2):
Απαντήθηκε 29/08/2008 στις 06:10
πηγή χρήστη

ψήφοι
6

Θα επωφεληθούν από την προσπάθεια της TestScenarios βιβλιοθήκη.

testscenarios προσφέρει καθαρά ένεση εξάρτηση για τις δοκιμές τύπου πύθωνα unittest. Αυτό μπορεί να χρησιμοποιηθεί για τη δοκιμή διεπαφή (δοκιμή πολλές υλοποιήσεις μέσω ενός μοναδικού σύνολο δοκιμών) ή για το κλασικό ένεση εξάρτηση (Παρέχουμε ελέγχους με εξαρτήσεις εξωτερικά στον ίδιο τον κώδικα δοκιμής, επιτρέποντας την εύκολη δοκιμή σε διαφορετικές καταστάσεις).

Απαντήθηκε 01/05/2009 στις 02:59
πηγή χρήστη

ψήφοι
53

Αυτό μπορεί να λυθεί κομψά χρησιμοποιώντας μετακλάσεις:

import unittest

l = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]

class TestSequenceMeta(type):
    def __new__(mcs, name, bases, dict):

        def gen_test(a, b):
            def test(self):
                self.assertEqual(a, b)
            return test

        for tname, a, b in l:
            test_name = "test_%s" % tname
            dict[test_name] = gen_test(a,b)
        return type.__new__(mcs, name, bases, dict)

class TestSequence(unittest.TestCase):
    __metaclass__ = TestSequenceMeta

if __name__ == '__main__':
    unittest.main()
Απαντήθηκε 01/01/2014 στις 14:52
πηγή χρήστη

ψήφοι
27

load_tests είναι ένα μικρό γνωστό μηχανισμό εισήχθη το 2,7 για να δημιουργήσει δυναμικά μια TestSuite. Με αυτό, μπορείτε εύκολα να δημιουργήσετε παραμετρική δοκιμές.

Για παράδειγμα:

import unittest

class GeneralTestCase(unittest.TestCase):
    def __init__(self, methodName, param1=None, param2=None):
        super(GeneralTestCase, self).__init__(methodName)

        self.param1 = param1
        self.param2 = param2

    def runTest(self):
        pass  # Test that depends on param 1 and 2.


def load_tests(loader, tests, pattern):
    test_cases = unittest.TestSuite()
    for p1, p2 in [(1, 2), (3, 4)]:
        test_cases.addTest(GeneralTestCase('runTest', p1, p2))
    return test_cases

Ο κώδικας θα τρέξει όλες τις σεναρίων ελέγχου στο TestSuite επέστρεψε από load_tests. Δεν άλλες δοκιμές εκτελούνται αυτόματα από το μηχανισμό ανακάλυψης.

Εναλλακτικά, μπορείτε επίσης να χρησιμοποιήσετε κληρονομιά, όπως φαίνεται σε αυτό το εισιτήριο: http://bugs.python.org/msg151444

Απαντήθηκε 07/05/2014 στις 02:55
πηγή χρήστη

ψήφοι
24

Αυτό μπορεί να γίνει με τη χρήση pytest . Απλά γράψτε το αρχείο test_me.pyμε περιεχόμενο:

import pytest

@pytest.mark.parametrize('name, left, right', [['foo', 'a', 'a'],
                                               ['bar', 'a', 'b'],
                                               ['baz', 'b', 'b']])
def test_me(name, left, right):
    assert left == right, name

Και τρέχει το τεστ με την εντολή py.test --tb=short test_me.py. Στη συνέχεια, η έξοδος θα είναι μοιάζει με:

=========================== test session starts ============================
platform darwin -- Python 2.7.6 -- py-1.4.23 -- pytest-2.6.1
collected 3 items

test_me.py .F.

================================= FAILURES =================================
_____________________________ test_me[bar-a-b] _____________________________
test_me.py:8: in test_me
    assert left == right, name
E   AssertionError: bar
==================== 1 failed, 2 passed in 0.01 seconds ====================

Είναι απλό !. Επίσης pytest έχει περισσότερες δυνατότητες, όπως fixtures, mark, assert, κλπ ...

Απαντήθηκε 02/09/2014 στις 14:08
πηγή χρήστη

ψήφοι
4

Μπορείτε να χρησιμοποιήσετε τη μύτη-ittr plugin ( pip install nose-ittr).

Είναι πολύ εύκολο να ενσωματωθεί με τις υπάρχουσες εξετάσεις, οι ελάχιστες αλλαγές (αν υπάρχουν) που απαιτείται. Υποστηρίζει, επίσης, τη μύτη plugin πολυεπεξεργασία.

Δεν είναι ότι μπορείτε να έχετε μια προσαρμόσετε setupτη λειτουργία ανά δοκιμή.

@ittr(number=[1, 2, 3, 4])   
def test_even(self):   
    assert_equal(self.number % 2, 0)

Είναι επίσης δυνατό να περάσει nosetestπαραμέτρους όπως με εντοιχισμένες plugin τους attrib, αυτό τον τρόπο μπορείτε να εκτελέσετε μόνο ένα ειδικό τεστ με ειδική παράμετρο:

nosetest -a number=2
Απαντήθηκε 02/12/2014 στις 11:39
πηγή χρήστη

ψήφοι
2

Ήρθα σε ParamUnittest τις προάλλες, όταν πρόκειται για τον πηγαίο κώδικα για το ραδόνιο ( π.χ. χρήση στο repo GitHub ). Θα πρέπει να συνεργαστεί με άλλα πλαίσια που εκτείνονται TestCase (όπως μύτη).

Εδώ είναι ένα παράδειγμα:

import unittest
import paramunittest


@paramunittest.parametrized(
    ('1', '2'),
    #(4, 3),    <---- uncomment to have a failing test
    ('2', '3'),
    (('4', ), {'b': '5'}),
    ((), {'a': 5, 'b': 6}),
    {'a': 5, 'b': 6},
)
class TestBar(TestCase):
    def setParameters(self, a, b):
        self.a = a
        self.b = b

    def testLess(self):
        self.assertLess(self.a, self.b)
Απαντήθηκε 05/03/2015 στις 23:21
πηγή χρήστη

ψήφοι
37

Από Python έχουν 3.4 subtests εισαχθεί σε unittest για το σκοπό αυτό. Δείτε την τεκμηρίωση για λεπτομέρειες. TestCase.subTest είναι ένας διαχειριστής πλαίσιο που επιτρέπει την απομόνωση ισχυρίζεται σε μια δοκιμή, έτσι ώστε μια αποτυχία θα αναφερθεί με πληροφορίες παράμετρο, αλλά δεν σταματά την εκτέλεση της δοκιμής. Εδώ είναι το παράδειγμα από τα έγγραφα:

class NumbersTest(unittest.TestCase):

def test_even(self):
    """
    Test that numbers between 0 and 5 are all even.
    """
    for i in range(0, 6):
        with self.subTest(i=i):
            self.assertEqual(i % 2, 0)

Η έξοδος μιας δοκιμαστικής λειτουργίας θα είναι:

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=1)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=3)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=5)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

Αυτό είναι επίσης μέρος της unittest2 , έτσι ώστε να είναι διαθέσιμο για παλαιότερες εκδόσεις του Python.

Απαντήθηκε 01/04/2015 στις 05:46
πηγή χρήστη

ψήφοι
8

Χρησιμοποιήστε το DDT βιβλιοθήκη. Προσθέτει απλό διακοσμητές για τις μεθόδους δοκιμών:

import unittest
from ddt import ddt, data
from mycode import larger_than_two

@ddt
class FooTestCase(unittest.TestCase):

    @data(3, 4, 12, 23)
    def test_larger_than_two(self, value):
        self.assertTrue(larger_than_two(value))

    @data(1, -3, 2, 0)
    def test_not_larger_than_two(self, value):
        self.assertFalse(larger_than_two(value))

Αυτή η βιβλιοθήκη μπορεί να εγκατασταθεί με pip. Δεν απαιτεί nose, και συνεργάζεται άριστα με την πρότυπη βιβλιοθήκη unittestτης μονάδας.

Απαντήθηκε 21/04/2015 στις 07:24
πηγή χρήστη

ψήφοι
1

Απλά χρησιμοποιήστε μετακλάσεις, όπως φαίνεται εδώ?

class DocTestMeta(type):
    """
    Test functions are generated in metaclass due to the way some
    test loaders work. For example, setupClass() won't get called
    unless there are other existing test methods, and will also
    prevent unit test loader logic being called before the test
    methods have been defined.
    """
    def __init__(self, name, bases, attrs):
        super(DocTestMeta, self).__init__(name, bases, attrs)

    def __new__(cls, name, bases, attrs):
        def func(self):
            """Inner test method goes here"""
            self.assertTrue(1)

        func.__name__ = 'test_sample'
        attrs[func.__name__] = func
        return super(DocTestMeta, cls).__new__(cls, name, bases, attrs)

class ExampleTestCase(TestCase):
    """Our example test case, with no methods defined"""
    __metaclass__ = DocTestMeta

Παραγωγή:

test_sample (ExampleTestCase) ... OK
Απαντήθηκε 10/05/2015 στις 10:43
πηγή χρήστη

ψήφοι
2

Χρησιμοποιώ μετακλάσεις και διακοσμητές για να δημιουργήσει τεστ. Μπορείτε να ελέγχει την εκτέλεσή μου python_wrap_cases . Αυτή η βιβλιοθήκη δεν απαιτεί πλαίσια δοκιμών.

το παράδειγμά σας:

import unittest
from python_wrap_cases import wrap_case


@wrap_case
class TestSequence(unittest.TestCase):

    @wrap_case("foo", "a", "a")
    @wrap_case("bar", "a", "b")
    @wrap_case("lee", "b", "b")
    def testsample(self, name, a, b):
        print "test", name
        self.assertEqual(a, b)

έξοδο της κονσόλας:

testsample_u'bar'_u'a'_u'b' (tests.example.test_stackoverflow.TestSequence) ... test bar
FAIL
testsample_u'foo'_u'a'_u'a' (tests.example.test_stackoverflow.TestSequence) ... test foo
ok
testsample_u'lee'_u'b'_u'b' (tests.example.test_stackoverflow.TestSequence) ... test lee
ok

Επίσης μπορείτε να χρησιμοποιήσετε τις γεννήτριες . Για παράδειγμα, ο κώδικας αυτός παράγει όλους τους πιθανούς συνδυασμούς των δοκιμών με επιχειρήματα a__listκαιb__list

import unittest
from python_wrap_cases import wrap_case


@wrap_case
class TestSequence(unittest.TestCase):

    @wrap_case(a__list=["a", "b"], b__list=["a", "b"])
    def testsample(self, a, b):
        self.assertEqual(a, b)

έξοδο της κονσόλας:

testsample_a(u'a')_b(u'a') (tests.example.test_stackoverflow.TestSequence) ... ok
testsample_a(u'a')_b(u'b') (tests.example.test_stackoverflow.TestSequence) ... FAIL
testsample_a(u'b')_b(u'a') (tests.example.test_stackoverflow.TestSequence) ... FAIL
testsample_a(u'b')_b(u'b') (tests.example.test_stackoverflow.TestSequence) ... ok
Απαντήθηκε 01/07/2015 στις 11:28
πηγή χρήστη

ψήφοι
4

Υπάρχει, επίσης, υπόθεση η οποία προσθέτει δοκιμή χνούδι ή ακινήτων με βάση: https://pypi.python.org/pypi/hypothesis

Αυτή είναι μια πολύ ισχυρή μέθοδος δοκιμής.

Απαντήθηκε 24/11/2015 στις 00:00
πηγή χρήστη

ψήφοι
1

Μπορείτε να χρησιμοποιήσετε TestSuiteκαι προσαρμοσμένες TestCaseκατηγορίες.

import unittest

class CustomTest(unittest.TestCase):
    def __init__(self, name, a, b):
        super().__init__()
        self.name = name
        self.a = a
        self.b = b

    def runTest(self):
        print("test", self.name)
        self.assertEqual(self.a, self.b)

if __name__ == '__main__':
    suite = unittest.TestSuite()
    suite.addTest(CustomTest("Foo", 1337, 1337))
    suite.addTest(CustomTest("Bar", 0xDEAD, 0xC0DE))
    unittest.TextTestRunner().run(suite)
Απαντήθηκε 20/12/2015 στις 13:41
πηγή χρήστη

ψήφοι
0

Είχα πρόβλημα με ένα πολύ συγκεκριμένο στυλ της παραμετροποιημένη δοκιμές. Όλες οι δοκιμές Σελήνιο μας μπορεί να τρέξει σε τοπικό επίπεδο, αλλά επίσης θα πρέπει να είναι σε θέση να τρέξει από απόσταση εναντίον διάφορες πλατφόρμες για SauceLabs. Βασικά, ήθελα να πάρει ένα μεγάλο ποσό των ήδη γράψει περιπτώσεις δοκιμών και παραμετροποίηση τους με τις λιγότερες αλλαγές στον κώδικα δυνατόν. Επιπλέον, έπρεπε να είμαι σε θέση να περάσει τις παραμέτρους στη μέθοδο ρύθμισης, κάτι που δεν έχω δει καμία λύσεις για αλλού.

Εδώ είναι αυτό που έχω καταλήξει:

import inspect
import types

test_platforms = [
    {'browserName': "internet explorer", 'platform': "Windows 7", 'version': "10.0"},
    {'browserName': "internet explorer", 'platform': "Windows 7", 'version': "11.0"},
    {'browserName': "firefox", 'platform': "Linux", 'version': "43.0"},
]


def sauce_labs():
    def wrapper(cls):
        return test_on_platforms(cls)
    return wrapper


def test_on_platforms(base_class):
    for name, function in inspect.getmembers(base_class, inspect.isfunction):
        if name.startswith('test_'):
            for platform in test_platforms:
                new_name = '_'.join(list([name, ''.join(platform['browserName'].title().split()), platform['version']]))
                new_function = types.FunctionType(function.__code__, function.__globals__, new_name,
                                                  function.__defaults__, function.__closure__)
                setattr(new_function, 'platform', platform)
                setattr(base_class, new_name, new_function)
            delattr(base_class, name)

    return base_class

Με αυτό, το μόνο που είχα να κάνω ήταν να προσθέσετε ένα απλό @sauce_labs διακοσμητή () σε κάθε τακτική παλιά TestCase, και τώρα κατά την εκτέλεση τους, από όπου και αν τυλιγμένη και ξαναγραφεί, έτσι ώστε όλες οι μέθοδοι δοκιμών είναι παραμετροποιημένο και μετονομάστηκε. LoginTests.test_login (αυτο) λειτουργεί ως LoginTests.test_login_internet_explorer_10.0 (αυτο), LoginTests.test_login_internet_explorer_11.0 (αυτο) και LoginTests.test_login_firefox_43.0 (αυτο), και το καθένα έχει τη self.platform παράμετρο για να αποφασίσει ποιο πρόγραμμα περιήγησης / πλατφόρμα για να τρέξει κατά, ακόμη και σε LoginTests.setUp, η οποία είναι ζωτικής σημασίας για το έργο μου, δεδομένου ότι αυτό είναι όπου η σύνδεση με SauceLabs έχει προετοιμαστεί.

Τέλος πάντων, ελπίζω ότι αυτό θα μπορούσε να βοηθήσει σε κάποιον που θέλει να κάνει μια παρόμοια «παγκόσμια» παραμετροποίηση των δοκιμών τους!

Απαντήθηκε 22/04/2016 στις 07:02
πηγή χρήστη

ψήφοι
-1

Εκτός από τη χρήση SetAttr, μπορούμε να χρησιμοποιήσουμε load_tests από την python 3.2. Ανατρέξτε στο blog μετά blog.livreuro.com/en/coding/python/how-to-generate-discoverable-unit-tests-in-python-dynamically/

class Test(unittest.TestCase):
    pass

def _test(self, file_name):
    open(file_name, 'r') as f:
        self.assertEqual('test result',f.read())

def _generate_test(file_name):
    def test(self):
        _test(self, file_name)
    return test

def _generate_tests():
    for file in files:
        file_name = os.path.splitext(os.path.basename(file))[0]
        setattr(Test, 'test_%s' % file_name, _generate_test(file))

test_cases = (Test,)

def load_tests(loader, tests, pattern):
    _generate_tests()
    suite = TestSuite()
    for test_class in test_cases:
        tests = loader.loadTestsFromTestCase(test_class)
        suite.addTests(tests)
    return suite

if __name__ == '__main__':
    _generate_tests()
    unittest.main()
Απαντήθηκε 26/05/2016 στις 19:20
πηγή χρήστη

ψήφοι
-1

Μετά είναι η λύση μου. Θεωρώ ότι αυτό είναι χρήσιμο όταν: 1. Πρέπει να εργαστούμε για unittest.Testcase και unittest ανακαλύψετε 2. Έχετε μια σειρά δοκιμών για να τρέξει για διαφορετικές ρυθμίσεις παραμέτρων. 3. Πολύ απλά δεν υπάρχει η εξάρτηση από άλλα πακέτα εισαγωγή unittest

    class BaseClass(unittest.TestCase):
        def setUp(self):
            self.param = 2
            self.base = 2

        def test_me(self):
            self.assertGreaterEqual(5, self.param+self.base)

        def test_me_too(self):
            self.assertLessEqual(3, self.param+self.base)



     class Child_One(BaseClass):
        def setUp(self):
            BaseClass.setUp(self)
            self.param = 4


     class Child_Two(BaseClass):
        def setUp(self):
            BaseClass.setUp(self)
            self.param = 1
Απαντήθηκε 02/08/2016 στις 15:35
πηγή χρήστη

ψήφοι
0

Η λύση αυτή λειτουργεί με unittestκαι nose:

#!/usr/bin/env python
import unittest

def make_function(description, a, b):
    def ghost(self):
        self.assertEqual(a, b, description)
    print description
    ghost.__name__ = 'test_{0}'.format(description)
    return ghost


class TestsContainer(unittest.TestCase):
    pass

testsmap = {
    'foo': [1, 1],
    'bar': [1, 2],
    'baz': [5, 5]}

def generator():
    for name, params in testsmap.iteritems():
        test_func = make_function(name, params[0], params[1])
        setattr(TestsContainer, 'test_{0}'.format(name), test_func)

generator()

if __name__ == '__main__':
    unittest.main()
Απαντήθηκε 06/09/2016 στις 12:57
πηγή χρήστη

ψήφοι
1
import unittest

def generator(test_class, a, b):
    def test(self):
        self.assertEqual(a, b)
    return test

def add_test_methods(test_class):
    #First element of list is variable "a", then variable "b", then name of test case that will be used as suffix.
    test_list = [[2,3, 'one'], [5,5, 'two'], [0,0, 'three']]
    for case in test_list:
        test = generator(test_class, case[0], case[1])
        setattr(test_class, "test_%s" % case[2], test)


class TestAuto(unittest.TestCase):
    def setUp(self):
        print 'Setup'
        pass

    def tearDown(self):
        print 'TearDown'
        pass

_add_test_methods(TestAuto)  # It's better to start with underscore so it is not detected as a test itself

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

ΑΠΟΤΕΛΕΣΜΑ:

>>> 
Setup
FTearDown
Setup
TearDown
.Setup
TearDown
.
======================================================================
FAIL: test_one (__main__.TestAuto)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "D:/inchowar/Desktop/PyTrash/test_auto_3.py", line 5, in test
    self.assertEqual(a, b)
AssertionError: 2 != 3

----------------------------------------------------------------------
Ran 3 tests in 0.019s

FAILED (failures=1)
Απαντήθηκε 07/12/2016 στις 04:10
πηγή χρήστη

ψήφοι
0

Οι απαντήσεις μετακλάση με βάση εξακολουθούν να εργάζονται στην python3, αλλά αντ 'αυτού του __metaclass__χαρακτηριστικού πρέπει κανείς να χρησιμοποιήσει την metaclassπαράμετρο, όπως σε:

class ExampleTestCase(TestCase,metaclass=DocTestMeta):
    pass
Απαντήθηκε 08/05/2017 στις 14:25
πηγή χρήστη

ψήφοι
0

Meta-προγραμματισμός είναι διασκέδαση, αλλά μπορεί να πάρει στο δρόμο. Οι περισσότερες λύσεις εδώ καθιστούν δύσκολη την:

  • ξεκινήσει επιλεκτικά μια δοκιμή
  • σημείο πίσω από το όνομα του τεστ κώδικα που δίνεται για

Έτσι, η πρώτη μου πρόταση είναι να ακολουθήσετε τις απλές / ρητή διαδρομή (λειτουργεί με οποιαδήποτε δοκιμή δρομέας):

import unittest

class TestSequence(unittest.TestCase):

    def _test_complex_property(self, a, b):
        self.assertEqual(a,b)

    def test_foo(self):
        self._test_complex_property("a", "a")
    def test_bar(self):
        self._test_complex_property("a", "b")
    def test_lee(self):
        self._test_complex_property("b", "b")

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

Από τη στιγμή που δεν πρέπει να επαναλάβουμε τους εαυτούς μας, δεύτερη πρότασή μου βασίζεται στην @ απάντηση Javier είναι: αγκαλιάσει το ξενοδοχείο με βάση τις δοκιμές. Βιβλιοθήκη Υπόθεση:

  • είναι «πιο αμείλικτα ύπουλη για δοκιμή γενιάς περίπτωση από εμάς απλό άνθρωπο»
  • θα παρέχει απλή καταμέτρηση-παραδείγματα
  • Λειτουργεί με οποιοδήποτε τεστ δρομέα
  • έχει πολλά ακόμα ενδιαφέροντα χαρακτηριστικά (στατιστικά στοιχεία, επιπλέον παραγωγή δοκιμής, ...)

    class TestSequence (unittest.TestCase):

    @given(st.text(), st.text())
    def test_complex_property(self, a, b):
        self.assertEqual(a,b)
    

Για να ελέγξετε συγκεκριμένα παραδείγματα σας, απλά προσθέστε:

    @example("a", "a")
    @example("a", "b")
    @example("b", "b")

Για να εκτελέσετε μόνο ένα συγκεκριμένο παράδειγμα, μπορείτε να σχολιάσετε τα άλλα παραδείγματα (με την προϋπόθεση παράδειγμα θα τρέξει πρώτα). Μπορεί να θέλετε να χρησιμοποιήσετε @given(st.nothing()). Μια άλλη επιλογή είναι να αντικαταστήσει το σύνολο του συγκροτήματος από:

    @given(st.just("a"), st.just("b"))

Εντάξει, δεν χρειάζεται ξεχωριστή ονόματα δοκιμή. Αλλά ίσως το μόνο που χρειάζεται:

  • ένα περιγραφικό όνομα της ιδιότητας υπό δοκιμή.
  • η οποία είσοδος οδηγεί σε αποτυχία (παραποίηση παράδειγμα).

πιο αστείο παράδειγμα

Απαντήθηκε 08/08/2017 στις 12:59
πηγή χρήστη

ψήφοι
0

Σούπερ αργά για το κόμμα, αλλά είχα πρόβλημα να κάνει αυτές τις εργασίες setUpClass.

Εδώ είναι μια έκδοση του @ απάντηση Javier είναι που δίνει setUpClassπρόσβαση σε δυναμικά διατίθενται ιδιότητες.

import unittest


class GeneralTestCase(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print ''
        print cls.p1
        print cls.p2

    def runTest1(self):
        self.assertTrue((self.p2 - self.p1) == 1)

    def runTest2(self):
        self.assertFalse((self.p2 - self.p1) == 2)


def load_tests(loader, tests, pattern):
    test_cases = unittest.TestSuite()
    for p1, p2 in [(1, 2), (3, 4)]:
        clsname = 'TestCase_{}_{}'.format(p1, p2)
        dct = {
            'p1': p1,
            'p2': p2,
        }
        cls = type(clsname, (GeneralTestCase,), dct)
        test_cases.addTest(cls('runTest1'))
        test_cases.addTest(cls('runTest2'))
    return test_cases

έξοδοι

1
2
..
3
4
..
----------------------------------------------------------------------
Ran 4 tests in 0.000s

OK
Απαντήθηκε 25/01/2018 στις 19:24
πηγή χρήστη

ψήφοι
0

Έχω διαπιστώσει ότι αυτό λειτουργεί καλά για τους σκοπούς μου, ειδικά αν χρειαστεί να δημιουργήσει τεστ που κάνουν ελαφρά διαδικασίες διαφορά σε μια συλλογή των δεδομένων.

import unittest

def rename(newName):
    def renamingFunc(func):
        func.__name__ == newName
        return func
    return renamingFunc

class TestGenerator(unittest.TestCase):

    TEST_DATA = {}

    @classmethod
    def generateTests(cls):
        for dataName, dataValue in TestGenerator.TEST_DATA:
            for func in cls.getTests(dataName, dataValue):
                setattr(cls, "test_{:s}_{:s}".format(func.__name__, dataName), func)

    @classmethod
    def getTests(cls):
        raise(NotImplementedError("This must be implemented"))

class TestCluster(TestGenerator):

    TEST_CASES = []

    @staticmethod
    def getTests(dataName, dataValue):

        def makeTest(case):

            @rename("{:s}".format(case["name"]))
            def test(self):
                # Do things with self, case, data
                pass

            return test

        return [makeTest(c) for c in TestCluster.TEST_CASES]

TestCluster.generateTests()

Η TestGeneratorτάξη μπορεί να χρησιμοποιηθεί για να αναπαράγονται διαφορετικά σύνολα των περιπτώσεων δοκιμής όπως TestCluster.

TestClusterμπορεί να θεωρηθεί ως εφαρμογή της TestGeneratorδιεπαφής.

Απαντήθηκε 06/08/2019 στις 16:10
πηγή χρήστη

ψήφοι
0

unittest εισαγωγής

def γεννήτρια (test_class, a, b, c, d, όνομα): def δοκιμή (self): print ( 'Testexecution =', όνομα) print ( 'a =', α) print ( 'b =', β) εκτύπωσης ( 'c =', γ) print ( 'd =', δ)

return test

def add_test_methods (test_class): test_list = [[3,3,5,6, 'ένα'], [5,5,8,9, 'δύο'], [0,0,5,6, 'τρία'] , [0,0,2,3, 'τέσσερα']] για την περίπτωση στην test_list: print ( 'υπόθεση =', περίπτωση [0], περίπτωση [1], περίπτωση [2], περίπτωση [3], περίπτωση [4 ]) δοκιμής = γεννήτρια (test_class, περίπτωση [0], περίπτωση [1], περίπτωση [2], περίπτωση [3], περίπτωση [4]) SetAttr (test_class, "test_% s" % υπόθεση [4], δοκιμή)

Κατηγορία TestAuto (unittest.TestCase): def setup (αυτο): print ( 'Setup') μπάλα

def tearDown(self):
    print ('TearDown')
    pass

add_test_methods (TestAuto)

αν το όνομα == ' κύρια ': unittest.main (πολυλογία = 1)

Απαντήθηκε 21/11/2019 στις 13:00
πηγή χρήστη

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more