diff --git a/parameterized-pr116-pytest4.patch b/parameterized-pr116-pytest4.patch new file mode 100644 index 0000000..c03b17f --- /dev/null +++ b/parameterized-pr116-pytest4.patch @@ -0,0 +1,537 @@ +From 674f23824328709562303941e9546097b360b4fc Mon Sep 17 00:00:00 2001 +From: David Wolever +Date: Sat, 9 Jan 2021 16:00:47 -0500 +Subject: [PATCH 1/6] Enable pytest4 (tests will fail) + +--- + tox.ini | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +Index: parameterized-0.8.1/tox.ini +=================================================================== +--- parameterized-0.8.1.orig/tox.ini ++++ parameterized-0.8.1/tox.ini +@@ -1,5 +1,5 @@ + [tox] +-envlist=py{27,35,36,py}-{nose,nose2,pytest2,pytest3,unit,unit2},py{37,38,39}-{nose,nose2,pytest3,unit,unit2} ++envlist=py{27,35,36,py}-{nose,nose2,pytest2,pytest3,pytest4,unit,unit2},py{37,38,39}-{nose,nose2,pytest3,pytest4,unit,unit2} + [testenv] + deps= + nose +@@ -7,13 +7,13 @@ deps= + nose2: nose2 + pytest2: pytest>=2,<3 + pytest3: pytest>=3,<4 +- #pytest4: pytest>=4,<5 ++ pytest4: pytest>=4,<5 + unit2: unittest2 + commands= + nose: nosetests + nose2: nose2 + pytest2: py.test parameterized/test.py + pytest3: py.test parameterized/test.py +- #pytest4: py.test parameterized/test.py ++ pytest4: py.test parameterized/test.py + unit: python -m unittest parameterized.test + unit2: unit2 parameterized.test +Index: parameterized-0.8.1/parameterized/parameterized.py +=================================================================== +--- parameterized-0.8.1.orig/parameterized/parameterized.py ++++ parameterized-0.8.1/parameterized/parameterized.py +@@ -19,9 +19,14 @@ except ImportError: + class SkipTest(Exception): + pass + ++try: ++ import pytest ++except ImportError: ++ pytest = None ++ + PY3 = sys.version_info[0] == 3 + PY2 = sys.version_info[0] == 2 +- ++PYTEST4 = pytest and pytest.__version__ >= '4.0.0' + + if PY3: + # Python 3 doesn't have an InstanceType, so just use a dummy type. +@@ -352,6 +357,120 @@ class parameterized(object): + def __call__(self, test_func): + self.assert_not_in_testcase_subclass() + ++ input = self.get_input() ++ wrapper = self._wrap_test_func(test_func, input) ++ wrapper.parameterized_input = input ++ wrapper.parameterized_func = test_func ++ test_func.__name__ = "_parameterized_original_%s" %(test_func.__name__, ) ++ ++ return wrapper ++ ++ def _wrap_test_func(self, test_func, input): ++ """ Wraps a test function so that it will appropriately handle ++ parameterization. ++ ++ In the general case, the wrapper will enumerate the input, yielding ++ test cases. ++ ++ In the case of pytest4, the wrapper will use ++ ``@pytest.mark.parametrize`` to parameterize the test function. """ ++ ++ if not input: ++ if not self.skip_on_empty: ++ raise ValueError( ++ "Parameters iterable is empty (hint: use " ++ "`parameterized([], skip_on_empty=True)` to skip " ++ "this test when the input is empty)" ++ ) ++ return wraps(test_func)(skip_on_empty_helper) ++ ++ if PYTEST4 and detect_runner() == "pytest": ++ # pytest >= 4 compatibility is... a bit of work. Basically, the ++ # only way (I can find) of implementing parameterized testing with ++ # pytest >= 4 is through the ``@pytest.mark.parameterized`` ++ # decorator. This decorator has some strange requirements around ++ # the name and number of arguments to the test function, so this ++ # wrapper works around that by: ++ # 1. Introspecting the original test function to determine the ++ # names and default values of all arguments. ++ # 2. Creating a new function with the same arguments, but none ++ # of them are optional:: ++ # ++ # def foo(a, b=42): ... ++ # ++ # Becomes: ++ # ++ # def parameterized_pytest_wrapper_foo(a, b): ... ++ # ++ # 3. Merging the ``@parameterized`` parameters with the argument ++ # default values. ++ # 4. Generating a list of ``pytest.param(...)`` values, and passing ++ # that into ``@pytest.mark.parameterized``. ++ # Some work also needs to be done to support the documented usage ++ # of ``mock.patch``, which also adds complexity. ++ Undefined = object() ++ test_func_wrapped = test_func ++ test_func_real, mock_patchings = unwrap_mock_patch_func(test_func_wrapped) ++ func_argspec = getargspec(test_func_real) ++ ++ func_args = func_argspec.args ++ if mock_patchings: ++ func_args = func_args[:-len(mock_patchings)] ++ ++ func_args_no_self = func_args ++ if func_args_no_self[:1] == ["self"]: ++ func_args_no_self = func_args_no_self[1:] ++ ++ args_with_default = dict( ++ (arg, Undefined) ++ for arg in func_args_no_self ++ ) ++ for (arg, default) in zip(reversed(func_args_no_self), reversed(func_argspec.defaults or [])): ++ args_with_default[arg] = default ++ ++ pytest_params = [] ++ for i in input: ++ p = dict(args_with_default) ++ for (arg, val) in zip(func_args_no_self, i.args): ++ p[arg] = val ++ p.update(i.kwargs) ++ ++ # Sanity check: all arguments should now be defined ++ if any(v is Undefined for v in p.values()): ++ raise ValueError( ++ "When parameterizing function %r: no value for " ++ "arguments: %s with parameters %r " ++ "(see: 'no value for arguments' in " ++ "https://github.com/wolever/parameterized#faq)" %( ++ test_func, ++ ", ".join( ++ repr(arg) ++ for (arg, val) in p.items() ++ if val is Undefined ++ ), ++ i, ++ ) ++ ) ++ ++ pytest_params.append(pytest.param(*[ ++ p.get(arg) for arg in func_args_no_self ++ ])) ++ ++ namespace = { ++ "__parameterized_original_test_func": test_func_wrapped, ++ } ++ wrapper_name = "parameterized_pytest_wrapper_%s" %(test_func.__name__, ) ++ exec( ++ "def %s(%s, *__args): return __parameterized_original_test_func(%s, *__args)" %( ++ wrapper_name, ++ ",".join(func_args), ++ ",".join(func_args), ++ ), ++ namespace, ++ namespace, ++ ) ++ return pytest.mark.parametrize(",".join(func_args_no_self), pytest_params)(namespace[wrapper_name]) ++ + @wraps(test_func) + def wrapper(test_self=None): + test_cls = test_self and type(test_self) +@@ -366,7 +485,7 @@ class parameterized(object): + ) %(test_self, )) + + original_doc = wrapper.__doc__ +- for num, args in enumerate(wrapper.parameterized_input): ++ for num, args in enumerate(input): + p = param.from_decorator(args) + unbound_func, nose_tuple = self.param_as_nose_tuple(test_self, test_func, num, p) + try: +@@ -383,21 +502,6 @@ class parameterized(object): + if test_self is not None: + delattr(test_cls, test_func.__name__) + wrapper.__doc__ = original_doc +- +- input = self.get_input() +- if not input: +- if not self.skip_on_empty: +- raise ValueError( +- "Parameters iterable is empty (hint: use " +- "`parameterized([], skip_on_empty=True)` to skip " +- "this test when the input is empty)" +- ) +- wrapper = wraps(test_func)(skip_on_empty_helper) +- +- wrapper.parameterized_input = input +- wrapper.parameterized_func = test_func +- test_func.__name__ = "_parameterized_original_%s" %(test_func.__name__, ) +- + return wrapper + + def param_as_nose_tuple(self, test_self, func, num, p): +@@ -618,6 +722,11 @@ def parameterized_class(attrs, input_val + + return decorator + ++def unwrap_mock_patch_func(f): ++ if not hasattr(f, "patchings"): ++ return (f, []) ++ real_func, patchings = unwrap_mock_patch_func(f.__wrapped__) ++ return (real_func, patchings + f.patchings) + + def get_class_name_suffix(params_dict): + if "name" in params_dict: +Index: parameterized-0.8.1/parameterized/test.py +=================================================================== +--- parameterized-0.8.1.orig/parameterized/test.py ++++ parameterized-0.8.1/parameterized/test.py +@@ -6,8 +6,9 @@ from unittest import TestCase + from nose.tools import assert_equal, assert_raises + + from .parameterized import ( +- PY3, PY2, parameterized, param, parameterized_argument_value_pairs, +- short_repr, detect_runner, parameterized_class, SkipTest, ++ PY3, PY2, PYTEST4, parameterized, param, ++ parameterized_argument_value_pairs, short_repr, detect_runner, ++ parameterized_class, SkipTest, + ) + + def assert_contains(haystack, needle): +@@ -40,6 +41,7 @@ def expect(skip, tests=None): + + test_params = [ + (42, ), ++ (42, "bar_val"), + "foo0", + param("foo1"), + param("foo2", bar=42), +@@ -50,6 +52,7 @@ expect("standalone", [ + "test_naked_function('foo1', bar=None)", + "test_naked_function('foo2', bar=42)", + "test_naked_function(42, bar=None)", ++ "test_naked_function(42, bar='bar_val')", + ]) + + @parameterized(test_params) +@@ -63,6 +66,7 @@ class TestParameterized(object): + "test_instance_method('foo1', bar=None)", + "test_instance_method('foo2', bar=42)", + "test_instance_method(42, bar=None)", ++ "test_instance_method(42, bar='bar_val')", + ]) + + @parameterized(test_params) +@@ -95,10 +99,16 @@ if not PYTEST: + missing_tests.remove("test_setup(%s)" %(self.actual_order, )) + + +-def custom_naming_func(custom_tag): ++def custom_naming_func(custom_tag, kw_name): + def custom_naming_func(testcase_func, param_num, param): +- return testcase_func.__name__ + ('_%s_name_' % custom_tag) + str(param.args[0]) +- ++ return ( ++ testcase_func.__name__ + ++ '_%s_name_' %(custom_tag, ) + ++ str(param.args[0]) + ++ # This ... is a bit messy, to properly handle the values in ++ # `test_params`, but ... it should work. ++ '_%s' %(param.args[1] if len(param.args) > 1 else param.kwargs.get(kw_name), ) ++ ) + return custom_naming_func + + +@@ -137,19 +147,20 @@ class TestParameterizedExpandWithMockPat + mock_fdopen._mock_name, mock_getpid._mock_name)) + + +-@mock.patch("os.getpid") +-class TestParameterizedExpandWithNoExpand(object): +- expect("generator", [ +- "test_patch_class_no_expand(42, 51, 'umask', 'getpid')", +- ]) ++if not (PYTEST4 and detect_runner() == 'pytest'): ++ @mock.patch("os.getpid") ++ class TestParameterizedExpandWithNoExpand(object): ++ expect("generator", [ ++ "test_patch_class_no_expand(42, 51, 'umask', 'getpid')", ++ ]) + +- @parameterized([(42, 51)]) +- @mock.patch("os.umask") +- def test_patch_class_no_expand(self, foo, bar, mock_umask, mock_getpid): +- missing_tests.remove("test_patch_class_no_expand" +- "(%r, %r, %r, %r)" % +- (foo, bar, mock_umask._mock_name, +- mock_getpid._mock_name)) ++ @parameterized([(42, 51)]) ++ @mock.patch("os.umask") ++ def test_patch_class_no_expand(self, foo, bar, mock_umask, mock_getpid): ++ missing_tests.remove("test_patch_class_no_expand" ++ "(%r, %r, %r, %r)" % ++ (foo, bar, mock_umask._mock_name, ++ mock_getpid._mock_name)) + + + class TestParameterizedExpandWithNoMockPatchForClass(TestCase): +@@ -214,6 +225,7 @@ class TestParamerizedOnTestCase(TestCase + "test_on_TestCase('foo1', bar=None)", + "test_on_TestCase('foo2', bar=42)", + "test_on_TestCase(42, bar=None)", ++ "test_on_TestCase(42, bar='bar_val')", + ]) + + @parameterized.expand(test_params) +@@ -221,20 +233,21 @@ class TestParamerizedOnTestCase(TestCase + missing_tests.remove("test_on_TestCase(%r, bar=%r)" %(foo, bar)) + + expect([ +- "test_on_TestCase2_custom_name_42(42, bar=None)", +- "test_on_TestCase2_custom_name_foo0('foo0', bar=None)", +- "test_on_TestCase2_custom_name_foo1('foo1', bar=None)", +- "test_on_TestCase2_custom_name_foo2('foo2', bar=42)", ++ "test_on_TestCase2_custom_name_42_None(42, bar=None)", ++ "test_on_TestCase2_custom_name_42_bar_val(42, bar='bar_val')", ++ "test_on_TestCase2_custom_name_foo0_None('foo0', bar=None)", ++ "test_on_TestCase2_custom_name_foo1_None('foo1', bar=None)", ++ "test_on_TestCase2_custom_name_foo2_42('foo2', bar=42)", + ]) + + @parameterized.expand(test_params, +- name_func=custom_naming_func("custom")) ++ name_func=custom_naming_func("custom", "bar")) + def test_on_TestCase2(self, foo, bar=None): + stack = inspect.stack() + frame = stack[1] + frame_locals = frame[0].f_locals + nose_test_method_name = frame_locals['a'][0]._testMethodName +- expected_name = "test_on_TestCase2_custom_name_" + str(foo) ++ expected_name = "test_on_TestCase2_custom_name_" + str(foo) + "_" + str(bar) + assert_equal(nose_test_method_name, expected_name, + "Test Method name '%s' did not get customized to expected: '%s'" % + (nose_test_method_name, expected_name)) +@@ -373,6 +386,8 @@ def tearDownModule(): + def test_old_style_classes(): + if PY3: + raise SkipTest("Py3 doesn't have old-style classes") ++ if PYTEST4 and detect_runner() == 'pytest': ++ raise SkipTest("We're not going to worry about old style classes with pytest 4") + class OldStyleClass: + @parameterized(["foo"]) + def parameterized_method(self, param): +@@ -552,3 +567,16 @@ class TestUnicodeDocstring(object): + def test_with_docstring(self, param): + """ Это док-стринг, содержащий не-ascii символы """ + pass ++ ++if PYTEST4 and detect_runner() == 'pytest': ++ def test_missing_argument_error(): ++ try: ++ @parameterized([ ++ (1, ), ++ ]) ++ def foo(a, b): ++ pass ++ except ValueError as e: ++ assert_contains(repr(e), "no value for arguments: 'b'") ++ else: ++ raise AssertionError("Expected exception not raised") +Index: parameterized-0.8.1/README.rst +=================================================================== +--- parameterized-0.8.1.orig/README.rst ++++ parameterized-0.8.1/README.rst +@@ -9,11 +9,9 @@ Parameterized testing with any Python te + :alt: Circle CI + :target: https://circleci.com/gh/wolever/parameterized + +- +-Parameterized testing in Python sucks. +- +-``parameterized`` fixes that. For everything. Parameterized testing for nose, +-parameterized testing for py.test, parameterized testing for unittest. ++``parameterized`` provides universal parameterized testing for Python: ++parameterized testing for nose, parameterized testing for py.test, ++parameterized testing for unittest, parameterized testing for Django. + + .. code:: python + +@@ -131,7 +129,7 @@ With unittest (and unittest2):: + (note: because unittest does not support test decorators, only tests created + with ``@parameterized.expand`` will be executed) + +-With green:: ++With `green`__ :: + + $ green test_math.py -vvv + test_math +@@ -161,6 +159,7 @@ With green:: + + OK (passes=9) + ++__ https://github.com/CleanCut/green + + Installation + ------------ +@@ -237,16 +236,16 @@ __ https://travis-ci.org/wolever/paramet + - yes + - yes + * - py.test 4 +- - no** +- - no** +- - no** +- - no** +- - no** +- - no** +- - no** +- - no** +- - no** +- - no** ++ - yes ++ - yes ++ - yes ++ - yes ++ - yes ++ - yes ++ - yes ++ - yes ++ - yes ++ - yes + * - py.test fixtures + - no† + - no† +@@ -285,8 +284,6 @@ __ https://travis-ci.org/wolever/paramet + + \*: py.test 2 does `does not appear to work (#71)`__ under Python 3. Please comment on the related issues if you are affected. + +-\*\*: py.test 4 is not yet supported (but coming!) in `issue #34`__ +- + †: py.test fixture support is documented in `issue #81`__ + + __ https://github.com/wolever/parameterized/issues/71 +@@ -575,7 +572,6 @@ which controls the name of the parameter + test_concat (test_concat.TestConcatenation_0_say_cheese__) ... ok + + +- + Using with Single Parameters + ............................ + +@@ -616,15 +612,42 @@ can be confusing. The ``@mock.patch(...) + + .. code:: python + +- @mock.patch("os.getpid") + class TestOS(object): + @parameterized(...) + @mock.patch("os.fdopen") + @mock.patch("os.umask") +- def test_method(self, param1, param2, ..., mock_umask, mock_fdopen, mock_getpid): ++ def test_method(self, param1, param2, ..., mock_umask, mock_fdopen): + ... + +-Note: the same holds true when using ``@parameterized.expand``. ++Note 1: the same holds true when using ``@parameterized.expand``. ++ ++Note 2: ``@mock.patch`` is supported with all runners, including ``pytest``, ++*except* when used as a *class decorator* with ``pytest>=4``. ++ ++Parameterized testing with Django ++................................. ++ ++``parameterized`` enables parameterized testing with Django with ++``@parameterized.expand``:: ++ ++ from django.test import TestCase ++ ++ class DjangoTestCase(TestCase): ++ @parameterized.expand([ ++ ("negative", -1.5, -2.0), ++ ("integer", 1, 1.0), ++ ("large fraction", 1.6, 1), ++ ]) ++ def test_floor(self, name, input, expected): ++ assert_equal(math.floor(input), expected) ++ ++Which will yield:: ++ ++ $ python manage.py test ++ ... ++ test_floor_0_negative (test_math.DjangoTestCase) ... ok ++ test_floor_1_integer (test_math.DjangoTestCase) ... ok ++ test_floor_2_large_fraction (test_math.DjangoTestCase) ... ok + + + Migrating from ``nose-parameterized`` to ``parameterized`` +@@ -650,7 +673,7 @@ What happened to ``nose-parameterized``? + only made sense to change the name! + + What do you mean when you say "nose is best supported"? +- There are small caveates with ``py.test`` and ``unittest``: ``py.test`` ++ There are small caveats with ``py.test`` and ``unittest``: ``py.test`` + does not show the parameter values (ex, it will show ``test_add[0]`` + instead of ``test_add[1, 2, 3]``), and ``unittest``/``unittest2`` do not + support test generators so ``@parameterized.expand`` must be used. +@@ -664,3 +687,26 @@ Why do I get an ``AttributeError: 'funct + You've likely installed the ``parametrized`` (note the missing *e*) + package. Use ``parameterized`` (with the *e*) instead and you'll be all + set. ++ ++What is the ``no value for arguments`` error when using ``pytest>=4``? ++ The ``no value for arguments`` error occurs with ``pytest>=4`` when the ++ parameters for a method do not supply values for all the test function ++ arguments. ++ ++ For example, consider:: ++ ++ @parameterized([ ++ (1, ), ++ (2, 3), ++ ]) ++ def test_foo(a, b): ++ pass ++ ++ In this case, the error will be ``no value for arguments: 'b' with ++ paramters (1, )``, because the parameter ``(1, )`` does not provide ++ a value for the argument ``b``. ++ ++ Because ``pytest.mark.parametrized`` - which is used to implement ++ parametrized testing with ``pytest>=4`` - depends fairly heavily on ++ argument names, this can also come up if other decorators are used (for ++ example, if ``@mock.patch`` is used as a class decorator). diff --git a/python-parameterized.changes b/python-parameterized.changes index 3f46c6d..a1ebd9f 100644 --- a/python-parameterized.changes +++ b/python-parameterized.changes @@ -1,3 +1,11 @@ +------------------------------------------------------------------- +Thu Apr 14 17:07:13 UTC 2022 - Ben Greiner + +- Add parameterized-pr116-pytest4.patch for pytest 4 to 7 (!) + support -- gh#wolever/parameterized#116 +- Refresh remove_nose.patch +- Drop skip_Documentation_tests.patch fixed upstream + ------------------------------------------------------------------- Thu Apr 7 12:34:14 UTC 2022 - pgajdos@suse.com diff --git a/python-parameterized.spec b/python-parameterized.spec index e4a7e32..f28f831 100644 --- a/python-parameterized.spec +++ b/python-parameterized.spec @@ -24,10 +24,9 @@ Summary: Parameterized testing License: BSD-2-Clause URL: https://github.com/wolever/parameterized Source: https://files.pythonhosted.org/packages/source/p/parameterized/parameterized-%{version}.tar.gz -# PATCH-FIX-UPSTREAM skip_Documentation_tests.patch gh#wolever/parameterized#84 mcepl@suse.com -# Skip tests failing with Python 3.8 -Patch0: skip_Documentation_tests.patch -# PATCH-FIX-UPSTREAM remove_nose.patch mcepl@suse.com +# PATCH-FIX-UPSTREAM parameterized-pr116-pytest4.patch -- gh#wolever/parameterized#116, fix pytest >= 4 execution +Patch0: parameterized-pr116-pytest4.patch +# PATCH-FIX-OPENSUSE remove_nose.patch mcepl@suse.com # Remove nose dependency (patch is not very good, DO NOT SEND UPSTREAM!) Patch1: remove_nose.patch BuildRequires: %{python_module nose2} diff --git a/remove_nose.patch b/remove_nose.patch index b11b131..3203b51 100644 --- a/remove_nose.patch +++ b/remove_nose.patch @@ -3,18 +3,20 @@ parameterized/test.py | 30 ++++++++++++++++-------------- 2 files changed, 20 insertions(+), 17 deletions(-) ---- a/parameterized/test.py -+++ b/parameterized/test.py -@@ -4,7 +4,7 @@ import inspect +Index: parameterized-0.8.1/parameterized/test.py +=================================================================== +--- parameterized-0.8.1.orig/parameterized/test.py ++++ parameterized-0.8.1/parameterized/test.py +@@ -3,7 +3,7 @@ + import inspect import mock - import sys - from unittest import TestCase, skipIf + from unittest import TestCase -from nose.tools import assert_equal, assert_raises +import pytest from .parameterized import ( - PY3, PY2, parameterized, param, parameterized_argument_value_pairs, -@@ -88,12 +88,12 @@ if not PYTEST: + PY3, PY2, PYTEST4, parameterized, param, +@@ -91,12 +91,12 @@ if not PYTEST: self.actual_order = self.stack.pop(0) def tearDown(self): @@ -29,11 +31,11 @@ + missing_tests.remove("test_setup(%s)" % self.actual_order) - def custom_naming_func(custom_tag): -@@ -236,9 +236,9 @@ class TestParamerizedOnTestCase(TestCase + def custom_naming_func(custom_tag, kw_name): +@@ -248,9 +248,9 @@ class TestParamerizedOnTestCase(TestCase frame_locals = frame[0].f_locals nose_test_method_name = frame_locals['a'][0]._testMethodName - expected_name = "test_on_TestCase2_custom_name_" + str(foo) + expected_name = "test_on_TestCase2_custom_name_" + str(foo) + "_" + str(bar) - assert_equal(nose_test_method_name, expected_name, - "Test Method name '%s' did not get customized to expected: '%s'" % - (nose_test_method_name, expected_name)) @@ -43,7 +45,7 @@ missing_tests.remove("%s(%r, bar=%r)" %(expected_name, foo, bar)) -@@ -261,7 +261,7 @@ class TestParameterizedExpandDocstring(T +@@ -272,7 +272,7 @@ class TestParameterizedExpandDocstring(T actual_docstring = test_method.__doc__ if rstrip: actual_docstring = actual_docstring.rstrip() @@ -52,7 +54,7 @@ @parameterized.expand([param("foo")], doc_func=lambda f, n, p: "stuff") -@@ -337,7 +337,7 @@ def test_helpful_error_on_empty_iterable +@@ -348,7 +348,7 @@ def test_helpful_error_on_empty_iterable def test_skip_test_on_empty_iterable(): func = parameterized([], skip_on_empty=True)(lambda: None) @@ -61,7 +63,7 @@ def test_helpful_error_on_empty_iterable_input_expand(): -@@ -370,7 +370,7 @@ def test_helpful_error_on_non_iterable_i +@@ -381,7 +381,7 @@ def test_helpful_error_on_non_iterable_i def tearDownModule(): missing = sorted(list(missing_tests)) @@ -70,7 +72,7 @@ def test_old_style_classes(): if PY3: -@@ -420,7 +420,7 @@ class TestOldStyleClass: +@@ -433,7 +433,7 @@ class TestOldStyleClass: def test_parameterized_argument_value_pairs(func_params, p, expected): helper = eval("lambda %s: None" %(func_params, )) actual = parameterized_argument_value_pairs(helper, p) @@ -79,7 +81,7 @@ @parameterized([ -@@ -430,7 +430,7 @@ def test_parameterized_argument_value_pa +@@ -443,7 +443,7 @@ def test_parameterized_argument_value_pa (123456789, "12...89", 4), ]) def test_short_repr(input, expected, n=6): @@ -88,7 +90,7 @@ @parameterized([ ("foo", ), -@@ -444,7 +444,7 @@ cases_over_10 = [(i, i+1) for i in range +@@ -457,7 +457,7 @@ cases_over_10 = [(i, i+1) for i in range @parameterized(cases_over_10) def test_cases_over_10(input, expected): @@ -97,7 +99,7 @@ @parameterized_class(("a", "b", "c"), [ -@@ -461,7 +461,7 @@ class TestParameterizedClass(TestCase): +@@ -476,7 +476,7 @@ class TestParameterizedClass(TestCase): def _assertions(self, test_name): assert hasattr(self, "a") @@ -106,9 +108,11 @@ missing_tests.remove("%s:%s(%r, %r, %r)" %( self.__class__.__name__, test_name, ---- a/parameterized/parameterized.py -+++ b/parameterized/parameterized.py -@@ -276,7 +276,7 @@ def default_name_func(func, num, p): +Index: parameterized-0.8.1/parameterized/parameterized.py +=================================================================== +--- parameterized-0.8.1.orig/parameterized/parameterized.py ++++ parameterized-0.8.1/parameterized/parameterized.py +@@ -286,7 +286,7 @@ def default_name_func(func, num, p): _test_runner_override = None _test_runner_guess = False @@ -117,12 +121,3 @@ _test_runner_aliases = { "_pytest": "pytest", } -@@ -582,7 +582,7 @@ def parameterized_class(attrs, input_val - ) - - class_name_func = class_name_func or default_class_name_func -- -+ - if classname_func: - warnings.warn( - "classname_func= is deprecated; use class_name_func= instead. " diff --git a/skip_Documentation_tests.patch b/skip_Documentation_tests.patch deleted file mode 100644 index f4a0a5b..0000000 --- a/skip_Documentation_tests.patch +++ /dev/null @@ -1,20 +0,0 @@ ---- a/parameterized/test.py -+++ b/parameterized/test.py -@@ -2,7 +2,8 @@ - - import inspect - import mock --from unittest import TestCase -+import sys -+from unittest import TestCase, skipIf - from nose.tools import assert_equal, assert_raises - - from .parameterized import ( -@@ -241,6 +242,7 @@ class TestParamerizedOnTestCase(TestCase - missing_tests.remove("%s(%r, bar=%r)" %(expected_name, foo, bar)) - - -+@skipIf(sys.version_info[:2] >= (3, 8), "Doesn't work with Python 3.8") - class TestParameterizedExpandDocstring(TestCase): - def _assert_docstring(self, expected_docstring, rstrip=False): - """ Checks the current test method's docstring. Must be called directly