From 035ee0128b276be3d7916e82b3c30dcaec22338c758d622735c4d8021fbf1e60 Mon Sep 17 00:00:00 2001 From: Matej Cepl Date: Wed, 27 Oct 2021 19:28:35 +0000 Subject: [PATCH] Accepting request 927765 from home:pgajdos:python - %check: drop usage of nose, use %pytest macro for testing - added patches fix https://github.com/wolever/pprintpp/pull/28 + python-pprintpp-remove-nose.patch OBS-URL: https://build.opensuse.org/request/show/927765 OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-pprintpp?expand=0&rev=8 --- python-pprintpp-remove-nose.patch | 289 ++++++++++++++++++++++++++++++ python-pprintpp.changes | 8 + python-pprintpp.spec | 10 +- 3 files changed, 304 insertions(+), 3 deletions(-) create mode 100644 python-pprintpp-remove-nose.patch diff --git a/python-pprintpp-remove-nose.patch b/python-pprintpp-remove-nose.patch new file mode 100644 index 0000000..cdcb5f3 --- /dev/null +++ b/python-pprintpp-remove-nose.patch @@ -0,0 +1,289 @@ +Index: pprintpp-0.4.0/test.py +=================================================================== +--- pprintpp-0.4.0.orig/test.py 2021-10-26 13:15:18.391876167 +0200 ++++ pprintpp-0.4.0/test.py 2021-10-26 13:15:23.059902356 +0200 +@@ -1,46 +1,100 @@ + from __future__ import print_function + + import sys +-import ctypes +-import textwrap +- +-from nose.tools import assert_equal +-from parameterized import parameterized, param ++from contextlib import redirect_stdout ++import io ++import pytest + + sys.path.append("pp/") + import pp + import pprintpp as p + from pprintpp import Counter, defaultdict, OrderedDict + +-class PPrintppTestBase(object): +- def assertStdout(self, expected, trim=True): +- if trim: +- expected = textwrap.dedent(expected.rstrip().lstrip("\n")) +- # Assumes that nose's capture plugin is active +- assert_equal(sys.stdout.getvalue().rstrip(), expected) +- +- +-class TestPP(PPrintppTestBase): +- def test_pp(self): ++def test_pp(): ++ expected = "['hello', 'world']" ++ f = io.StringIO() ++ with redirect_stdout(f): + pp(["hello", "world"]) +- self.assertStdout("['hello', 'world']") ++ actual = f.getvalue().rstrip("\n") ++ assert actual == expected + +- def test_pp_pprint(self): ++def test_pp_print(): ++ expected = "'stuff'" ++ f = io.StringIO() ++ with redirect_stdout(f): + pp.pprint("stuff") +- self.assertStdout("'stuff'") ++ actual = f.getvalue().rstrip("\n") ++ assert actual == expected + +- def test_fmt(self): ++def test_fmt(): ++ expected = "'asdf'\n'stuff'" ++ f = io.StringIO() ++ with redirect_stdout(f): + print(pp.pformat("asdf")) + print(pp.fmt("stuff")) +- self.assertStdout(""" +- 'asdf' +- 'stuff' +- """) +- +- def test_module_like(self): +- print(dir(pp)) +- print(repr(pp)) ++ actual = f.getvalue().rstrip("\n") ++ assert actual == expected + ++def test_module_like(): ++ print(dir(pp)) ++ print(repr(pp)) ++ ++uni_safe = "\xe9 \u6f02 \u0e4f \u2661" ++uni_unsafe = "\u200a \u0302 \n" ++slashed = lambda s: u"%s'%s'" %( ++ p.u_prefix, ++ s.encode("ascii", "backslashreplace").decode("ascii").replace("\n", "\\n") ++) ++ ++test_unicode_data = [ ++ (uni_safe, "%s'%s'" %(p.u_prefix, uni_safe), "utf-8"), ++ (uni_unsafe, slashed(uni_unsafe), "utf-8"), ++ (uni_unsafe, slashed(uni_unsafe), "ascii"), ++ ("\U0002F9B2", slashed("\U0002F9B2"), "ascii") ++] ++ ++@pytest.mark.parametrize("input,expected,encoding", test_unicode_data) ++def test_unicode(input, expected, encoding): ++ stream = p.TextIO(encoding=encoding) ++ p.pprint(input, stream=stream) ++ assert stream.getvalue().rstrip("\n") == expected ++ ++test_back_and_forth_data = [ ++ "'\\'\"'", ++ '"\'"', ++ "'\"'", ++ "frozenset(['a', 'b', 'c'])", ++ "set([None, 1, 'a'])", ++ "[]", ++ "[1]", ++ "{}", ++ "{1: 1}", ++ "set()", ++ "set([1])", ++ "frozenset()", ++ "frozenset([1])", ++ "()", ++ "(1, )", ++ "MyDict({})", ++ "MyDict({1: 1})", ++ "MyList([])", ++ "MyList([1])", ++ "MyTuple(())", ++ "MyTuple((1, ))", ++ "MySet()", ++ "MySet([1])", ++ "MyFrozenSet()", ++ "MyFrozenSet([1])", ++ "Counter()", ++ "Counter({1: 1})", ++ "OrderedDict()", ++ "OrderedDict([(1, 1), (5, 5), (2, 2)])", ++ "MyOrderedDict()", ++ "MyOrderedDict([(1, 1)])", ++ "MyCounter()", ++ "MyCounter({1: 1})", ++ "MyCounterWithRepr('dummy')", ++] + + class MyDict(dict): + pass +@@ -70,104 +124,46 @@ class MyCounterWithRepr(p.Counter): + def __repr__(self): + return "MyCounterWithRepr('dummy')" + +-class TestPPrint(PPrintppTestBase): +- uni_safe = u"\xe9 \u6f02 \u0e4f \u2661" +- uni_unsafe = u"\u200a \u0302 \n" +- slashed = lambda s: u"%s'%s'" %( +- p.u_prefix, +- s.encode("ascii", "backslashreplace").decode("ascii").replace("\n", "\\n") +- ) +- +- @parameterized([ +- param("safe", uni_safe, "%s'%s'" %(p.u_prefix, uni_safe)), +- param("unsafe", uni_unsafe, slashed(uni_unsafe)), +- param("encoding-aware", uni_safe, slashed(uni_safe), encoding="ascii"), +- param("high-end-chars", u"\U0002F9B2", slashed(u"\U0002F9B2"), encoding="ascii"), +- ]) +- def test_unicode(self, name, input, expected, encoding="utf-8"): +- stream = p.TextIO(encoding=encoding) +- p.pprint(input, stream=stream) +- assert_equal(stream.getvalue().rstrip("\n"), expected) +- +- @parameterized([ +- param(u"'\\'\"'"), +- param(u'"\'"'), +- param(u"'\"'"), +- param("frozenset(['a', 'b', 'c'])"), +- param("set([None, 1, 'a'])"), +- +- param("[]"), +- param("[1]"), +- param("{}"), +- param("{1: 1}"), +- param("set()"), +- param("set([1])"), +- param("frozenset()"), +- param("frozenset([1])"), +- param("()"), +- param("(1, )"), +- +- param("MyDict({})"), +- param("MyDict({1: 1})"), +- param("MyList([])"), +- param("MyList([1])"), +- param("MyTuple(())"), +- param("MyTuple((1, ))"), +- param("MySet()"), +- param("MySet([1])"), +- param("MyFrozenSet()"), +- param("MyFrozenSet([1])"), +- +- ] + ([] if not p._test_has_collections else [ +- param("Counter()"), +- param("Counter({1: 1})"), +- param("OrderedDict()"), +- param("OrderedDict([(1, 1), (5, 5), (2, 2)])"), +- param("MyOrderedDict()"), +- param("MyOrderedDict([(1, 1)])"), +- param("MyCounter()"), +- param("MyCounter({1: 1})"), +- param("MyCounterWithRepr('dummy')"), +- ])) +- def test_back_and_forth(self, expected): +- input = eval(expected) +- stream = p.TextIO() +- p.pprint(input, stream=stream) +- assert_equal(stream.getvalue().rstrip("\n"), expected) +- +- if p._test_has_collections: +- @parameterized([ +- param("defaultdict(%r, {})" %(int, ), defaultdict(int)), +- param("defaultdict(%r, {1: 1})" %(int, ), defaultdict(int, [(1, 1)])), +- param("MyDefaultDict(%r, {})" %(int, ), MyDefaultDict(int)), +- param("MyDefaultDict(%r, {1: 1})" %(int, ), MyDefaultDict(int, [(1, 1)])), +- ]) +- def test_expected_input(self, expected, input): +- stream = p.TextIO() +- p.pprint(input, stream=stream) +- assert_equal(stream.getvalue().rstrip("\n"), expected) +- +- def test_unhashable_repr(self): +- # In Python 3, C extensions can define a __repr__ method which is an +- # instance of `instancemethod`, which is unhashable. It turns out to be +- # spectacularly difficult to create an `instancemethod` and attach it to +- # a type without using C... so we'll simulate it using a more explicitly +- # unhashable type. +- # See also: http://stackoverflow.com/q/40876368/71522 +- +- class UnhashableCallable(object): +- __hash__ = None +- +- def __call__(self): +- return "some-repr" +- +- class MyCls(object): +- __repr__ = UnhashableCallable() +- +- obj = MyCls() +- assert_equal(p.pformat(obj), "some-repr") +- +- +-if __name__ == "__main__": +- import nose +- nose.main() ++@pytest.mark.parametrize("expected", test_back_and_forth_data) ++def test_back_and_forth(expected): ++ input = eval(expected) ++ stream = p.TextIO() ++ p.pprint(input, stream=stream) ++ assert stream.getvalue().rstrip("\n") == expected ++ ++test_expected_input_data = [ ++ ("defaultdict(%r, {})" %(int, ), defaultdict(int)), ++ ("defaultdict(%r, {1: 1})" %(int, ), defaultdict(int, [(1, 1)])), ++ ("MyDefaultDict(%r, {})" %(int, ), MyDefaultDict(int)), ++ ("MyDefaultDict(%r, {1: 1})" %(int, ), MyDefaultDict(int, [(1, 1)])), ++] ++ ++@pytest.mark.parametrize("expected,input", test_expected_input_data) ++def test_expected_input(expected, input): ++ stream = p.TextIO() ++ p.pprint(input, stream=stream) ++ assert stream.getvalue().rstrip("\n") == expected ++ ++ ++def test_unhashable_repr(): ++ # In Python 3, C extensions can define a __repr__ method which is an ++ # instance of `instancemethod`, which is unhashable. It turns out to be ++ # spectacularly difficult to create an `instancemethod` and attach it to ++ # a type without using C... so we'll simulate it using a more explicitly ++ # unhashable type. ++ # See also: http://stackoverflow.com/q/40876368/71522 ++ ++ class UnhashableCallable(object): ++ __hash__ = None ++ ++ def __call__(self): ++ return "some-repr" ++ ++ class MyCls(object): ++ __repr__ = UnhashableCallable() ++ ++ obj = MyCls() ++ assert p.pformat(obj) == "some-repr" ++ ++ ++ +Index: pprintpp-0.4.0/test-requires.txt +=================================================================== +--- pprintpp-0.4.0.orig/test-requires.txt 2021-10-26 13:15:18.391876167 +0200 ++++ pprintpp-0.4.0/test-requires.txt 2021-10-26 13:15:18.395876190 +0200 +@@ -1,2 +1,2 @@ +-nose==1.3.0 ++pytest + parameterized==0.6.1 + diff --git a/python-pprintpp.changes b/python-pprintpp.changes index 3ae481d..a70029b 100644 --- a/python-pprintpp.changes +++ b/python-pprintpp.changes @@ -1,3 +1,11 @@ +------------------------------------------------------------------- +Tue Oct 26 11:38:48 UTC 2021 - pgajdos@suse.com + +- %check: drop usage of nose, use %pytest macro for testing +- added patches + fix https://github.com/wolever/pprintpp/pull/28 + + python-pprintpp-remove-nose.patch + ------------------------------------------------------------------- Wed May 20 07:26:15 UTC 2020 - Petr Gajdos diff --git a/python-pprintpp.spec b/python-pprintpp.spec index fe3e936..0983f9c 100644 --- a/python-pprintpp.spec +++ b/python-pprintpp.spec @@ -1,7 +1,7 @@ # # spec file for package python-pprintpp # -# Copyright (c) 2020 SUSE LLC +# Copyright (c) 2021 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -26,13 +26,16 @@ Group: Development/Languages/Python URL: https://github.com/wolever/pprintpp Source: https://files.pythonhosted.org/packages/source/p/pprintpp/pprintpp-%{version}.tar.gz Patch0: https://github.com/wolever/pprintpp/commit/3a35e815.patch +# https://github.com/wolever/pprintpp/pull/28 +Patch1: python-pprintpp-remove-nose.patch BuildRequires: %{python_module nose} BuildRequires: %{python_module parameterized} +BuildRequires: %{python_module pytest} BuildRequires: %{python_module setuptools} BuildRequires: fdupes BuildRequires: python-rpm-macros Requires(post): update-alternatives -Requires(postun): update-alternatives +Requires(postun):update-alternatives BuildArch: noarch %python_subpackages @@ -42,6 +45,7 @@ A drop-in replacement for pprint that is arguably prettier. %prep %setup -q -n pprintpp-%{version} %patch0 -p1 +%patch1 -p1 %build export LANG=en_US.utf-8 @@ -55,7 +59,7 @@ export LANG=en_US.utf-8 %check export LANG=en_US.utf-8 -%python_exec setup.py test --test-suite=test +%pytest -v test.py %post %python_install_alternative pypprint