diff --git a/python-jsondiff.changes b/python-jsondiff.changes
index a785f20..981c9b0 100644
--- a/python-jsondiff.changes
+++ b/python-jsondiff.changes
@@ -1,3 +1,8 @@
+-------------------------------------------------------------------
+Sun Sep 13 17:39:27 UTC 2020 - Matej Cepl <mcepl@suse.com>
+
+- Add remove_nose.patch to remove requirement for nose.
+
 -------------------------------------------------------------------
 Mon May 25 10:59:35 UTC 2020 - Petr Gajdos <pgajdos@suse.com>
 
diff --git a/python-jsondiff.spec b/python-jsondiff.spec
index 0b8f024..f269894 100644
--- a/python-jsondiff.spec
+++ b/python-jsondiff.spec
@@ -24,8 +24,10 @@ Summary:        Module to diff JSON and JSON-like structures in Python
 License:        MIT
 URL:            https://github.com/ZoomerAnalytics/jsondiff
 Source:         https://files.pythonhosted.org/packages/source/j/jsondiff/jsondiff-%{version}.tar.gz
-BuildRequires:  %{python_module nose-random}
-BuildRequires:  %{python_module nose}
+# PATCH-FEATURE-UPSTREAM remove_nose.patch bsc#[0-9]+ mcepl@suse.com
+# Replace nose-random plugin with ripped of version independent of nose.
+Patch0:         remove_nose.patch
+BuildRequires:  %{python_module pytest}
 BuildRequires:  %{python_module setuptools}
 BuildRequires:  fdupes
 BuildRequires:  python-rpm-macros
@@ -39,7 +41,7 @@ BuildArch:      noarch
 Package to show differences between JSON and JSON-like structures in Python
 
 %prep
-%setup -q -n jsondiff-%{version}
+%autosetup -p1 -n jsondiff-%{version}
 
 %build
 %python_build
@@ -51,7 +53,7 @@ Package to show differences between JSON and JSON-like structures in Python
 %python_expand %fdupes %{buildroot}%{$python_sitelib}
 
 %check
-%python_expand nosetests-%{$python_bin_suffix}
+%pytest tests/__init__.py
 
 %post
 %python_install_alternative jsondiff
