Nasıl Python dinamik (parametrelenmişse) birim testleri elde edebilirim?

oy
154

Ben test verilerinin çeşit ve her öğe için bir birim test oluşturmak istiyorum. Benim ilk fikir böyle yapmak oldu:

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()

bu olumsuz bir testte tüm verileri işler olmasıdır. Ben anında her madde için bir testi üretmek istiyoruz. Baska öneri?

Oluştur 28/08/2008 saat 16:49
kaynak kullanıcı
Diğer dillerde...                            


24 cevaplar

oy
114

ben böyle bir şey kullanın:

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-parameterizedPaket bu işlemi otomatik hale getirmek için kullanılabilir:

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)

testler üretecektir Hangi:

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'
Cevap 28/08/2008 saat 17:02
kaynak kullanıcı

oy
66

Burun test çerçevesi bu destekler .

Örnek (aşağıdaki kod testi içeren dosyanın, tüm içeriği olan):

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 komutunun çıktısı:

> 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)

GÜNCELLEME - 3.4 beri unittest desteği:

Python 3.4 yana, standart kütüphane unittestile paketlerin subTestbenzer işlevler kullanılarak sağlayan, içerik yöneticisi unittestsadece.

belgelere bakın:

Örnek:

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)

Ayrıca özel bir mesaj ve parametre değerlerini belirtebilirsiniz subTest():

with self.subTest(msg="Checking if p1 equals p2", p1=p1, p2=p2):
Cevap 29/08/2008 saat 06:10
kaynak kullanıcı

oy
6

Denemeye yararlanacak TestScenarios kütüphanesi.

testscenarios piton unittest tarzı testler için temiz bağımlılık enjeksiyon sağlar. Bu (farklı durumlarda kolay test edilebilmesini sağlar Test kodu için harici olarak bağımlılıkları ile testler sağlamak) (tek bir test paketi ile bir çok uygulamaları test) arabirimi test edilmesi veya klasik bağımlılık enjeksiyon için kullanılabilir.

Cevap 01/05/2009 saat 02:59
kaynak kullanıcı

oy
53

Bu metaclasses kullanarak zarif çözülebilir:

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()
Cevap 01/01/2014 saat 14:52
kaynak kullanıcı

oy
27

load_tests dinamik Testsuite oluşturmak için 2.7'de kişiye az bilinen bir mekanizmadır. Bununla beraber, kolayca parametrized testler oluşturabilirsiniz.

Örneğin:

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

Bu kod load_tests tarafından döndürülen Testsuite tüm testcases çalışacaktır. Başka hiçbir testler otomatik keşif mekanizması tarafından işletilmektedir.

Bu biletin gösterildiği gibi Alternatif olarak, devralma kullanabilirsiniz: http://bugs.python.org/msg151444

Cevap 07/05/2014 saat 02:55
kaynak kullanıcı

oy
24

Bu kullanılarak yapılabilir pytest . Sadece dosyası yazmak test_me.pyiçerikli:

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

Ve komutla testi py.test --tb=short test_me.py. Sonra çıkış gibi görünüyor olacaktır:

=========================== 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 ====================

Çok basit !. Ayrıca pytest gibi başka özelliklere sahiptir fixtures, mark, assert, vb ...

Cevap 02/09/2014 saat 14:08
kaynak kullanıcı

oy
4

Sen kullanabilirsiniz burun ittr eklentisi ( pip install nose-ittr).

Mevcut testler ile entegre etmek çok kolaydır, minimal değişiklikler (varsa) gereklidir. Ayrıca destekler burun çoklu eklenti.

Ayrıca bir özelleştir olabilir Değil o setuptestin ortalama işlevi.

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

Aynı geçmek de mümkündür nosetestonların yap-eklenti ile gibi parametreleri attrib, belirli bir parametre ile sadece belirli bir testi bu yolla:

nosetest -a number=2
Cevap 02/12/2014 saat 11:39
kaynak kullanıcı

oy
2

Ben rastladım ParamUnittest için kaynak koduna bakarken Geçen gün radon ( github repo örnek kullanımı ). O (Burun gibi) TestCase uzatmak diğer çerçeveler ile çalışmalıdır.

İşte bir örnek:

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)
Cevap 05/03/2015 saat 23:21
kaynak kullanıcı

oy
37

