Accepting request 927846 from devel:languages:python

OBS-URL: https://build.opensuse.org/request/show/927846
OBS-URL: https://build.opensuse.org/package/show/openSUSE:Factory/python-pprintpp?expand=0&rev=4

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
+

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 <pgajdos@suse.com>
 

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