diff --git a/remove_nose.patch b/remove_nose.patch
new file mode 100644
index 0000000..66bbdbd
--- /dev/null
+++ b/remove_nose.patch
@@ -0,0 +1,269 @@
+--- /dev/null
++++ b/tests/_random.py
+@@ -0,0 +1,33 @@
++import sys
++from random import Random
++
++PY3 = (sys.version_info[0] == 3)
++
++
++def _generate_tag(n, rng):
++    return ''.join(rng.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')
++                   for _ in range(n))
++
++
++def randomize(n, scenario_generator, seed=12038728732):
++    def decorator(test):
++        def randomized_test(self):
++            rng_seed = Random(seed)
++            nseeds = n
++            # (rng_seed.getrandbits(32) for i in range(n))
++            seeds = (_generate_tag(12, rng_seed) for i in range(n))
++            for i, rseed in enumerate(seeds):
++                rng = Random(rseed)
++                scenario = scenario_generator(self, rng)
++                try:
++                    test(self, scenario)
++                except Exception as e:
++                    import sys
++                    if PY3:
++                        raise type(e).with_traceback(type(e)('%s with scenario %s (%i of %i)' %
++                                                             (e.message, rseed, i+1, nseeds)), sys.exc_info()[2])
++                    else:
++                        raise (type(e), type(e)('%s with scenario %s (%i of %i)'
++                               % (e.message, rseed, i+1, nseeds)), sys.exc_info()[2])
++        return randomized_test
++    return decorator
+--- a/tests/__init__.py
++++ b/tests/__init__.py
+@@ -1,115 +0,0 @@
+-import unittest
+-
+-from jsondiff import diff, replace, add, discard, insert, delete, update, JsonDiffer
+-
+-from .utils import generate_random_json, perturbate_json
+-
+-from nose_random import randomize
+-
+-
+-class JsonDiffTests(unittest.TestCase):
+-
+-    def test_a(self):
+-
+-        self.assertEqual({}, diff(1, 1))
+-        self.assertEqual({}, diff(True, True))
+-        self.assertEqual({}, diff('abc', 'abc'))
+-        self.assertEqual({}, diff([1, 2], [1, 2]))
+-        self.assertEqual({}, diff((1, 2), (1, 2)))
+-        self.assertEqual({}, diff({1, 2}, {1, 2}))
+-        self.assertEqual({}, diff({'a': 1, 'b': 2}, {'a': 1, 'b': 2}))
+-        self.assertEqual({}, diff([], []))
+-        self.assertEqual({}, diff(None, None))
+-        self.assertEqual({}, diff({}, {}))
+-        self.assertEqual({}, diff(set(), set()))
+-
+-        self.assertEqual(2, diff(1, 2))
+-        self.assertEqual(False, diff(True, False))
+-        self.assertEqual('def', diff('abc', 'def'))
+-        self.assertEqual([3, 4], diff([1, 2], [3, 4]))
+-        self.assertEqual((3, 4), diff((1, 2), (3, 4)))
+-        self.assertEqual({3, 4}, diff({1, 2}, {3, 4}))
+-        self.assertEqual({replace: {'c': 3, 'd': 4}}, diff({'a': 1, 'b': 2}, {'c': 3, 'd': 4}))
+-
+-        self.assertEqual({replace: {'c': 3, 'd': 4}}, diff([1, 2], {'c': 3, 'd': 4}))
+-        self.assertEqual(123, diff({'a': 1, 'b': 2}, 123))
+-
+-        self.assertEqual({delete: ['b']}, diff({'a': 1, 'b': 2}, {'a': 1}))
+-        self.assertEqual({'b': 3}, diff({'a': 1, 'b': 2}, {'a': 1, 'b': 3}))
+-        self.assertEqual({'c': 3}, diff({'a': 1, 'b': 2}, {'a': 1, 'b': 2, 'c': 3}))
+-        self.assertEqual({delete: ['b'], 'c': 3}, diff({'a': 1, 'b': 2}, {'a': 1, 'c': 3}))
+-
+-        self.assertEqual({add: {3}}, diff({1, 2}, {1, 2, 3}))
+-        self.assertEqual({add: {3}, discard: {4}}, diff({1, 2, 4}, {1, 2, 3}))
+-        self.assertEqual({discard: {4}}, diff({1, 2, 4}, {1, 2}))
+-
+-        self.assertEqual({insert: [(1, 'b')]}, diff(['a', 'c'], ['a', 'b', 'c']))
+-        self.assertEqual({insert: [(1, 'b')], delete: [3, 0]}, diff(['x', 'a', 'c', 'x'], ['a', 'b', 'c']))
+-        self.assertEqual(
+-            {insert: [(2, 'b')], delete: [4, 0], 1: {'v': 20}},
+-            diff(['x', 'a', {'v': 11}, 'c', 'x'], ['a', {'v': 20}, 'b', 'c'])
+-        )
+-        self.assertEqual(
+-            {insert: [(2, 'b')], delete: [4, 0],  1: {'v': 20}},
+-            diff(['x', 'a', {'u': 10, 'v': 11}, 'c', 'x'], ['a', {'u': 10, 'v': 20}, 'b', 'c'])
+-        )
+-
+-    def test_marshal(self):
+-        differ = JsonDiffer()
+-
+-        d = {
+-            delete: 3,
+-            '$delete': 4,
+-            insert: 4,
+-            '$$something': 1
+-        }
+-
+-        dm = differ.marshal(d)
+-
+-        self.assertEqual(d, differ.unmarshal(dm))
+-
+-    def generate_scenario(self, rng):
+-        a = generate_random_json(rng, sets=True)
+-        b = perturbate_json(a, rng, sets=True)
+-        return a, b
+-
+-    def generate_scenario_no_sets(self, rng):
+-        a = generate_random_json(rng, sets=False)
+-        b = perturbate_json(a, rng, sets=False)
+-        return a, b
+-
+-    @randomize(1000, generate_scenario_no_sets)
+-    def test_dump(self, scenario):
+-        a, b = scenario
+-        diff(a, b, syntax='compact', dump=True)
+-        diff(a, b, syntax='explicit', dump=True)
+-        diff(a, b, syntax='symmetric', dump=True)
+-
+-    @randomize(1000, generate_scenario)
+-    def test_compact_syntax(self, scenario):
+-        a, b = scenario
+-        differ = JsonDiffer(syntax='compact')
+-        d = differ.diff(a, b)
+-        self.assertEqual(b, differ.patch(a, d))
+-        dm = differ.marshal(d)
+-        self.assertEqual(d, differ.unmarshal(dm))
+-
+-
+-    @randomize(1000, generate_scenario)
+-    def test_explicit_syntax(self, scenario):
+-        a, b = scenario
+-        differ = JsonDiffer(syntax='explicit')
+-        d = differ.diff(a, b)
+-        # self.assertEqual(b, differ.patch(a, d))
+-        dm = differ.marshal(d)
+-        self.assertEqual(d, differ.unmarshal(dm))
+-
+-    @randomize(1000, generate_scenario)
+-    def test_symmetric_syntax(self, scenario):
+-        a, b = scenario
+-        differ = JsonDiffer(syntax='symmetric')
+-        d = differ.diff(a, b)
+-        self.assertEqual(b, differ.patch(a, d))
+-        self.assertEqual(a, differ.unpatch(b, d))
+-        dm = differ.marshal(d)
+-        self.assertEqual(d, differ.unmarshal(dm))
+--- /dev/null
++++ b/tests/test_jsondiff.py
+@@ -0,0 +1,112 @@
++import unittest
++
++from jsondiff import diff, replace, add, discard, insert, delete, update, JsonDiffer
++from tests.utils import generate_random_json, perturbate_json
++from tests._random import randomize
++
++
++class JsonDiffTests(unittest.TestCase):
++
++    def test_a(self):
++
++        self.assertEqual({}, diff(1, 1))
++        self.assertEqual({}, diff(True, True))
++        self.assertEqual({}, diff('abc', 'abc'))
++        self.assertEqual({}, diff([1, 2], [1, 2]))
++        self.assertEqual({}, diff((1, 2), (1, 2)))
++        self.assertEqual({}, diff({1, 2}, {1, 2}))
++        self.assertEqual({}, diff({'a': 1, 'b': 2}, {'a': 1, 'b': 2}))
++        self.assertEqual({}, diff([], []))
++        self.assertEqual({}, diff(None, None))
++        self.assertEqual({}, diff({}, {}))
++        self.assertEqual({}, diff(set(), set()))
++
++        self.assertEqual(2, diff(1, 2))
++        self.assertEqual(False, diff(True, False))
++        self.assertEqual('def', diff('abc', 'def'))
++        self.assertEqual([3, 4], diff([1, 2], [3, 4]))
++        self.assertEqual((3, 4), diff((1, 2), (3, 4)))
++        self.assertEqual({3, 4}, diff({1, 2}, {3, 4}))
++        self.assertEqual({replace: {'c': 3, 'd': 4}}, diff({'a': 1, 'b': 2}, {'c': 3, 'd': 4}))
++
++        self.assertEqual({replace: {'c': 3, 'd': 4}}, diff([1, 2], {'c': 3, 'd': 4}))
++        self.assertEqual(123, diff({'a': 1, 'b': 2}, 123))
++
++        self.assertEqual({delete: ['b']}, diff({'a': 1, 'b': 2}, {'a': 1}))
++        self.assertEqual({'b': 3}, diff({'a': 1, 'b': 2}, {'a': 1, 'b': 3}))
++        self.assertEqual({'c': 3}, diff({'a': 1, 'b': 2}, {'a': 1, 'b': 2, 'c': 3}))
++        self.assertEqual({delete: ['b'], 'c': 3}, diff({'a': 1, 'b': 2}, {'a': 1, 'c': 3}))
++
++        self.assertEqual({add: {3}}, diff({1, 2}, {1, 2, 3}))
++        self.assertEqual({add: {3}, discard: {4}}, diff({1, 2, 4}, {1, 2, 3}))
++        self.assertEqual({discard: {4}}, diff({1, 2, 4}, {1, 2}))
++
++        self.assertEqual({insert: [(1, 'b')]}, diff(['a', 'c'], ['a', 'b', 'c']))
++        self.assertEqual({insert: [(1, 'b')], delete: [3, 0]}, diff(['x', 'a', 'c', 'x'], ['a', 'b', 'c']))
++        self.assertEqual(
++            {insert: [(2, 'b')], delete: [4, 0], 1: {'v': 20}},
++            diff(['x', 'a', {'v': 11}, 'c', 'x'], ['a', {'v': 20}, 'b', 'c'])
++        )
++        self.assertEqual(
++            {insert: [(2, 'b')], delete: [4, 0],  1: {'v': 20}},
++            diff(['x', 'a', {'u': 10, 'v': 11}, 'c', 'x'], ['a', {'u': 10, 'v': 20}, 'b', 'c'])
++        )
++
++    def test_marshal(self):
++        differ = JsonDiffer()
++
++        d = {
++            delete: 3,
++            '$delete': 4,
++            insert: 4,
++            '$$something': 1
++        }
++
++        dm = differ.marshal(d)
++
++        self.assertEqual(d, differ.unmarshal(dm))
++
++    def generate_scenario(self, rng):
++        a = generate_random_json(rng, sets=True)
++        b = perturbate_json(a, rng, sets=True)
++        return a, b
++
++    def generate_scenario_no_sets(self, rng):
++        a = generate_random_json(rng, sets=False)
++        b = perturbate_json(a, rng, sets=False)
++        return a, b
++
++    @randomize(1000, generate_scenario_no_sets)
++    def test_dump(self, scenario):
++        a, b = scenario
++        diff(a, b, syntax='compact', dump=True)
++        diff(a, b, syntax='explicit', dump=True)
++        diff(a, b, syntax='symmetric', dump=True)
++
++    @randomize(1000, generate_scenario)
++    def test_compact_syntax(self, scenario):
++        a, b = scenario
++        differ = JsonDiffer(syntax='compact')
++        d = differ.diff(a, b)
++        self.assertEqual(b, differ.patch(a, d))
++        dm = differ.marshal(d)
++        self.assertEqual(d, differ.unmarshal(dm))
++
++    @randomize(1000, generate_scenario)
++    def test_explicit_syntax(self, scenario):
++        a, b = scenario
++        differ = JsonDiffer(syntax='explicit')
++        d = differ.diff(a, b)
++        # self.assertEqual(b, differ.patch(a, d))
++        dm = differ.marshal(d)
++        self.assertEqual(d, differ.unmarshal(dm))
++
++    @randomize(1000, generate_scenario)
++    def test_symmetric_syntax(self, scenario):
++        a, b = scenario
++        differ = JsonDiffer(syntax='symmetric')
++        d = differ.diff(a, b)
++        self.assertEqual(b, differ.patch(a, d))
++        self.assertEqual(a, differ.unpatch(b, d))
++        dm = differ.marshal(d)
++        self.assertEqual(d, differ.unmarshal(dm))