Python itibariyle 3.4 alt testleri bu amaçla UnitTest tanıtıldı edilmiştir. Bkz belgelere detayları için. TestCase.subTest izole sağlar bir bağlam yöneticisi bir hata parametresi bilgileri ile rapor edilecektir fakat test icra durmaz ve böylece bir testte iddia olup. İşte belgelerinden örnek:

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)

Bir test çalışmasının çıkış olacaktır:

======================================================================
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

Bu aynı zamanda bir parçası olan unittest2 , bu yüzden Python önceki sürümlerinde kullanılabilir.

Cevap 01/04/2015 saat 05:46
kaynak kullanıcı

oy
8

Kullanım ddt kütüphanesi. Bu deney yöntemleri için basit dekoratörler ekler:

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))

Bu kütüphane ile kurulabilir pip. Bu gerektirmez noseve standart kütüphane ile mükemmel çalışır unittestmodülü.

Cevap 21/04/2015 saat 07:24
kaynak kullanıcı

oy
1

Burada görüldüğü gibi Sadece metaclasses kullanın;

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

Çıktı:

test_sample (ExampleTestCase) ... OK
Cevap 10/05/2015 saat 10:43
kaynak kullanıcı

oy
2

Testler oluşturmak için ben metaclasses ve dekoratörler kullanır. Sen benim uygulama kontrol edebilirsiniz python_wrap_cases . Bu kütüphane herhangi bir test çerçeveler gerektirmez.

Sizin örnek:

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)

Konsol çıkışı:

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

Ayrıca kullanabilir jeneratörler . Örneğin, bu kod bağımsız değişken ile yapılan testlerde tüm olası kombinasyonları oluşturmak a__listveb__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)

Konsol çıkışı:

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
Cevap 01/07/2015 saat 11:28
kaynak kullanıcı

oy
4

Hav veya maddi temelli test ekler Hipotez da var: https://pypi.python.org/pypi/hypothesis

Bu çok güçlü bir test yöntemidir.

Cevap 24/11/2015 saat 00:00
kaynak kullanıcı

oy
1

Sen kullanabilirsiniz TestSuiteve özel TestCasesınıflar.

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)
Cevap 20/12/2015 saat 13:41
kaynak kullanıcı

oy
0

Ben parametreli testler çok özel tarzı ile sorun yaşıyorsanız etmişti. Tüm Selenyum testler lokal çalışabilir, fakat aynı zamanda SauceLabs üzerinde çeşitli platformlarda uzaktan çalıştırılabilir mümkün olmalıdır. Temelde, zaten yazılı sınav vakaların büyük miktarda almak ve olası kodlamak için en az değişikliklerle onları parametreleyebilir istedi. Dahası, ben kurulum yöntemi, başka bir yerde herhangi bir çözüm görmedim şey haline parametreleri geçmek mümkün olması gerekiyordu.

İşte ile geldim budur:

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

Bununla, yapmam gereken bütün her düzenli eski TestCase için () basit dekoratör @sauce_labs eklemek oldu ve onları çalıştırırken şimdi, onlar, sarılmış ve yeniden yazılabilir olduğunuz tüm test yöntemleri parametreli ve adını böylece. LoginTests.test_login_internet_explorer_10.0 (öz), LoginTests.test_login_internet_explorer_11.0 (öz) ve LoginTests.test_login_firefox_43.0 (öz) ve her biri karar vermek parametre self.platform olduğu gibi LoginTests.test_login (öz) çalıştırır hangi tarayıcıyı / platformu çok SauceLabs bağlantı başlatılır orası beri benim görev için çok önemlidir LoginTests.setUp, içinde, çalışmaya zorlar.

Neyse, bu onların testlerin benzer "global" parameterizasyonunu yapmak isteyen birine yardım olabilir umut!

Cevap 22/04/2016 saat 07:02
kaynak kullanıcı

oy
-1

Setattr kullanmanın yanı sıra, biz piton 3.2 beri load_tests kullanabilirsiniz. Yazılan blog bakınız 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()
Cevap 26/05/2016 saat 19:20
kaynak kullanıcı

oy
-1

Aşağıdaki benim çözümdür. Ben ne zaman bu yararlı buluyorum: 1. unittest.Testcase için çalışmak mı ve unittest 2. testlerin bir dizi farklı parametre ayarları için çalıştırılacak var keşfederler. Diğer paketler 3. Çok basit hiçbir bağımlılık unittest içe

    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
Cevap 02/08/2016 saat 15:35
kaynak kullanıcı

oy
0

Bu çözüm ile çalışır unittestve 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()
Cevap 06/09/2016 saat 12:57
kaynak kullanıcı

oy
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)

SONUÇ:

>>> 
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)
Cevap 07/12/2016 saat 04:10
kaynak kullanıcı

oy
0

Metaclass bazlı cevaplar hala Python3 çalışmak, ancak yerine __metaclass__özniteliği birini kullanmak zorundadır metaclassolduğu gibi parametre:

class ExampleTestCase(TestCase,metaclass=DocTestMeta):
    pass
Cevap 08/05/2017 saat 14:25
kaynak kullanıcı

oy
0

Meta-programlama eğlenceli, ama yolda alabilirsiniz. Buradaki çoğu çözümler zorlaştırmaktadır:

  • seçici bir test başlatmak
  • Kod verilen testin adının geri işaret

Yani, benim ilk önerim (herhangi bir test koşucu ile çalışır) basit / açık yolu takip etmektir:

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()

kendimizi tekrarlamak olmayacağından, benim ikinci öneri Javier cevap @ üzerine inşa: mülkiyet temelli test kucaklıyorum. Hipotez kitaplığı:

  • "Bize sadece insanlardan daha test durumu oluşturma hakkında daha fazla acımasız dolambaçlı" dir
  • Basit sayım-örnekler sunacaktır
  • herhangi bir test koşucu ile çalışır
  • sahip daha birçok ilginç özellikleri (istatistikler, ek test çıktısı, ...)

    Sınıf TestSequence (unittest.TestCase):

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

Belirli örnekleri test etmek için, sadece ekleyin:

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

Sadece belirli bir örneği çalıştırmak için, diğer örnekler üzerinden yorum yapabilirsiniz (sağlanan örnek ilk idare edilecek). Sen kullanmak isteyebilir @given(st.nothing()). Başka bir seçenek tarafından bütün bloğu değiştirmektir:

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

Tamam, farklı bir test isimleri yok. Ama belki de sadece gerekir:

  • Test edilen özelliğin tanımlayıcı adı.
  • ki bu giriş yetmezliği (örnek tahrifat) yol açar.

komik örneği

Cevap 08/08/2017 saat 12:59
kaynak kullanıcı

oy
0

Süper partiye geç ama sorun için bu işi yapıyor vardı setUpClass.

İşte bir versiyonu var Javier cevap @ verir setUpClassdinamik olarak ayrılmış özelliklerine erişim.

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

çıktılar

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

OK
Cevap 25/01/2018 saat 19:24
kaynak kullanıcı

oy
0

Biliyorum bu verilerin bir koleksiyon üzerinde hafifçe fark süreçlerini yapmak testler oluşturmak gerekir, özellikle eğer benim amaçlar için iyi çalışır bulduk.

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()

TestGeneratorSınıf gibi test olguların farklı setleri yumurtlamaya için kullanılabilir TestCluster.

TestClusterbir uygulama olarak düşünülebilir TestGeneratorarayüzüne.

Cevap 06/08/2019 saat 16:10
kaynak kullanıcı

oy
0

ithalat unittest

def jeneratör (test_class, a, b, c, d, ad): def testi (kendi kendine): Baskı ( 'Testexecution =', ad) baskı ( 'a =', a) baskı ( 'B = a', b) Baskı ( 'c =' c) baskı (d '=', d)

return test

def add_test_methods (test_class): test_list = [[3,3,5,6, 'bir'], [5,5,8,9, 'iki'], [0,0,5,6, 'üç'] [0,0,2,3 'dört']] test_list durum için: baskı ( 'durum =' halinde [0], durum [1], durum [2], durum [3], durum [4 ]) testi = jeneratör (test_class, örnek [0], durum [1], örnek [2], örnek [3], örnek [4]) 'setattr (test_class, "TEST_% s" % durumda [4], testi)

sınıf TestAuto (unittest.TestCase): def kurulumu (öz): print ( 'Kur') geçiş

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

add_test_methods (TestAuto)

Eğer adı == ' ana ': unittest.main (ayrıntı = 1)

Cevap 21/11/2019 saat 13:00
kaynak kullanıcı

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