Scrapy, a fast high-level web crawling & scraping framework for Python.
Convert tests/test_utils* to plain asserts. (#6695)
Andrey Rakhmatullind161d1d47d44
diff --git a/tests/test_utils_asyncgen.py b/tests/test_utils_asyncgen.pyindex 8adeea5c0..9b5a25b3a 100644--- a/tests/test_utils_asyncgen.py+++ b/tests/test_utils_asyncgen.py@@ -4,15 +4,15 @@ from scrapy.utils.asyncgen import as_async_generator, collect_asyncgenfrom scrapy.utils.defer import deferred_f_from_coro_f-class AsyncgenUtilsTest(unittest.TestCase):+class TestAsyncgenUtils(unittest.TestCase):@deferred_f_from_coro_fasync def test_as_async_generator(self):ag = as_async_generator(range(42))results = [i async for i in ag]- self.assertEqual(results, list(range(42)))+ assert results == list(range(42))@deferred_f_from_coro_fasync def test_collect_asyncgen(self):ag = as_async_generator(range(42))results = await collect_asyncgen(ag)- self.assertEqual(results, list(range(42)))+ assert results == list(range(42))diff --git a/tests/test_utils_asyncio.py b/tests/test_utils_asyncio.pyindex ecac0df9c..a65a36219 100644--- a/tests/test_utils_asyncio.py+++ b/tests/test_utils_asyncio.py@@ -2,7 +2,6 @@ import asyncioimport warningsimport pytest-from twisted.trial.unittest import TestCasefrom scrapy.utils.defer import deferred_f_from_coro_ffrom scrapy.utils.reactor import (@@ -13,19 +12,17 @@ from scrapy.utils.reactor import (@pytest.mark.usefixtures("reactor_pytest")-class AsyncioTest(TestCase):+class TestAsyncio:def test_is_asyncio_reactor_installed(self):# the result should depend only on the pytest --reactor argument- self.assertEqual(- is_asyncio_reactor_installed(), self.reactor_pytest == "asyncio"- )+ assert is_asyncio_reactor_installed() == (self.reactor_pytest == "asyncio")def test_install_asyncio_reactor(self):from twisted.internet import reactor as original_reactorwith warnings.catch_warnings(record=True) as w:install_reactor("twisted.internet.asyncioreactor.AsyncioSelectorReactor")- self.assertEqual(len(w), 0)+ assert len(w) == 0from twisted.internet import reactor # pylint: disable=reimportedassert original_reactor == reactordiff --git a/tests/test_utils_conf.py b/tests/test_utils_conf.pyindex e27bb7b74..26f158380 100644--- a/tests/test_utils_conf.py+++ b/tests/test_utils_conf.py@@ -1,5 +1,3 @@-import unittest-import pytestfrom scrapy.exceptions import UsageError@@ -12,26 +10,24 @@ from scrapy.utils.conf import ()-class BuildComponentListTest(unittest.TestCase):+class TestBuildComponentList:def test_build_dict(self):d = {"one": 1, "two": None, "three": 8, "four": 4}- self.assertEqual(- build_component_list(d, convert=lambda x: x), ["one", "four", "three"]- )+ assert build_component_list(d, convert=lambda x: x) == ["one", "four", "three"]def test_duplicate_components_in_basesettings(self):# Higher priority takes precedenceduplicate_bs = BaseSettings({"one": 1, "two": 2}, priority=0)duplicate_bs.set("ONE", 4, priority=10)- self.assertEqual(- build_component_list(duplicate_bs, convert=lambda x: x.lower()),- ["two", "one"],- )+ assert build_component_list(duplicate_bs, convert=lambda x: x.lower()) == [+ "two",+ "one",+ ]duplicate_bs.set("one", duplicate_bs["one"], priority=20)- self.assertEqual(- build_component_list(duplicate_bs, convert=lambda x: x.lower()),- ["one", "two"],- )+ assert build_component_list(duplicate_bs, convert=lambda x: x.lower()) == [+ "one",+ "two",+ ]# Same priority raises ValueErrorduplicate_bs.set("ONE", duplicate_bs["ONE"], priority=20)with pytest.raises(@@ -42,24 +38,24 @@ class BuildComponentListTest(unittest.TestCase):def test_valid_numbers(self):# work well with None and numeric valuesd = {"a": 10, "b": None, "c": 15, "d": 5.0}- self.assertEqual(build_component_list(d, convert=lambda x: x), ["d", "a", "c"])+ assert build_component_list(d, convert=lambda x: x) == ["d", "a", "c"]d = {"a": 33333333333333333333,"b": 11111111111111111111,"c": 22222222222222222222,}- self.assertEqual(build_component_list(d, convert=lambda x: x), ["b", "c", "a"])+ assert build_component_list(d, convert=lambda x: x) == ["b", "c", "a"]-class UtilsConfTestCase(unittest.TestCase):+class TestUtilsConf:def test_arglist_to_dict(self):- self.assertEqual(- arglist_to_dict(["arg1=val1", "arg2=val2"]),- {"arg1": "val1", "arg2": "val2"},- )+ assert arglist_to_dict(["arg1=val1", "arg2=val2"]) == {+ "arg1": "val1",+ "arg2": "val2",+ }-class FeedExportConfigTestCase(unittest.TestCase):+class TestFeedExportConfig:def test_feed_export_config_invalid_format(self):settings = Settings()with pytest.raises(UsageError):@@ -72,44 +68,36 @@ class FeedExportConfigTestCase(unittest.TestCase):def test_feed_export_config_explicit_formats(self):settings = Settings()- self.assertEqual(- {- "items_1.dat": {"format": "json"},- "items_2.dat": {"format": "xml"},- "items_3.dat": {"format": "csv"},- },- feed_process_params_from_cli(- settings, ["items_1.dat:json", "items_2.dat:xml", "items_3.dat:csv"]- ),+ assert {+ "items_1.dat": {"format": "json"},+ "items_2.dat": {"format": "xml"},+ "items_3.dat": {"format": "csv"},+ } == feed_process_params_from_cli(+ settings, ["items_1.dat:json", "items_2.dat:xml", "items_3.dat:csv"])def test_feed_export_config_implicit_formats(self):settings = Settings()- self.assertEqual(- {- "items_1.json": {"format": "json"},- "items_2.xml": {"format": "xml"},- "items_3.csv": {"format": "csv"},- },- feed_process_params_from_cli(- settings, ["items_1.json", "items_2.xml", "items_3.csv"]- ),+ assert {+ "items_1.json": {"format": "json"},+ "items_2.xml": {"format": "xml"},+ "items_3.csv": {"format": "csv"},+ } == feed_process_params_from_cli(+ settings, ["items_1.json", "items_2.xml", "items_3.csv"])def test_feed_export_config_stdout(self):settings = Settings()- self.assertEqual(- {"stdout:": {"format": "pickle"}},- feed_process_params_from_cli(settings, ["-:pickle"]),+ assert {"stdout:": {"format": "pickle"}} == feed_process_params_from_cli(+ settings, ["-:pickle"])def test_feed_export_config_overwrite(self):settings = Settings()- self.assertEqual(- {"output.json": {"format": "json", "overwrite": True}},- feed_process_params_from_cli(- settings, [], overwrite_output=["output.json"]- ),+ assert {+ "output.json": {"format": "json", "overwrite": True}+ } == feed_process_params_from_cli(+ settings, [], overwrite_output=["output.json"])def test_output_and_overwrite_output(self):@@ -131,18 +119,15 @@ class FeedExportConfigTestCase(unittest.TestCase):})new_feed = feed_complete_default_values_from_settings(feed, settings)- self.assertEqual(- new_feed,- {- "encoding": "custom encoding",- "fields": ["f1", "f2", "f3"],- "indent": 42,- "store_empty": True,- "uri_params": (1, 2, 3, 4),- "batch_item_count": 2,- "item_export_kwargs": {},- },- )+ assert new_feed == {+ "encoding": "custom encoding",+ "fields": ["f1", "f2", "f3"],+ "indent": 42,+ "store_empty": True,+ "uri_params": (1, 2, 3, 4),+ "batch_item_count": 2,+ "item_export_kwargs": {},+ }def test_feed_complete_default_values_from_settings_non_empty(self):feed = {@@ -159,15 +144,12 @@ class FeedExportConfigTestCase(unittest.TestCase):})new_feed = feed_complete_default_values_from_settings(feed, settings)- self.assertEqual(- new_feed,- {- "encoding": "other encoding",- "fields": None,- "indent": 42,- "store_empty": True,- "uri_params": None,- "batch_item_count": 2,- "item_export_kwargs": {},- },- )+ assert new_feed == {+ "encoding": "other encoding",+ "fields": None,+ "indent": 42,+ "store_empty": True,+ "uri_params": None,+ "batch_item_count": 2,+ "item_export_kwargs": {},+ }diff --git a/tests/test_utils_console.py b/tests/test_utils_console.pyindex 0bc86e1b9..6598bdce7 100644--- a/tests/test_utils_console.py+++ b/tests/test_utils_console.py@@ -1,4 +1,4 @@-import unittest+import pytestfrom scrapy.utils.console import get_shell_embed_func@@ -18,23 +18,23 @@ except ImportError:ipy = False-class UtilsConsoleTestCase(unittest.TestCase):+class TestUtilsConsole:def test_get_shell_embed_func(self):shell = get_shell_embed_func(["invalid"])- self.assertEqual(shell, None)+ assert shell is Noneshell = get_shell_embed_func(["invalid", "python"])- self.assertTrue(callable(shell))- self.assertEqual(shell.__name__, "_embed_standard_shell")+ assert callable(shell)+ assert shell.__name__ == "_embed_standard_shell"- @unittest.skipIf(not bpy, "bpython not available in testenv")+ @pytest.mark.skipif(not bpy, reason="bpython not available in testenv")def test_get_shell_embed_func2(self):shell = get_shell_embed_func(["bpython"])- self.assertTrue(callable(shell))- self.assertEqual(shell.__name__, "_embed_bpython_shell")+ assert callable(shell)+ assert shell.__name__ == "_embed_bpython_shell"- @unittest.skipIf(not ipy, "IPython not available in testenv")+ @pytest.mark.skipif(not ipy, reason="IPython not available in testenv")def test_get_shell_embed_func3(self):# default shell should be 'ipython'shell = get_shell_embed_func()- self.assertEqual(shell.__name__, "_embed_ipython_shell")+ assert shell.__name__ == "_embed_ipython_shell"diff --git a/tests/test_utils_curl.py b/tests/test_utils_curl.pyindex a5b438645..e8dd88049 100644--- a/tests/test_utils_curl.py+++ b/tests/test_utils_curl.py@@ -1,4 +1,3 @@-import unittestimport warningsimport pytest@@ -8,16 +7,16 @@ from scrapy import Requestfrom scrapy.utils.curl import curl_to_request_kwargs-class CurlToRequestKwargsTest(unittest.TestCase):+class TestCurlToRequestKwargs:maxDiff = 5000def _test_command(self, curl_command, expected_result):result = curl_to_request_kwargs(curl_command)- self.assertEqual(result, expected_result)+ assert result == expected_resulttry:Request(**result)except TypeError as e:- self.fail(f"Request kwargs are not correct {e}")+ pytest.fail(f"Request kwargs are not correct {e}")def test_get(self):curl_command = "curl http://example.org/"@@ -203,7 +202,7 @@ class CurlToRequestKwargsTest(unittest.TestCase):def test_get_silent(self):curl_command = 'curl --silent "www.example.com"'expected_result = {"method": "GET", "url": "http://www.example.com"}- self.assertEqual(curl_to_request_kwargs(curl_command), expected_result)+ assert curl_to_request_kwargs(curl_command) == expected_resultdef test_too_few_arguments_error(self):with pytest.raises(@@ -218,7 +217,7 @@ class CurlToRequestKwargsTest(unittest.TestCase):warnings.simplefilter("ignore")curl_command = "curl --bar --baz http://www.example.com"expected_result = {"method": "GET", "url": "http://www.example.com"}- self.assertEqual(curl_to_request_kwargs(curl_command), expected_result)+ assert curl_to_request_kwargs(curl_command) == expected_result# case 2: ignore_unknown_options=False (raise exception):with pytest.raises(ValueError, match="Unrecognized options:.*--bar.*--baz"):diff --git a/tests/test_utils_datatypes.py b/tests/test_utils_datatypes.pyindex 2e35d339a..75b6b0e99 100644--- a/tests/test_utils_datatypes.py+++ b/tests/test_utils_datatypes.py@@ -1,5 +1,4 @@import copy-import unittestimport warningsfrom collections.abc import Iterator, Mapping, MutableMapping@@ -17,18 +16,18 @@ from scrapy.utils.datatypes import (from scrapy.utils.python import garbage_collect-class CaseInsensitiveDictMixin:+class CaseInsensitiveDictBase:def test_init_dict(self):seq = {"red": 1, "black": 3}d = self.dict_class(seq)- self.assertEqual(d["red"], 1)- self.assertEqual(d["black"], 3)+ assert d["red"] == 1+ assert d["black"] == 3def test_init_pair_sequence(self):seq = (("red", 1), ("black", 3))d = self.dict_class(seq)- self.assertEqual(d["red"], 1)- self.assertEqual(d["black"], 3)+ assert d["red"] == 1+ assert d["black"] == 3def test_init_mapping(self):class MyMapping(Mapping):@@ -46,8 +45,8 @@ class CaseInsensitiveDictMixin:seq = MyMapping(red=1, black=3)d = self.dict_class(seq)- self.assertEqual(d["red"], 1)- self.assertEqual(d["black"], 3)+ assert d["red"] == 1+ assert d["black"] == 3def test_init_mutable_mapping(self):class MyMutableMapping(MutableMapping):@@ -71,18 +70,18 @@ class CaseInsensitiveDictMixin:seq = MyMutableMapping(red=1, black=3)d = self.dict_class(seq)- self.assertEqual(d["red"], 1)- self.assertEqual(d["black"], 3)+ assert d["red"] == 1+ assert d["black"] == 3def test_caseless(self):d = self.dict_class()d["key_Lower"] = 1- self.assertEqual(d["KEy_loWer"], 1)- self.assertEqual(d.get("KEy_loWer"), 1)+ assert d["KEy_loWer"] == 1+ assert d.get("KEy_loWer") == 1d["KEY_LOWER"] = 3- self.assertEqual(d["key_Lower"], 3)- self.assertEqual(d.get("key_Lower"), 3)+ assert d["key_Lower"] == 3+ assert d.get("key_Lower") == 3def test_delete(self):d = self.dict_class({"key_lower": 1})@@ -95,41 +94,41 @@ class CaseInsensitiveDictMixin:@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_getdefault(self):d = CaselessDict()- self.assertEqual(d.get("c", 5), 5)+ assert d.get("c", 5) == 5d["c"] = 10- self.assertEqual(d.get("c", 5), 10)+ assert d.get("c", 5) == 10@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_setdefault(self):d = CaselessDict({"a": 1, "b": 2})r = d.setdefault("A", 5)- self.assertEqual(r, 1)- self.assertEqual(d["A"], 1)+ assert r == 1+ assert d["A"] == 1r = d.setdefault("c", 5)- self.assertEqual(r, 5)- self.assertEqual(d["C"], 5)+ assert r == 5+ assert d["C"] == 5def test_fromkeys(self):keys = ("a", "b")d = self.dict_class.fromkeys(keys)- self.assertEqual(d["A"], None)- self.assertEqual(d["B"], None)+ assert d["A"] is None+ assert d["B"] is Noned = self.dict_class.fromkeys(keys, 1)- self.assertEqual(d["A"], 1)- self.assertEqual(d["B"], 1)+ assert d["A"] == 1+ assert d["B"] == 1instance = self.dict_class()d = instance.fromkeys(keys)- self.assertEqual(d["A"], None)- self.assertEqual(d["B"], None)+ assert d["A"] is None+ assert d["B"] is Noned = instance.fromkeys(keys, 1)- self.assertEqual(d["A"], 1)- self.assertEqual(d["B"], 1)+ assert d["A"] == 1+ assert d["B"] == 1def test_contains(self):d = self.dict_class()@@ -139,7 +138,7 @@ class CaseInsensitiveDictMixin:def test_pop(self):d = self.dict_class()d["a"] = 1- self.assertEqual(d.pop("A"), 1)+ assert d.pop("A") == 1with pytest.raises(KeyError):d.pop("A")@@ -152,7 +151,7 @@ class CaseInsensitiveDictMixin:d = MyDict()d["key-one"] = 2- self.assertEqual(list(d.keys()), ["Key-One"])+ assert list(d.keys()) == ["Key-One"]def test_normvalue(self):class MyDict(self.dict_class):@@ -164,62 +163,60 @@ class CaseInsensitiveDictMixin:normvalue = _normvalue # deprecated CaselessDict classd = MyDict({"key": 1})- self.assertEqual(d["key"], 2)- self.assertEqual(d.get("key"), 2)+ assert d["key"] == 2+ assert d.get("key") == 2d = MyDict()d["key"] = 1- self.assertEqual(d["key"], 2)- self.assertEqual(d.get("key"), 2)+ assert d["key"] == 2+ assert d.get("key") == 2d = MyDict()d.setdefault("key", 1)- self.assertEqual(d["key"], 2)- self.assertEqual(d.get("key"), 2)+ assert d["key"] == 2+ assert d.get("key") == 2d = MyDict()d.update({"key": 1})- self.assertEqual(d["key"], 2)- self.assertEqual(d.get("key"), 2)+ assert d["key"] == 2+ assert d.get("key") == 2d = MyDict.fromkeys(("key",), 1)- self.assertEqual(d["key"], 2)- self.assertEqual(d.get("key"), 2)+ assert d["key"] == 2+ assert d.get("key") == 2def test_copy(self):h1 = self.dict_class({"header1": "value"})h2 = copy.copy(h1)assert isinstance(h2, self.dict_class)- self.assertEqual(h1, h2)- self.assertEqual(h1.get("header1"), h2.get("header1"))- self.assertEqual(h1.get("header1"), h2.get("HEADER1"))+ assert h1 == h2+ assert h1.get("header1") == h2.get("header1")+ assert h1.get("header1") == h2.get("HEADER1")h3 = h1.copy()assert isinstance(h3, self.dict_class)- self.assertEqual(h1, h3)- self.assertEqual(h1.get("header1"), h3.get("header1"))- self.assertEqual(h1.get("header1"), h3.get("HEADER1"))+ assert h1 == h3+ assert h1.get("header1") == h3.get("header1")+ assert h1.get("header1") == h3.get("HEADER1")-class CaseInsensitiveDictTest(CaseInsensitiveDictMixin, unittest.TestCase):+class TestCaseInsensitiveDict(CaseInsensitiveDictBase):dict_class = CaseInsensitiveDictdef test_repr(self):d1 = self.dict_class({"foo": "bar"})- self.assertEqual(repr(d1), "<CaseInsensitiveDict: {'foo': 'bar'}>")+ assert repr(d1) == "<CaseInsensitiveDict: {'foo': 'bar'}>"d2 = self.dict_class({"AsDf": "QwErTy", "FoO": "bAr"})- self.assertEqual(- repr(d2), "<CaseInsensitiveDict: {'AsDf': 'QwErTy', 'FoO': 'bAr'}>"- )+ assert repr(d2) == "<CaseInsensitiveDict: {'AsDf': 'QwErTy', 'FoO': 'bAr'}>"def test_iter(self):d = self.dict_class({"AsDf": "QwErTy", "FoO": "bAr"})iterkeys = iter(d)- self.assertIsInstance(iterkeys, Iterator)- self.assertEqual(list(iterkeys), ["AsDf", "FoO"])+ assert isinstance(iterkeys, Iterator)+ assert list(iterkeys) == ["AsDf", "FoO"]@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")-class CaselessDictTest(CaseInsensitiveDictMixin, unittest.TestCase):+class TestCaselessDict(CaseInsensitiveDictBase):dict_class = CaselessDictdef test_deprecation_message(self):@@ -227,93 +224,93 @@ class CaselessDictTest(CaseInsensitiveDictMixin, unittest.TestCase):warnings.filterwarnings("always", category=ScrapyDeprecationWarning)self.dict_class({"foo": "bar"})- self.assertEqual(len(caught), 1)- self.assertTrue(issubclass(caught[0].category, ScrapyDeprecationWarning))- self.assertEqual(- "scrapy.utils.datatypes.CaselessDict is deprecated,"- " please use scrapy.utils.datatypes.CaseInsensitiveDict instead",- str(caught[0].message),+ assert len(caught) == 1+ assert issubclass(caught[0].category, ScrapyDeprecationWarning)+ assert (+ str(caught[0].message)+ == "scrapy.utils.datatypes.CaselessDict is deprecated,"+ " please use scrapy.utils.datatypes.CaseInsensitiveDict instead")-class SequenceExcludeTest(unittest.TestCase):+class TestSequenceExclude:def test_list(self):seq = [1, 2, 3]d = SequenceExclude(seq)- self.assertIn(0, d)- self.assertIn(4, d)- self.assertNotIn(2, d)+ assert 0 in d+ assert 4 in d+ assert 2 not in ddef test_range(self):seq = range(10, 20)d = SequenceExclude(seq)- self.assertIn(5, d)- self.assertIn(20, d)- self.assertNotIn(15, d)+ assert 5 in d+ assert 20 in d+ assert 15 not in ddef test_range_step(self):seq = range(10, 20, 3)d = SequenceExclude(seq)are_not_in = [v for v in range(10, 20, 3) if v in d]- self.assertEqual([], are_not_in)+ assert are_not_in == []are_not_in = [v for v in range(10, 20) if v in d]- self.assertEqual([11, 12, 14, 15, 17, 18], are_not_in)+ assert are_not_in == [11, 12, 14, 15, 17, 18]def test_string_seq(self):seq = "cde"d = SequenceExclude(seq)chars = "".join(v for v in "abcdefg" if v in d)- self.assertEqual("abfg", chars)+ assert chars == "abfg"def test_stringset_seq(self):seq = set("cde")d = SequenceExclude(seq)chars = "".join(v for v in "abcdefg" if v in d)- self.assertEqual("abfg", chars)+ assert chars == "abfg"def test_set(self):"""Anything that is not in the supplied sequence will evaluate as 'in' the container."""seq = {-3, "test", 1.1}d = SequenceExclude(seq)- self.assertIn(0, d)- self.assertIn("foo", d)- self.assertIn(3.14, d)- self.assertIn(set("bar"), d)+ assert 0 in d+ assert "foo" in d+ assert 3.14 in d+ assert set("bar") in d# supplied sequence is a set, so checking for list (non)inclusion failswith pytest.raises(TypeError):["a", "b", "c"] in d # noqa: B015for v in [-3, "test", 1.1]:- self.assertNotIn(v, d)+ assert v not in d-class LocalCacheTest(unittest.TestCase):+class TestLocalCache:def test_cache_with_limit(self):cache = LocalCache(limit=2)cache["a"] = 1cache["b"] = 2cache["c"] = 3- self.assertEqual(len(cache), 2)- self.assertNotIn("a", cache)- self.assertIn("b", cache)- self.assertIn("c", cache)- self.assertEqual(cache["b"], 2)- self.assertEqual(cache["c"], 3)+ assert len(cache) == 2+ assert "a" not in cache+ assert "b" in cache+ assert "c" in cache+ assert cache["b"] == 2+ assert cache["c"] == 3def test_cache_without_limit(self):maximum = 10**4cache = LocalCache()for x in range(maximum):cache[str(x)] = x- self.assertEqual(len(cache), maximum)+ assert len(cache) == maximumfor x in range(maximum):- self.assertIn(str(x), cache)- self.assertEqual(cache[str(x)], x)+ assert str(x) in cache+ assert cache[str(x)] == x-class LocalWeakReferencedCacheTest(unittest.TestCase):+class TestLocalWeakReferencedCache:def test_cache_with_limit(self):cache = LocalWeakReferencedCache(limit=2)r1 = Request("https://example.org")@@ -322,19 +319,19 @@ class LocalWeakReferencedCacheTest(unittest.TestCase):cache[r1] = 1cache[r2] = 2cache[r3] = 3- self.assertEqual(len(cache), 2)- self.assertNotIn(r1, cache)- self.assertIn(r2, cache)- self.assertIn(r3, cache)- self.assertEqual(cache[r1], None)- self.assertEqual(cache[r2], 2)- self.assertEqual(cache[r3], 3)+ assert len(cache) == 2+ assert r1 not in cache+ assert r2 in cache+ assert r3 in cache+ assert cache[r1] is None+ assert cache[r2] == 2+ assert cache[r3] == 3del r2# PyPy takes longer to collect dead referencesgarbage_collect()- self.assertEqual(len(cache), 1)+ assert len(cache) == 1def test_cache_non_weak_referenceable_objects(self):cache = LocalWeakReferencedCache()@@ -344,10 +341,10 @@ class LocalWeakReferencedCacheTest(unittest.TestCase):cache[k1] = 1cache[k2] = 2cache[k3] = 3- self.assertNotIn(k1, cache)- self.assertNotIn(k2, cache)- self.assertNotIn(k3, cache)- self.assertEqual(len(cache), 0)+ assert k1 not in cache+ assert k2 not in cache+ assert k3 not in cache+ assert len(cache) == 0def test_cache_without_limit(self):max = 10**4@@ -356,10 +353,10 @@ class LocalWeakReferencedCacheTest(unittest.TestCase):for x in range(max):refs.append(Request(f"https://example.org/{x}"))cache[refs[-1]] = x- self.assertEqual(len(cache), max)+ assert len(cache) == maxfor i, r in enumerate(refs):- self.assertIn(r, cache)- self.assertEqual(cache[r], i)+ assert r in cache+ assert cache[r] == idel r # delete reference to the last object in the list # pylint: disable=undefined-loop-variable# delete half of the objects, make sure that is reflected in the cache@@ -369,7 +366,7 @@ class LocalWeakReferencedCacheTest(unittest.TestCase):# PyPy takes longer to collect dead referencesgarbage_collect()- self.assertEqual(len(cache), max // 2)+ assert len(cache) == max // 2for i, r in enumerate(refs):- self.assertIn(r, cache)- self.assertEqual(cache[r], i)+ assert r in cache+ assert cache[r] == idiff --git a/tests/test_utils_defer.py b/tests/test_utils_defer.pyindex 3a1030fcf..36bd8ced9 100644--- a/tests/test_utils_defer.py+++ b/tests/test_utils_defer.py@@ -18,7 +18,7 @@ from scrapy.utils.defer import ()-class MustbeDeferredTest(unittest.TestCase):+class TestMustbeDeferred(unittest.TestCase):def test_success_function(self):steps = []@@ -66,23 +66,19 @@ def eb1(failure, arg1, arg2):return f"(eb1 {failure.value.__class__.__name__} {arg1} {arg2})"-class DeferUtilsTest(unittest.TestCase):+class TestDeferUtils(unittest.TestCase):@defer.inlineCallbacksdef test_process_chain(self):x = yield process_chain([cb1, cb2, cb3], "res", "v1", "v2")- self.assertEqual(x, "(cb3 (cb2 (cb1 res v1 v2) v1 v2) v1 v2)")+ assert x == "(cb3 (cb2 (cb1 res v1 v2) v1 v2) v1 v2)"- gotexc = False- try:+ with pytest.raises(TypeError):yield process_chain([cb1, cb_fail, cb3], "res", "v1", "v2")- except TypeError:- gotexc = True- self.assertTrue(gotexc)@defer.inlineCallbacksdef test_process_parallel(self):x = yield process_parallel([cb1, cb2, cb3], "res", "v1", "v2")- self.assertEqual(x, ["(cb1 res v1 v2)", "(cb2 res v1 v2)", "(cb3 res v1 v2)"])+ assert x == ["(cb1 res v1 v2)", "(cb2 res v1 v2)", "(cb3 res v1 v2)"]def test_process_parallel_failure(self):d = process_parallel([cb1, cb_fail, cb3], "res", "v1", "v2")@@ -90,15 +86,15 @@ class DeferUtilsTest(unittest.TestCase):return d-class IterErrbackTest(unittest.TestCase):+class TestIterErrback:def test_iter_errback_good(self):def itergood():yield from range(10)errors = []out = list(iter_errback(itergood(), errors.append))- self.assertEqual(out, list(range(10)))- self.assertFalse(errors)+ assert out == list(range(10))+ assert not errorsdef test_iter_errback_bad(self):def iterbad():@@ -109,12 +105,12 @@ class IterErrbackTest(unittest.TestCase):errors = []out = list(iter_errback(iterbad(), errors.append))- self.assertEqual(out, [0, 1, 2, 3, 4])- self.assertEqual(len(errors), 1)- self.assertIsInstance(errors[0].value, ZeroDivisionError)+ assert out == [0, 1, 2, 3, 4]+ assert len(errors) == 1+ assert isinstance(errors[0].value, ZeroDivisionError)-class AiterErrbackTest(unittest.TestCase):+class TestAiterErrback(unittest.TestCase):@deferred_f_from_coro_fasync def test_aiter_errback_good(self):async def itergood():@@ -123,8 +119,8 @@ class AiterErrbackTest(unittest.TestCase):errors = []out = await collect_asyncgen(aiter_errback(itergood(), errors.append))- self.assertEqual(out, list(range(10)))- self.assertFalse(errors)+ assert out == list(range(10))+ assert not errors@deferred_f_from_coro_fasync def test_iter_errback_bad(self):@@ -136,12 +132,12 @@ class AiterErrbackTest(unittest.TestCase):errors = []out = await collect_asyncgen(aiter_errback(iterbad(), errors.append))- self.assertEqual(out, [0, 1, 2, 3, 4])- self.assertEqual(len(errors), 1)- self.assertIsInstance(errors[0].value, ZeroDivisionError)+ assert out == [0, 1, 2, 3, 4]+ assert len(errors) == 1+ assert isinstance(errors[0].value, ZeroDivisionError)-class AsyncDefTestsuiteTest(unittest.TestCase):+class TestAsyncDefTestsuite(unittest.TestCase):@deferred_f_from_coro_fasync def test_deferred_f_from_coro_f(self):pass@@ -156,7 +152,7 @@ class AsyncDefTestsuiteTest(unittest.TestCase):raise RuntimeError("This is expected to be raised")-class AsyncCooperatorTest(unittest.TestCase):+class TestAsyncCooperator(unittest.TestCase):"""This tests _AsyncCooperatorAdapter by testing parallel_async which is its only usage.parallel_async is called with the results of a callback (so an iterable of items, requests and None,@@ -207,7 +203,7 @@ class AsyncCooperatorTest(unittest.TestCase):ait = self.get_async_iterable(length)dl = parallel_async(ait, self.CONCURRENT_ITEMS, self.callable, results)yield dl- self.assertEqual(list(range(length)), sorted(results))+ assert list(range(length)) == sorted(results)@defer.inlineCallbacksdef test_delays(self):@@ -216,4 +212,4 @@ class AsyncCooperatorTest(unittest.TestCase):ait = self.get_async_iterable_with_delays(length)dl = parallel_async(ait, self.CONCURRENT_ITEMS, self.callable, results)yield dl- self.assertEqual(list(range(length)), sorted(results))+ assert list(range(length)) == sorted(results)diff --git a/tests/test_utils_deprecate.py b/tests/test_utils_deprecate.pyindex e917b6947..52c165bb4 100644--- a/tests/test_utils_deprecate.py+++ b/tests/test_utils_deprecate.py@@ -1,5 +1,4 @@import inspect-import unittestimport warningsfrom unittest import mock@@ -21,7 +20,7 @@ class NewName(SomeBaseClass):pass-class WarnWhenSubclassedTest(unittest.TestCase):+class TestWarnWhenSubclassed:def _mywarnings(self, w, category=MyWarning):return [x for x in w if x.category is MyWarning]@@ -30,7 +29,7 @@ class WarnWhenSubclassedTest(unittest.TestCase):create_deprecated_class("Deprecated", NewName)w = self._mywarnings(w)- self.assertEqual(w, [])+ assert w == []def test_subclassing_warning_message(self):Deprecated = create_deprecated_class(@@ -43,15 +42,14 @@ class WarnWhenSubclassedTest(unittest.TestCase):passw = self._mywarnings(w)- self.assertEqual(len(w), 1)- self.assertEqual(- str(w[0].message),- "tests.test_utils_deprecate.UserClass inherits from "+ assert len(w) == 1+ assert (+ str(w[0].message) == "tests.test_utils_deprecate.UserClass inherits from ""deprecated class tests.test_utils_deprecate.Deprecated, ""please inherit from tests.test_utils_deprecate.NewName."- " (warning only on first subclass, there may be others)",+ " (warning only on first subclass, there may be others)")- self.assertEqual(w[0].lineno, inspect.getsourcelines(UserClass)[1])+ assert w[0].lineno == inspect.getsourcelines(UserClass)[1]def test_custom_class_paths(self):Deprecated = create_deprecated_class(@@ -70,11 +68,11 @@ class WarnWhenSubclassedTest(unittest.TestCase):_ = Deprecated()w = self._mywarnings(w)- self.assertEqual(len(w), 2)- self.assertIn("foo.NewClass", str(w[0].message))- self.assertIn("bar.OldClass", str(w[0].message))- self.assertIn("foo.NewClass", str(w[1].message))- self.assertIn("bar.OldClass", str(w[1].message))+ assert len(w) == 2+ assert "foo.NewClass" in str(w[0].message)+ assert "bar.OldClass" in str(w[0].message)+ assert "foo.NewClass" in str(w[1].message)+ assert "bar.OldClass" in str(w[1].message)def test_subclassing_warns_only_on_direct_children(self):Deprecated = create_deprecated_class(@@ -90,8 +88,8 @@ class WarnWhenSubclassedTest(unittest.TestCase):passw = self._mywarnings(w)- self.assertEqual(len(w), 1)- self.assertIn("UserClass", str(w[0].message))+ assert len(w) == 1+ assert "UserClass" in str(w[0].message)def test_subclassing_warns_once_by_default(self):Deprecated = create_deprecated_class(@@ -110,8 +108,8 @@ class WarnWhenSubclassedTest(unittest.TestCase):passw = self._mywarnings(w)- self.assertEqual(len(w), 1)- self.assertIn("UserClass", str(w[0].message))+ assert len(w) == 1+ assert "UserClass" in str(w[0].message)def test_warning_on_instance(self):Deprecated = create_deprecated_class(@@ -130,13 +128,12 @@ class WarnWhenSubclassedTest(unittest.TestCase):_ = UserClass() # subclass instances don't warnw = self._mywarnings(w)- self.assertEqual(len(w), 1)- self.assertEqual(- str(w[0].message),- "tests.test_utils_deprecate.Deprecated is deprecated, "- "instantiate tests.test_utils_deprecate.NewName instead.",+ assert len(w) == 1+ assert (+ str(w[0].message) == "tests.test_utils_deprecate.Deprecated is deprecated, "+ "instantiate tests.test_utils_deprecate.NewName instead.")- self.assertEqual(w[0].lineno, lineno)+ assert w[0].lineno == linenodef test_warning_auto_message(self):with warnings.catch_warnings(record=True) as w:@@ -146,8 +143,8 @@ class WarnWhenSubclassedTest(unittest.TestCase):passmsg = str(w[0].message)- self.assertIn("tests.test_utils_deprecate.NewName", msg)- self.assertIn("tests.test_utils_deprecate.Deprecated", msg)+ assert "tests.test_utils_deprecate.NewName" in msg+ assert "tests.test_utils_deprecate.Deprecated" in msgdef test_issubclass(self):with warnings.catch_warnings():@@ -225,7 +222,7 @@ class WarnWhenSubclassedTest(unittest.TestCase):warnings.simplefilter("ignore", ScrapyDeprecationWarning)Deprecated = create_deprecated_class("Deprecated", NewName, {"foo": "bar"})- self.assertEqual(Deprecated.foo, "bar")+ assert Deprecated.foo == "bar"def test_deprecate_a_class_with_custom_metaclass(self):Meta1 = type("Meta1", (type,), {})@@ -246,7 +243,7 @@ class WarnWhenSubclassedTest(unittest.TestCase):)w = self._mywarnings(w)- self.assertEqual(len(w), 0, str(map(str, w)))+ assert len(w) == 0, str(map(str, w))with warnings.catch_warnings(record=True) as w:AlsoDeprecated()@@ -255,11 +252,11 @@ class WarnWhenSubclassedTest(unittest.TestCase):passw = self._mywarnings(w)- self.assertEqual(len(w), 2)- self.assertIn("AlsoDeprecated", str(w[0].message))- self.assertIn("foo.Bar", str(w[0].message))- self.assertIn("AlsoDeprecated", str(w[1].message))- self.assertIn("foo.Bar", str(w[1].message))+ assert len(w) == 2+ assert "AlsoDeprecated" in str(w[0].message)+ assert "foo.Bar" in str(w[0].message)+ assert "AlsoDeprecated" in str(w[1].message)+ assert "foo.Bar" in str(w[1].message)def test_inspect_stack(self):with (@@ -271,7 +268,7 @@ class WarnWhenSubclassedTest(unittest.TestCase):class SubClass(DeprecatedName):pass- self.assertIn("Error detecting parent module", str(w[0].message))+ assert "Error detecting parent module" in str(w[0].message)@mock.patch(@@ -281,27 +278,27 @@ class WarnWhenSubclassedTest(unittest.TestCase):("scrapy.contrib.", "scrapy.extensions."),],)-class UpdateClassPathTest(unittest.TestCase):+class TestUpdateClassPath:def test_old_path_gets_fixed(self):with warnings.catch_warnings(record=True) as w:output = update_classpath("scrapy.contrib.debug.Debug")- self.assertEqual(output, "scrapy.extensions.debug.Debug")- self.assertEqual(len(w), 1)- self.assertIn("scrapy.contrib.debug.Debug", str(w[0].message))- self.assertIn("scrapy.extensions.debug.Debug", str(w[0].message))+ assert output == "scrapy.extensions.debug.Debug"+ assert len(w) == 1+ assert "scrapy.contrib.debug.Debug" in str(w[0].message)+ assert "scrapy.extensions.debug.Debug" in str(w[0].message)def test_sorted_replacement(self):with warnings.catch_warnings():warnings.simplefilter("ignore", ScrapyDeprecationWarning)output = update_classpath("scrapy.contrib.pipeline.Pipeline")- self.assertEqual(output, "scrapy.pipelines.Pipeline")+ assert output == "scrapy.pipelines.Pipeline"def test_unmatched_path_stays_the_same(self):with warnings.catch_warnings(record=True) as w:output = update_classpath("scrapy.unmatched.Path")- self.assertEqual(output, "scrapy.unmatched.Path")- self.assertEqual(len(w), 0)+ assert output == "scrapy.unmatched.Path"+ assert len(w) == 0def test_returns_nonstring(self):for notastring in [None, True, [1, 2, 3], object()]:- self.assertEqual(update_classpath(notastring), notastring)+ assert update_classpath(notastring) == notastringdiff --git a/tests/test_utils_display.py b/tests/test_utils_display.pyindex d1bf64828..cea564653 100644--- a/tests/test_utils_display.py+++ b/tests/test_utils_display.py@@ -1,10 +1,10 @@from io import StringIO-from unittest import TestCase, mock+from unittest import mockfrom scrapy.utils.display import pformat, pprint-class TestDisplay(TestCase):+class TestDisplay:object = {"a": 1}colorized_strings = {(@@ -26,15 +26,15 @@ class TestDisplay(TestCase):@mock.patch("sys.stdout.isatty")def test_pformat(self, isatty):isatty.return_value = True- self.assertIn(pformat(self.object), self.colorized_strings)+ assert pformat(self.object) in self.colorized_strings@mock.patch("sys.stdout.isatty")def test_pformat_dont_colorize(self, isatty):isatty.return_value = True- self.assertEqual(pformat(self.object, colorize=False), self.plain_string)+ assert pformat(self.object, colorize=False) == self.plain_stringdef test_pformat_not_tty(self):- self.assertEqual(pformat(self.object), self.plain_string)+ assert pformat(self.object) == self.plain_string@mock.patch("sys.platform", "win32")@mock.patch("platform.version")@@ -42,7 +42,7 @@ class TestDisplay(TestCase):def test_pformat_old_windows(self, isatty, version):isatty.return_value = Trueversion.return_value = "10.0.14392"- self.assertIn(pformat(self.object), self.colorized_strings)+ assert pformat(self.object) in self.colorized_strings@mock.patch("sys.platform", "win32")@mock.patch("scrapy.utils.display._enable_windows_terminal_processing")@@ -54,7 +54,7 @@ class TestDisplay(TestCase):isatty.return_value = Trueversion.return_value = "10.0.14393"terminal_processing.return_value = False- self.assertEqual(pformat(self.object), self.plain_string)+ assert pformat(self.object) == self.plain_string@mock.patch("sys.platform", "win32")@mock.patch("scrapy.utils.display._enable_windows_terminal_processing")@@ -64,7 +64,7 @@ class TestDisplay(TestCase):isatty.return_value = Trueversion.return_value = "10.0.14393"terminal_processing.return_value = True- self.assertIn(pformat(self.object), self.colorized_strings)+ assert pformat(self.object) in self.colorized_strings@mock.patch("sys.platform", "linux")@mock.patch("sys.stdout.isatty")@@ -81,10 +81,10 @@ class TestDisplay(TestCase):return real_import(name, globals, locals, fromlist, level)builtins.__import__ = mock_import- self.assertEqual(pformat(self.object), self.plain_string)+ assert pformat(self.object) == self.plain_stringbuiltins.__import__ = real_importdef test_pprint(self):with mock.patch("sys.stdout", new=StringIO()) as mock_out:pprint(self.object)- self.assertEqual(mock_out.getvalue(), "{'a': 1}\n")+ assert mock_out.getvalue() == "{'a': 1}\n"diff --git a/tests/test_utils_gz.py b/tests/test_utils_gz.pyindex d40cae9c7..c43ed152b 100644--- a/tests/test_utils_gz.py+++ b/tests/test_utils_gz.py@@ -1,4 +1,3 @@-import unittestfrom gzip import BadGzipFilefrom pathlib import Path@@ -12,17 +11,17 @@ from tests import tests_datadirSAMPLEDIR = Path(tests_datadir, "compressed")-class GunzipTest(unittest.TestCase):+class TestGunzip:def test_gunzip_basic(self):r1 = Response("http://www.example.com",body=(SAMPLEDIR / "feed-sample1.xml.gz").read_bytes(),)- self.assertTrue(gzip_magic_number(r1))+ assert gzip_magic_number(r1)r2 = Response("http://www.example.com", body=gunzip(r1.body))- self.assertFalse(gzip_magic_number(r2))- self.assertEqual(len(r2.body), 9950)+ assert not gzip_magic_number(r2)+ assert len(r2.body) == 9950def test_gunzip_truncated(self):text = gunzip((SAMPLEDIR / "truncated-crc-error.gz").read_bytes())@@ -37,15 +36,15 @@ class GunzipTest(unittest.TestCase):"http://www.example.com",body=(SAMPLEDIR / "truncated-crc-error-short.gz").read_bytes(),)- self.assertTrue(gzip_magic_number(r1))+ assert gzip_magic_number(r1)r2 = Response("http://www.example.com", body=gunzip(r1.body))assert r2.body.endswith(b"</html>")- self.assertFalse(gzip_magic_number(r2))+ assert not gzip_magic_number(r2)def test_is_gzipped_empty(self):r1 = Response("http://www.example.com")- self.assertFalse(gzip_magic_number(r1))+ assert not gzip_magic_number(r1)def test_gunzip_illegal_eof(self):text = html_to_unicode(@@ -54,5 +53,5 @@ class GunzipTest(unittest.TestCase):expected_text = (SAMPLEDIR / "unexpected-eof-output.txt").read_text(encoding="utf-8")- self.assertEqual(len(text), len(expected_text))- self.assertEqual(text, expected_text)+ assert len(text) == len(expected_text)+ assert text == expected_textdiff --git a/tests/test_utils_httpobj.py b/tests/test_utils_httpobj.pyindex 741e69559..0c05ef7d6 100644--- a/tests/test_utils_httpobj.py+++ b/tests/test_utils_httpobj.py@@ -1,11 +1,10 @@-import unittestfrom urllib.parse import urlparsefrom scrapy.http import Requestfrom scrapy.utils.httpobj import urlparse_cached-class HttpobjUtilsTest(unittest.TestCase):+class TestHttpobjUtils:def test_urlparse_cached(self):url = "http://www.example.com/index.html"request1 = Request(url)diff --git a/tests/test_utils_iterators.py b/tests/test_utils_iterators.pyindex 9ad30617a..fa0d37866 100644--- a/tests/test_utils_iterators.py+++ b/tests/test_utils_iterators.py@@ -1,5 +1,4 @@import pytest-from twisted.trial import unittestfrom scrapy.exceptions import ScrapyDeprecationWarningfrom scrapy.http import Response, TextResponse, XmlResponse@@ -7,7 +6,7 @@ from scrapy.utils.iterators import _body_or_str, csviter, xmliter, xmliter_lxmlfrom tests import get_testdata-class XmliterBaseTestCase:+class XmliterBase:@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_xmliter(self):body = b"""@@ -35,9 +34,10 @@ class XmliterBaseTestCase:for x in self.xmliter(response, "product")]- self.assertEqual(- attrs, [("001", ["Name 1"], ["Type 1"]), ("002", ["Name 2"], ["Type 2"])]- )+ assert attrs == [+ ("001", ["Name 1"], ["Type 1"]),+ ("002", ["Name 2"], ["Type 2"]),+ ]@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_xmliter_unusual_node(self):@@ -51,7 +51,7 @@ class XmliterBaseTestCase:nodenames = [e.xpath("name()").getall() for e in self.xmliter(response, "matchme...")]- self.assertEqual(nodenames, [["matchme..."]])+ assert nodenames == [["matchme..."]]@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_xmliter_unicode(self):@@ -107,10 +107,11 @@ class XmliterBaseTestCase:for x in self.xmliter(r, "þingflokkur")]- self.assertEqual(- attrs,- [("26", ["-"], ["80"]), ("21", ["Ab"], ["76"]), ("27", ["A"], ["27"])],- )+ assert attrs == [+ ("26", ["-"], ["80"]),+ ("21", ["Ab"], ["76"]),+ ("27", ["A"], ["27"]),+ ]@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_xmliter_text(self):@@ -119,10 +120,10 @@ class XmliterBaseTestCase:"<products><product>one</product><product>two</product></products>")- self.assertEqual(- [x.xpath("text()").getall() for x in self.xmliter(body, "product")],- [["one"], ["two"]],- )+ assert [x.xpath("text()").getall() for x in self.xmliter(body, "product")] == [+ ["one"],+ ["two"],+ ]@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_xmliter_namespaces(self):@@ -148,21 +149,19 @@ class XmliterBaseTestCase:my_iter = self.xmliter(response, "item")node = next(my_iter)node.register_namespace("g", "http://base.google.com/ns/1.0")- self.assertEqual(node.xpath("title/text()").getall(), ["Item 1"])- self.assertEqual(node.xpath("description/text()").getall(), ["This is item 1"])- self.assertEqual(- node.xpath("link/text()").getall(),- ["http://www.mydummycompany.com/items/1"],- )- self.assertEqual(- node.xpath("g:image_link/text()").getall(),- ["http://www.mydummycompany.com/images/item1.jpg"],- )- self.assertEqual(node.xpath("g:id/text()").getall(), ["ITEM_1"])- self.assertEqual(node.xpath("g:price/text()").getall(), ["400"])- self.assertEqual(node.xpath("image_link/text()").getall(), [])- self.assertEqual(node.xpath("id/text()").getall(), [])- self.assertEqual(node.xpath("price/text()").getall(), [])+ assert node.xpath("title/text()").getall() == ["Item 1"]+ assert node.xpath("description/text()").getall() == ["This is item 1"]+ assert node.xpath("link/text()").getall() == [+ "http://www.mydummycompany.com/items/1"+ ]+ assert node.xpath("g:image_link/text()").getall() == [+ "http://www.mydummycompany.com/images/item1.jpg"+ ]+ assert node.xpath("g:id/text()").getall() == ["ITEM_1"]+ assert node.xpath("g:price/text()").getall() == ["400"]+ assert node.xpath("image_link/text()").getall() == []+ assert node.xpath("id/text()").getall() == []+ assert node.xpath("price/text()").getall() == []@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_xmliter_namespaced_nodename(self):@@ -188,10 +187,9 @@ class XmliterBaseTestCase:my_iter = self.xmliter(response, "g:image_link")node = next(my_iter)node.register_namespace("g", "http://base.google.com/ns/1.0")- self.assertEqual(- node.xpath("text()").extract(),- ["http://www.mydummycompany.com/images/item1.jpg"],- )+ assert node.xpath("text()").extract() == [+ "http://www.mydummycompany.com/images/item1.jpg"+ ]@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_xmliter_namespaced_nodename_missing(self):@@ -246,13 +244,13 @@ class XmliterBaseTestCase:b"</xml>\n\n")response = XmlResponse("http://www.example.com", body=body)- self.assertEqual(- next(self.xmliter(response, "item")).get(),- "<item>Some Turkish Characters \xd6\xc7\u015e\u0130\u011e\xdc \xfc\u011f\u0131\u015f\xe7\xf6</item>",+ assert (+ next(self.xmliter(response, "item")).get()+ == "<item>Some Turkish Characters \xd6\xc7\u015e\u0130\u011e\xdc \xfc\u011f\u0131\u015f\xe7\xf6</item>")-class XmliterTestCase(XmliterBaseTestCase, unittest.TestCase):+class TestXmliter(XmliterBase):xmliter = staticmethod(xmliter)def test_deprecation(self):@@ -269,7 +267,7 @@ class XmliterTestCase(XmliterBaseTestCase, unittest.TestCase):next(self.xmliter(body, "product"))-class LxmlXmliterTestCase(XmliterBaseTestCase, unittest.TestCase):+class TestLxmlXmliter(XmliterBase):xmliter = staticmethod(xmliter_lxml)def test_xmliter_iterate_namespace(self):@@ -293,21 +291,19 @@ class LxmlXmliterTestCase(XmliterBaseTestCase, unittest.TestCase):response = XmlResponse(url="http://mydummycompany.com", body=body)no_namespace_iter = self.xmliter(response, "image_link")- self.assertEqual(len(list(no_namespace_iter)), 0)+ assert len(list(no_namespace_iter)) == 0namespace_iter = self.xmliter(response, "image_link", "http://base.google.com/ns/1.0")node = next(namespace_iter)- self.assertEqual(- node.xpath("text()").getall(),- ["http://www.mydummycompany.com/images/item1.jpg"],- )+ assert node.xpath("text()").getall() == [+ "http://www.mydummycompany.com/images/item1.jpg"+ ]node = next(namespace_iter)- self.assertEqual(- node.xpath("text()").getall(),- ["http://www.mydummycompany.com/images/item2.jpg"],- )+ assert node.xpath("text()").getall() == [+ "http://www.mydummycompany.com/images/item2.jpg"+ ]def test_xmliter_namespaces_prefix(self):body = b"""@@ -332,16 +328,16 @@ class LxmlXmliterTestCase(XmliterBaseTestCase, unittest.TestCase):my_iter = self.xmliter(response, "table", "http://www.w3.org/TR/html4/", "h")node = next(my_iter)- self.assertEqual(len(node.xpath("h:tr/h:td").getall()), 2)- self.assertEqual(node.xpath("h:tr/h:td[1]/text()").getall(), ["Apples"])- self.assertEqual(node.xpath("h:tr/h:td[2]/text()").getall(), ["Bananas"])+ assert len(node.xpath("h:tr/h:td").getall()) == 2+ assert node.xpath("h:tr/h:td[1]/text()").getall() == ["Apples"]+ assert node.xpath("h:tr/h:td[2]/text()").getall() == ["Bananas"]my_iter = self.xmliter(response, "table", "http://www.w3schools.com/furniture", "f")node = next(my_iter)- self.assertEqual(node.xpath("f:name/text()").getall(), ["African Coffee Table"])+ assert node.xpath("f:name/text()").getall() == ["African Coffee Table"]def test_xmliter_objtype_exception(self):i = self.xmliter(42, "product")@@ -349,42 +345,36 @@ class LxmlXmliterTestCase(XmliterBaseTestCase, unittest.TestCase):next(i)-class UtilsCsvTestCase(unittest.TestCase):+class TestUtilsCsv:def test_csviter_defaults(self):body = get_testdata("feeds", "feed-sample3.csv")response = TextResponse(url="http://example.com/", body=body)csv = csviter(response)result = list(csv)- self.assertEqual(- result,- [- {"id": "1", "name": "alpha", "value": "foobar"},- {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},- {"id": "3", "name": "multi", "value": "foo\nbar"},- {"id": "4", "name": "empty", "value": ""},- ],- )+ assert result == [+ {"id": "1", "name": "alpha", "value": "foobar"},+ {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},+ {"id": "3", "name": "multi", "value": "foo\nbar"},+ {"id": "4", "name": "empty", "value": ""},+ ]# explicit type check cuz' we no like stinkin' autocasting! yarrrfor result_row in result:- self.assertTrue(all(isinstance(k, str) for k in result_row))- self.assertTrue(all(isinstance(v, str) for v in result_row.values()))+ assert all(isinstance(k, str) for k in result_row)+ assert all(isinstance(v, str) for v in result_row.values())def test_csviter_delimiter(self):body = get_testdata("feeds", "feed-sample3.csv").replace(b",", b"\t")response = TextResponse(url="http://example.com/", body=body)csv = csviter(response, delimiter="\t")- self.assertEqual(- list(csv),- [- {"id": "1", "name": "alpha", "value": "foobar"},- {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},- {"id": "3", "name": "multi", "value": "foo\nbar"},- {"id": "4", "name": "empty", "value": ""},- ],- )+ assert list(csv) == [+ {"id": "1", "name": "alpha", "value": "foobar"},+ {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},+ {"id": "3", "name": "multi", "value": "foo\nbar"},+ {"id": "4", "name": "empty", "value": ""},+ ]def test_csviter_quotechar(self):body1 = get_testdata("feeds", "feed-sample6.csv")@@ -393,62 +383,50 @@ class UtilsCsvTestCase(unittest.TestCase):response1 = TextResponse(url="http://example.com/", body=body1)csv1 = csviter(response1, quotechar="'")- self.assertEqual(- list(csv1),- [- {"id": "1", "name": "alpha", "value": "foobar"},- {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},- {"id": "3", "name": "multi", "value": "foo\nbar"},- {"id": "4", "name": "empty", "value": ""},- ],- )+ assert list(csv1) == [+ {"id": "1", "name": "alpha", "value": "foobar"},+ {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},+ {"id": "3", "name": "multi", "value": "foo\nbar"},+ {"id": "4", "name": "empty", "value": ""},+ ]response2 = TextResponse(url="http://example.com/", body=body2)csv2 = csviter(response2, delimiter="|", quotechar="'")- self.assertEqual(- list(csv2),- [- {"id": "1", "name": "alpha", "value": "foobar"},- {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},- {"id": "3", "name": "multi", "value": "foo\nbar"},- {"id": "4", "name": "empty", "value": ""},- ],- )+ assert list(csv2) == [+ {"id": "1", "name": "alpha", "value": "foobar"},+ {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},+ {"id": "3", "name": "multi", "value": "foo\nbar"},+ {"id": "4", "name": "empty", "value": ""},+ ]def test_csviter_wrong_quotechar(self):body = get_testdata("feeds", "feed-sample6.csv")response = TextResponse(url="http://example.com/", body=body)csv = csviter(response)- self.assertEqual(- list(csv),- [- {"'id'": "1", "'name'": "'alpha'", "'value'": "'foobar'"},- {- "'id'": "2",- "'name'": "'unicode'",- "'value'": "'\xfan\xedc\xf3d\xe9\u203d'",- },- {"'id'": "'3'", "'name'": "'multi'", "'value'": "'foo"},- {"'id'": "4", "'name'": "'empty'", "'value'": ""},- ],- )+ assert list(csv) == [+ {"'id'": "1", "'name'": "'alpha'", "'value'": "'foobar'"},+ {+ "'id'": "2",+ "'name'": "'unicode'",+ "'value'": "'\xfan\xedc\xf3d\xe9\u203d'",+ },+ {"'id'": "'3'", "'name'": "'multi'", "'value'": "'foo"},+ {"'id'": "4", "'name'": "'empty'", "'value'": ""},+ ]def test_csviter_delimiter_binary_response_assume_utf8_encoding(self):body = get_testdata("feeds", "feed-sample3.csv").replace(b",", b"\t")response = Response(url="http://example.com/", body=body)csv = csviter(response, delimiter="\t")- self.assertEqual(- list(csv),- [- {"id": "1", "name": "alpha", "value": "foobar"},- {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},- {"id": "3", "name": "multi", "value": "foo\nbar"},- {"id": "4", "name": "empty", "value": ""},- ],- )+ assert list(csv) == [+ {"id": "1", "name": "alpha", "value": "foobar"},+ {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},+ {"id": "3", "name": "multi", "value": "foo\nbar"},+ {"id": "4", "name": "empty", "value": ""},+ ]def test_csviter_headers(self):sample = get_testdata("feeds", "feed-sample3.csv").splitlines()@@ -457,15 +435,12 @@ class UtilsCsvTestCase(unittest.TestCase):response = TextResponse(url="http://example.com/", body=body)csv = csviter(response, headers=[h.decode("utf-8") for h in headers])- self.assertEqual(- list(csv),- [- {"id": "1", "name": "alpha", "value": "foobar"},- {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},- {"id": "3", "name": "multi", "value": "foo\nbar"},- {"id": "4", "name": "empty", "value": ""},- ],- )+ assert list(csv) == [+ {"id": "1", "name": "alpha", "value": "foobar"},+ {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},+ {"id": "3", "name": "multi", "value": "foo\nbar"},+ {"id": "4", "name": "empty", "value": ""},+ ]def test_csviter_falserow(self):body = get_testdata("feeds", "feed-sample3.csv")@@ -474,15 +449,12 @@ class UtilsCsvTestCase(unittest.TestCase):response = TextResponse(url="http://example.com/", body=body)csv = csviter(response)- self.assertEqual(- list(csv),- [- {"id": "1", "name": "alpha", "value": "foobar"},- {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},- {"id": "3", "name": "multi", "value": "foo\nbar"},- {"id": "4", "name": "empty", "value": ""},- ],- )+ assert list(csv) == [+ {"id": "1", "name": "alpha", "value": "foobar"},+ {"id": "2", "name": "unicode", "value": "\xfan\xedc\xf3d\xe9\u203d"},+ {"id": "3", "name": "multi", "value": "foo\nbar"},+ {"id": "4", "name": "empty", "value": ""},+ ]def test_csviter_exception(self):body = get_testdata("feeds", "feed-sample3.csv")@@ -504,30 +476,24 @@ class UtilsCsvTestCase(unittest.TestCase):url="http://example.com/", body=body1, encoding="latin1")csv = csviter(response)- self.assertEqual(- list(csv),- [- {"id": "1", "name": "latin1", "value": "test"},- {"id": "2", "name": "something", "value": "\xf1\xe1\xe9\xf3"},- ],- )+ assert list(csv) == [+ {"id": "1", "name": "latin1", "value": "test"},+ {"id": "2", "name": "something", "value": "\xf1\xe1\xe9\xf3"},+ ]response = TextResponse(url="http://example.com/", body=body2, encoding="cp852")csv = csviter(response)- self.assertEqual(- list(csv),- [- {"id": "1", "name": "cp852", "value": "test"},- {- "id": "2",- "name": "something",- "value": "\u255a\u2569\u2569\u2569\u2550\u2550\u2557",- },- ],- )+ assert list(csv) == [+ {"id": "1", "name": "cp852", "value": "test"},+ {+ "id": "2",+ "name": "something",+ "value": "\u255a\u2569\u2569\u2569\u2550\u2550\u2557",+ },+ ]-class TestHelper(unittest.TestCase):+class TestHelper:bbody = b"utf8-body"ubody = bbody.decode("utf8")txtresponse = TextResponse(url="http://example.org/", body=bbody, encoding="utf-8")@@ -541,11 +507,9 @@ class TestHelper(unittest.TestCase):self._assert_type_and_value(r2, self.ubody, obj)r3 = _body_or_str(obj, unicode=False)self._assert_type_and_value(r3, self.bbody, obj)- self.assertTrue(type(r1) is type(r2))- self.assertTrue(type(r1) is not type(r3))+ assert type(r1) is type(r2)+ assert type(r1) is not type(r3)def _assert_type_and_value(self, a, b, obj):- self.assertTrue(- type(a) is type(b), f"Got {type(a)}, expected {type(b)} for {obj!r}"- )- self.assertEqual(a, b)+ assert type(a) is type(b), f"Got {type(a)}, expected {type(b)} for {obj!r}"+ assert a == bdiff --git a/tests/test_utils_log.py b/tests/test_utils_log.pyindex 06e88bd10..af50fed7a 100644--- a/tests/test_utils_log.py+++ b/tests/test_utils_log.py@@ -7,7 +7,6 @@ import sysimport unittestfrom io import StringIOfrom typing import TYPE_CHECKING, Any-from unittest import TestCaseimport pytestfrom testfixtures import LogCapture@@ -27,7 +26,7 @@ if TYPE_CHECKING:from collections.abc import Mapping, MutableMapping-class FailureToExcInfoTest(unittest.TestCase):+class TestFailureToExcInfo:def test_failure(self):try:0 / 0@@ -35,14 +34,14 @@ class FailureToExcInfoTest(unittest.TestCase):exc_info = sys.exc_info()failure = Failure()- self.assertTupleEqual(exc_info, failure_to_exc_info(failure))+ assert exc_info == failure_to_exc_info(failure)def test_non_failure(self):- self.assertIsNone(failure_to_exc_info("test"))+ assert failure_to_exc_info("test") is None-class TopLevelFormatterTest(unittest.TestCase):- def setUp(self):+class TestTopLevelFormatter:+ def setup_method(self):self.handler = LogCapture()self.handler.addFilter(TopLevelFormatter(["test"]))@@ -71,8 +70,8 @@ class TopLevelFormatterTest(unittest.TestCase):log.check(("different", "WARNING", "test log msg"))-class LogCounterHandlerTest(unittest.TestCase):- def setUp(self):+class TestLogCounterHandler:+ def setup_method(self):settings = {"LOG_LEVEL": "WARNING"}self.logger = logging.getLogger("test")self.logger.setLevel(logging.NOTSET)@@ -81,24 +80,24 @@ class LogCounterHandlerTest(unittest.TestCase):self.handler = LogCounterHandler(self.crawler)self.logger.addHandler(self.handler)- def tearDown(self):+ def teardown_method(self):self.logger.propagate = Trueself.logger.removeHandler(self.handler)def test_init(self):- self.assertIsNone(self.crawler.stats.get_value("log_count/DEBUG"))- self.assertIsNone(self.crawler.stats.get_value("log_count/INFO"))- self.assertIsNone(self.crawler.stats.get_value("log_count/WARNING"))- self.assertIsNone(self.crawler.stats.get_value("log_count/ERROR"))- self.assertIsNone(self.crawler.stats.get_value("log_count/CRITICAL"))+ assert self.crawler.stats.get_value("log_count/DEBUG") is None+ assert self.crawler.stats.get_value("log_count/INFO") is None+ assert self.crawler.stats.get_value("log_count/WARNING") is None+ assert self.crawler.stats.get_value("log_count/ERROR") is None+ assert self.crawler.stats.get_value("log_count/CRITICAL") is Nonedef test_accepted_level(self):self.logger.error("test log msg")- self.assertEqual(self.crawler.stats.get_value("log_count/ERROR"), 1)+ assert self.crawler.stats.get_value("log_count/ERROR") == 1def test_filtered_out_level(self):self.logger.debug("test log msg")- self.assertIsNone(self.crawler.stats.get_value("log_count/INFO"))+ assert self.crawler.stats.get_value("log_count/INFO") is Noneclass StreamLoggerTest(unittest.TestCase):@@ -152,8 +151,8 @@ def test_spider_logger_adapter_process(assert result_kwargs == expected_extra-class LoggingTestCase(TestCase):- def setUp(self):+class TestLogging:+ def setup_method(self):self.log_stream = StringIO()handler = logging.StreamHandler(self.log_stream)logger = logging.getLogger("log_spider")@@ -163,7 +162,7 @@ class LoggingTestCase(TestCase):self.logger = loggerself.spider = LogSpider()- def tearDown(self):+ def teardown_method(self):self.logger.removeHandler(self.handler)def test_debug_logging(self):@@ -202,8 +201,8 @@ class LoggingTestCase(TestCase):assert log_contents == f"{log_message}\n"-class LoggingWithExtraTestCase(TestCase):- def setUp(self):+class TestLoggingWithExtra:+ def setup_method(self):self.log_stream = StringIO()handler = logging.StreamHandler(self.log_stream)formatter = logging.Formatter(@@ -218,7 +217,7 @@ class LoggingWithExtraTestCase(TestCase):self.spider = LogSpider()self.regex_pattern = re.compile(r"^<LogSpider\s'log_spider'\sat\s[^>]+>$")- def tearDown(self):+ def teardown_method(self):self.logger.removeHandler(self.handler)def test_debug_logging(self):diff --git a/tests/test_utils_misc/__init__.py b/tests/test_utils_misc/__init__.pyindex a67e16962..b330819d9 100644--- a/tests/test_utils_misc/__init__.py+++ b/tests/test_utils_misc/__init__.py@@ -1,6 +1,5 @@import osimport sys-import unittestfrom pathlib import Pathfrom unittest import mock@@ -18,18 +17,18 @@ from scrapy.utils.misc import ()-class UtilsMiscTestCase(unittest.TestCase):+class TestUtilsMisc:def test_load_object_class(self):obj = load_object(Field)- self.assertIs(obj, Field)+ assert obj is Fieldobj = load_object("scrapy.item.Field")- self.assertIs(obj, Field)+ assert obj is Fielddef test_load_object_function(self):obj = load_object(load_object)- self.assertIs(obj, load_object)+ assert obj is load_objectobj = load_object("scrapy.utils.misc.load_object")- self.assertIs(obj, load_object)+ assert obj is load_objectdef test_load_object_exceptions(self):with pytest.raises(ImportError):@@ -47,20 +46,20 @@ class UtilsMiscTestCase(unittest.TestCase):"tests.test_utils_misc.test_walk_modules.mod.mod0","tests.test_utils_misc.test_walk_modules.mod1",]- self.assertEqual({m.__name__ for m in mods}, set(expected))+ assert {m.__name__ for m in mods} == set(expected)mods = walk_modules("tests.test_utils_misc.test_walk_modules.mod")expected = ["tests.test_utils_misc.test_walk_modules.mod","tests.test_utils_misc.test_walk_modules.mod.mod0",]- self.assertEqual({m.__name__ for m in mods}, set(expected))+ assert {m.__name__ for m in mods} == set(expected)mods = walk_modules("tests.test_utils_misc.test_walk_modules.mod1")expected = ["tests.test_utils_misc.test_walk_modules.mod1",]- self.assertEqual({m.__name__ for m in mods}, set(expected))+ assert {m.__name__ for m in mods} == set(expected)with pytest.raises(ImportError):walk_modules("nomodule999")@@ -76,7 +75,7 @@ class UtilsMiscTestCase(unittest.TestCase):"testegg.spiders.b","testegg",]- self.assertEqual({m.__name__ for m in mods}, set(expected))+ assert {m.__name__ for m in mods} == set(expected)finally:sys.path.remove(egg)@@ -90,15 +89,13 @@ class UtilsMiscTestCase(unittest.TestCase):assert hasattr(arg_to_iter([1, 2, 3]), "__iter__")assert hasattr(arg_to_iter(c for c in "abcd"), "__iter__")- self.assertEqual(list(arg_to_iter(None)), [])- self.assertEqual(list(arg_to_iter("lala")), ["lala"])- self.assertEqual(list(arg_to_iter(100)), [100])- self.assertEqual(list(arg_to_iter(c for c in "abc")), ["a", "b", "c"])- self.assertEqual(list(arg_to_iter([1, 2, 3])), [1, 2, 3])- self.assertEqual(list(arg_to_iter({"a": 1})), [{"a": 1}])- self.assertEqual(- list(arg_to_iter(TestItem(name="john"))), [TestItem(name="john")]- )+ assert not list(arg_to_iter(None))+ assert list(arg_to_iter("lala")) == ["lala"]+ assert list(arg_to_iter(100)) == [100]+ assert list(arg_to_iter(c for c in "abc")) == ["a", "b", "c"]+ assert list(arg_to_iter([1, 2, 3])) == [1, 2, 3]+ assert list(arg_to_iter({"a": 1})) == [{"a": 1}]+ assert list(arg_to_iter(TestItem(name="john"))) == [TestItem(name="john")]@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_create_instance(self):@@ -110,10 +107,10 @@ class UtilsMiscTestCase(unittest.TestCase):def _test_with_settings(mock, settings):create_instance(mock, settings, None, *args, **kwargs)if hasattr(mock, "from_crawler"):- self.assertEqual(mock.from_crawler.call_count, 0)+ assert mock.from_crawler.call_count == 0if hasattr(mock, "from_settings"):mock.from_settings.assert_called_once_with(settings, *args, **kwargs)- self.assertEqual(mock.call_count, 0)+ assert mock.call_count == 0else:mock.assert_called_once_with(*args, **kwargs)@@ -122,11 +119,11 @@ class UtilsMiscTestCase(unittest.TestCase):if hasattr(mock, "from_crawler"):mock.from_crawler.assert_called_once_with(crawler, *args, **kwargs)if hasattr(mock, "from_settings"):- self.assertEqual(mock.from_settings.call_count, 0)- self.assertEqual(mock.call_count, 0)+ assert mock.from_settings.call_count == 0+ assert mock.call_count == 0elif hasattr(mock, "from_settings"):mock.from_settings.assert_called_once_with(settings, *args, **kwargs)- self.assertEqual(mock.call_count, 0)+ assert mock.call_count == 0else:mock.assert_called_once_with(*args, **kwargs)@@ -172,11 +169,11 @@ class UtilsMiscTestCase(unittest.TestCase):if hasattr(mock, "from_crawler"):mock.from_crawler.assert_called_once_with(crawler, *args, **kwargs)if hasattr(mock, "from_settings"):- self.assertEqual(mock.from_settings.call_count, 0)- self.assertEqual(mock.call_count, 0)+ assert mock.from_settings.call_count == 0+ assert mock.call_count == 0elif hasattr(mock, "from_settings"):mock.from_settings.assert_called_once_with(settings, *args, **kwargs)- self.assertEqual(mock.call_count, 0)+ assert mock.call_count == 0else:mock.assert_called_once_with(*args, **kwargs)diff --git a/tests/test_utils_misc/test_return_with_argument_inside_generator.py b/tests/test_utils_misc/test_return_with_argument_inside_generator.pyindex 480729d11..81a83c3d7 100644--- a/tests/test_utils_misc/test_return_with_argument_inside_generator.py+++ b/tests/test_utils_misc/test_return_with_argument_inside_generator.py@@ -1,4 +1,3 @@-import unittestimport warningsfrom functools import partialfrom unittest import mock@@ -40,7 +39,7 @@ def generator_that_returns_stuff():return 3-class UtilsMiscPy3TestCase(unittest.TestCase):+class TestUtilsMisc:def test_generators_return_something(self):def f1():yield 1@@ -77,27 +76,27 @@ https://example.orgwith warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, top_level_return_something)- self.assertEqual(len(w), 1)- self.assertIn(- 'The "NoneType.top_level_return_something" method is a generator',- str(w[0].message),+ assert len(w) == 1+ assert (+ 'The "NoneType.top_level_return_something" method is a generator'+ in str(w[0].message))with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, f1)- self.assertEqual(len(w), 1)- self.assertIn('The "NoneType.f1" method is a generator', str(w[0].message))+ assert len(w) == 1+ assert 'The "NoneType.f1" method is a generator' in str(w[0].message)with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, g1)- self.assertEqual(len(w), 1)- self.assertIn('The "NoneType.g1" method is a generator', str(w[0].message))+ assert len(w) == 1+ assert 'The "NoneType.g1" method is a generator' in str(w[0].message)with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, h1)- self.assertEqual(len(w), 1)- self.assertIn('The "NoneType.h1" method is a generator', str(w[0].message))+ assert len(w) == 1+ assert 'The "NoneType.h1" method is a generator' in str(w[0].message)with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, i1)- self.assertEqual(len(w), 1)- self.assertIn('The "NoneType.i1" method is a generator', str(w[0].message))+ assert len(w) == 1+ assert 'The "NoneType.i1" method is a generator' in str(w[0].message)def test_generators_return_none(self):def f2():@@ -144,28 +143,28 @@ https://example.orgwith warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, top_level_return_none)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, f2)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, g2)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, h2)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, i2)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, j2)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, k2)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, l2)- self.assertEqual(len(w), 0)+ assert len(w) == 0def test_generators_return_none_with_decorator(self):def decorator(func):@@ -225,28 +224,28 @@ https://example.orgwith warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, top_level_return_none)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, f3)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, g3)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, h3)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, i3)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, j3)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, k3)- self.assertEqual(len(w), 0)+ assert len(w) == 0with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, l3)- self.assertEqual(len(w), 0)+ assert len(w) == 0@mock.patch("scrapy.utils.misc.is_generator_with_return_value", new=_indentation_error@@ -254,8 +253,8 @@ https://example.orgdef test_indentation_error(self):with warnings.catch_warnings(record=True) as w:warn_on_generator_with_return_value(None, top_level_return_none)- self.assertEqual(len(w), 1)- self.assertIn("Unable to determine", str(w[0].message))+ assert len(w) == 1+ assert "Unable to determine" in str(w[0].message)def test_partial(self):def cb(arg1, arg2):diff --git a/tests/test_utils_project.py b/tests/test_utils_project.pyindex 1d149d48d..aa250be69 100644--- a/tests/test_utils_project.py+++ b/tests/test_utils_project.py@@ -2,7 +2,6 @@ import contextlibimport osimport shutilimport tempfile-import unittestimport warningsfrom pathlib import Path@@ -25,21 +24,21 @@ def inside_a_project():shutil.rmtree(project_dir)-class ProjectUtilsTest(unittest.TestCase):+class TestProjectUtils:def test_data_path_outside_project(self):- self.assertEqual(str(Path(".scrapy", "somepath")), data_path("somepath"))+ assert str(Path(".scrapy", "somepath")) == data_path("somepath")abspath = str(Path(os.path.sep, "absolute", "path"))- self.assertEqual(abspath, data_path(abspath))+ assert abspath == data_path(abspath)def test_data_path_inside_project(self):with inside_a_project() as proj_path:expected = Path(proj_path, ".scrapy", "somepath")- self.assertEqual(expected.resolve(), Path(data_path("somepath")).resolve())+ assert expected.resolve() == Path(data_path("somepath")).resolve()abspath = str(Path(os.path.sep, "absolute", "path").resolve())- self.assertEqual(abspath, data_path(abspath))+ assert abspath == data_path(abspath)-class GetProjectSettingsTestCase(unittest.TestCase):+class TestGetProjectSettings:def test_valid_envvar(self):value = "tests.test_cmdline.settings"envvars = {diff --git a/tests/test_utils_python.py b/tests/test_utils_python.pyindex 3b0739276..291646ad7 100644--- a/tests/test_utils_python.py+++ b/tests/test_utils_python.py@@ -21,18 +21,18 @@ from scrapy.utils.python import ()-class MutableChainTest(unittest.TestCase):+class TestMutableChain:def test_mutablechain(self):m = MutableChain(range(2), [2, 3], (4, 5))m.extend(range(6, 7))m.extend([7, 8])m.extend([9, 10], (11, 12))- self.assertEqual(next(m), 0)- self.assertEqual(m.__next__(), 1)- self.assertEqual(list(m), list(range(2, 13)))+ assert next(m) == 0+ assert m.__next__() == 1+ assert list(m) == list(range(2, 13))-class MutableAsyncChainTest(unittest.TestCase):+class TestMutableAsyncChain(unittest.TestCase):@staticmethodasync def g1():for i in range(3):@@ -62,9 +62,9 @@ class MutableAsyncChainTest(unittest.TestCase):m.extend(self.g2())m.extend(self.g3())- self.assertEqual(await m.__anext__(), 0)+ assert await m.__anext__() == 0results = await collect_asyncgen(m)- self.assertEqual(results, list(range(1, 10)))+ assert results == list(range(1, 10))@deferred_f_from_coro_fasync def test_mutableasyncchain_exc(self):@@ -73,46 +73,46 @@ class MutableAsyncChainTest(unittest.TestCase):m.extend(self.g3())results = await collect_asyncgen(aiter_errback(m, lambda _: None))- self.assertEqual(results, list(range(5)))+ assert results == list(range(5))-class ToUnicodeTest(unittest.TestCase):+class TestToUnicode:def test_converting_an_utf8_encoded_string_to_unicode(self):- self.assertEqual(to_unicode(b"lel\xc3\xb1e"), "lel\xf1e")+ assert to_unicode(b"lel\xc3\xb1e") == "lel\xf1e"def test_converting_a_latin_1_encoded_string_to_unicode(self):- self.assertEqual(to_unicode(b"lel\xf1e", "latin-1"), "lel\xf1e")+ assert to_unicode(b"lel\xf1e", "latin-1") == "lel\xf1e"def test_converting_a_unicode_to_unicode_should_return_the_same_object(self):- self.assertEqual(to_unicode("\xf1e\xf1e\xf1e"), "\xf1e\xf1e\xf1e")+ assert to_unicode("\xf1e\xf1e\xf1e") == "\xf1e\xf1e\xf1e"- def test_converting_a_strange_object_should_raise_TypeError(self):+ def test_converting_a_strange_object_should_raise_type_error(self):with pytest.raises(TypeError):to_unicode(423)def test_errors_argument(self):- self.assertEqual(to_unicode(b"a\xedb", "utf-8", errors="replace"), "a\ufffdb")+ assert to_unicode(b"a\xedb", "utf-8", errors="replace") == "a\ufffdb"-class ToBytesTest(unittest.TestCase):+class TestToBytes:def test_converting_a_unicode_object_to_an_utf_8_encoded_string(self):- self.assertEqual(to_bytes("\xa3 49"), b"\xc2\xa3 49")+ assert to_bytes("\xa3 49") == b"\xc2\xa3 49"def test_converting_a_unicode_object_to_a_latin_1_encoded_string(self):- self.assertEqual(to_bytes("\xa3 49", "latin-1"), b"\xa3 49")+ assert to_bytes("\xa3 49", "latin-1") == b"\xa3 49"def test_converting_a_regular_bytes_to_bytes_should_return_the_same_object(self):- self.assertEqual(to_bytes(b"lel\xf1e"), b"lel\xf1e")+ assert to_bytes(b"lel\xf1e") == b"lel\xf1e"- def test_converting_a_strange_object_should_raise_TypeError(self):+ def test_converting_a_strange_object_should_raise_type_error(self):with pytest.raises(TypeError):to_bytes(pytest)def test_errors_argument(self):- self.assertEqual(to_bytes("a\ufffdb", "latin-1", errors="replace"), b"a?b")+ assert to_bytes("a\ufffdb", "latin-1", errors="replace") == b"a?b"-class MemoizedMethodTest(unittest.TestCase):+class TestMemoizedMethod:def test_memoizemethod_noargs(self):class A:@memoizemethod_noargs@@ -130,7 +130,7 @@ class MemoizedMethodTest(unittest.TestCase):assert one is not three-class BinaryIsTextTest(unittest.TestCase):+class TestBinaryIsText:def test_binaryistext(self):assert binary_is_text(b"hello")@@ -144,7 +144,7 @@ class BinaryIsTextTest(unittest.TestCase):assert not binary_is_text(b"\x02\xa3")-class UtilsPythonTestCase(unittest.TestCase):+class TestUtilsPython:@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_equal_attributes(self):class Obj:@@ -153,31 +153,31 @@ class UtilsPythonTestCase(unittest.TestCase):a = Obj()b = Obj()# no attributes given return False- self.assertFalse(equal_attributes(a, b, []))+ assert not equal_attributes(a, b, [])# nonexistent attributes- self.assertFalse(equal_attributes(a, b, ["x", "y"]))+ assert not equal_attributes(a, b, ["x", "y"])a.x = 1b.x = 1# equal attribute- self.assertTrue(equal_attributes(a, b, ["x"]))+ assert equal_attributes(a, b, ["x"])b.y = 2# obj1 has no attribute y- self.assertFalse(equal_attributes(a, b, ["x", "y"]))+ assert not equal_attributes(a, b, ["x", "y"])a.y = 2# equal attributes- self.assertTrue(equal_attributes(a, b, ["x", "y"]))+ assert equal_attributes(a, b, ["x", "y"])a.y = 1# different attributes- self.assertFalse(equal_attributes(a, b, ["x", "y"]))+ assert not equal_attributes(a, b, ["x", "y"])# test callablea.meta = {}b.meta = {}- self.assertTrue(equal_attributes(a, b, ["meta"]))+ assert equal_attributes(a, b, ["meta"])# compare ['meta']['a']a.meta["z"] = 1@@ -189,10 +189,10 @@ class UtilsPythonTestCase(unittest.TestCase):def compare_z(obj):return get_z(get_meta(obj))- self.assertTrue(equal_attributes(a, b, [compare_z, "x"]))+ assert equal_attributes(a, b, [compare_z, "x"])# fail z equalitya.meta["z"] = 2- self.assertFalse(equal_attributes(a, b, [compare_z, "x"]))+ assert not equal_attributes(a, b, [compare_z, "x"])def test_get_func_args(self):def f1(a, b, c):@@ -221,36 +221,35 @@ class UtilsPythonTestCase(unittest.TestCase):partial_f2 = functools.partial(f1, b=None)partial_f3 = functools.partial(partial_f2, None)- self.assertEqual(get_func_args(f1), ["a", "b", "c"])- self.assertEqual(get_func_args(f2), ["a", "b", "c"])- self.assertEqual(get_func_args(f3), ["a", "b", "c"])- self.assertEqual(get_func_args(A), ["a", "b", "c"])- self.assertEqual(get_func_args(a.method), ["a", "b", "c"])- self.assertEqual(get_func_args(partial_f1), ["b", "c"])- self.assertEqual(get_func_args(partial_f2), ["a", "c"])- self.assertEqual(get_func_args(partial_f3), ["c"])- self.assertEqual(get_func_args(cal), ["a", "b", "c"])- self.assertEqual(get_func_args(object), [])- self.assertEqual(get_func_args(str.split, stripself=True), ["sep", "maxsplit"])- self.assertEqual(get_func_args(" ".join, stripself=True), ["iterable"])+ assert get_func_args(f1) == ["a", "b", "c"]+ assert get_func_args(f2) == ["a", "b", "c"]+ assert get_func_args(f3) == ["a", "b", "c"]+ assert get_func_args(A) == ["a", "b", "c"]+ assert get_func_args(a.method) == ["a", "b", "c"]+ assert get_func_args(partial_f1) == ["b", "c"]+ assert get_func_args(partial_f2) == ["a", "c"]+ assert get_func_args(partial_f3) == ["c"]+ assert get_func_args(cal) == ["a", "b", "c"]+ assert get_func_args(object) == []+ assert get_func_args(str.split, stripself=True) == ["sep", "maxsplit"]+ assert get_func_args(" ".join, stripself=True) == ["iterable"]if sys.version_info >= (3, 13) or platform.python_implementation() == "PyPy":# the correct and correctly extracted signature- self.assertEqual(- get_func_args(operator.itemgetter(2), stripself=True), ["obj"]- )+ assert get_func_args(operator.itemgetter(2), stripself=True) == ["obj"]elif platform.python_implementation() == "CPython":# ["args", "kwargs"] is a correct result for the pre-3.13 incorrect function signature# [] is an incorrect result on even older CPython (https://github.com/python/cpython/issues/86951)- self.assertIn(- get_func_args(operator.itemgetter(2), stripself=True),- [[], ["args", "kwargs"]],- )+ assert get_func_args(operator.itemgetter(2), stripself=True) in [+ [],+ ["args", "kwargs"],+ ]def test_without_none_values(self):- self.assertEqual(without_none_values([1, None, 3, 4]), [1, 3, 4])- self.assertEqual(without_none_values((1, None, 3, 4)), (1, 3, 4))- self.assertEqual(- without_none_values({"one": 1, "none": None, "three": 3, "four": 4}),- {"one": 1, "three": 3, "four": 4},- )+ assert without_none_values([1, None, 3, 4]) == [1, 3, 4]+ assert without_none_values((1, None, 3, 4)) == (1, 3, 4)+ assert without_none_values({"one": 1, "none": None, "three": 3, "four": 4}) == {+ "one": 1,+ "three": 3,+ "four": 4,+ }diff --git a/tests/test_utils_request.py b/tests/test_utils_request.pyindex 51bca9a31..5b8509753 100644--- a/tests/test_utils_request.py+++ b/tests/test_utils_request.py@@ -1,7 +1,6 @@from __future__ import annotationsimport json-import unittestimport warningsfrom hashlib import sha1from weakref import WeakKeyDictionary@@ -21,23 +20,23 @@ from scrapy.utils.request import (from scrapy.utils.test import get_crawler-class UtilsRequestTest(unittest.TestCase):+class TestUtilsRequest:@pytest.mark.filterwarnings("ignore::scrapy.exceptions.ScrapyDeprecationWarning")def test_request_authenticate(self):r = Request("http://www.example.com")request_authenticate(r, "someuser", "somepass")- self.assertEqual(r.headers["Authorization"], b"Basic c29tZXVzZXI6c29tZXBhc3M=")+ assert r.headers["Authorization"] == b"Basic c29tZXVzZXI6c29tZXBhc3M="def test_request_httprepr(self):r1 = Request("http://www.example.com")- self.assertEqual(- request_httprepr(r1), b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"+ assert (+ request_httprepr(r1) == b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n")r1 = Request("http://www.example.com/some/page.html?arg=1")- self.assertEqual(- request_httprepr(r1),- b"GET /some/page.html?arg=1 HTTP/1.1\r\nHost: www.example.com\r\n\r\n",+ assert (+ request_httprepr(r1)+ == b"GET /some/page.html?arg=1 HTTP/1.1\r\nHost: www.example.com\r\n\r\n")r1 = Request(@@ -46,9 +45,9 @@ class UtilsRequestTest(unittest.TestCase):headers={"Content-type": b"text/html"},body=b"Some body",)- self.assertEqual(- request_httprepr(r1),- b"POST / HTTP/1.1\r\nHost: www.example.com\r\nContent-Type: text/html\r\n\r\nSome body",+ assert (+ request_httprepr(r1)+ == b"POST / HTTP/1.1\r\nHost: www.example.com\r\nContent-Type: text/html\r\n\r\nSome body")def test_request_httprepr_for_non_http_request(self):@@ -57,7 +56,7 @@ class UtilsRequestTest(unittest.TestCase):request_httprepr(Request("ftp://localhost/tmp/foo.txt"))-class FingerprintTest(unittest.TestCase):+class TestFingerprint:maxDiff = Nonefunction: staticmethod = staticmethod(fingerprint)@@ -147,23 +146,23 @@ class FingerprintTest(unittest.TestCase):def test_query_string_key_order(self):r1 = Request("http://www.example.com/query?id=111&cat=222")r2 = Request("http://www.example.com/query?cat=222&id=111")- self.assertEqual(self.function(r1), self.function(r1))- self.assertEqual(self.function(r1), self.function(r2))+ assert self.function(r1) == self.function(r1)+ assert self.function(r1) == self.function(r2)def test_query_string_key_without_value(self):r1 = Request("http://www.example.com/hnnoticiaj1.aspx?78132,199")r2 = Request("http://www.example.com/hnnoticiaj1.aspx?78160,199")- self.assertNotEqual(self.function(r1), self.function(r2))+ assert self.function(r1) != self.function(r2)def test_caching(self):r1 = Request("http://www.example.com/hnnoticiaj1.aspx?78160,199")- self.assertEqual(self.function(r1), self.cache[r1][self.default_cache_key])+ assert self.function(r1) == self.cache[r1][self.default_cache_key]def test_header(self):r1 = Request("http://www.example.com/members/offers.html")r2 = Request("http://www.example.com/members/offers.html")r2.headers["SESSIONID"] = b"somehash"- self.assertEqual(self.function(r1), self.function(r2))+ assert self.function(r1) == self.function(r2)def test_headers(self):r1 = Request("http://www.example.com/")@@ -173,36 +172,35 @@ class FingerprintTest(unittest.TestCase):r3.headers["Accept-Language"] = b"en"r3.headers["SESSIONID"] = b"somehash"- self.assertEqual(self.function(r1), self.function(r2), self.function(r3))+ assert self.function(r1) == self.function(r2) == self.function(r3)- self.assertEqual(- self.function(r1), self.function(r1, include_headers=["Accept-Language"])+ assert self.function(r1) == self.function(+ r1, include_headers=["Accept-Language"])- self.assertNotEqual(- self.function(r1), self.function(r2, include_headers=["Accept-Language"])+ assert self.function(r1) != self.function(+ r2, include_headers=["Accept-Language"])- self.assertEqual(- self.function(r3, include_headers=["accept-language", "sessionid"]),- self.function(r3, include_headers=["SESSIONID", "Accept-Language"]),- )+ assert self.function(+ r3, include_headers=["accept-language", "sessionid"]+ ) == self.function(r3, include_headers=["SESSIONID", "Accept-Language"])def test_fragment(self):r1 = Request("http://www.example.com/test.html")r2 = Request("http://www.example.com/test.html#fragment")- self.assertEqual(self.function(r1), self.function(r2))- self.assertEqual(self.function(r1), self.function(r1, keep_fragments=True))- self.assertNotEqual(self.function(r2), self.function(r2, keep_fragments=True))- self.assertNotEqual(self.function(r1), self.function(r2, keep_fragments=True))+ assert self.function(r1) == self.function(r2)+ assert self.function(r1) == self.function(r1, keep_fragments=True)+ assert self.function(r2) != self.function(r2, keep_fragments=True)+ assert self.function(r1) != self.function(r2, keep_fragments=True)def test_method_and_body(self):r1 = Request("http://www.example.com")r2 = Request("http://www.example.com", method="POST")r3 = Request("http://www.example.com", method="POST", body=b"request body")- self.assertNotEqual(self.function(r1), self.function(r2))- self.assertNotEqual(self.function(r2), self.function(r3))+ assert self.function(r1) != self.function(r2)+ assert self.function(r2) != self.function(r3)def test_request_replace(self):# cached fingerprint must be cleared on request copy@@ -210,7 +208,7 @@ class FingerprintTest(unittest.TestCase):fp1 = self.function(r1)r2 = r1.replace(url="http://www.example.com/other")fp2 = self.function(r2)- self.assertNotEqual(fp1, fp2)+ assert fp1 != fp2def test_part_separation(self):# An old implementation used to serialize request data in a way that@@ -219,7 +217,7 @@ class FingerprintTest(unittest.TestCase):fp1 = self.function(r1)r2 = Request("http://www.example.com/f", body=b"oo")fp2 = self.function(r2)- self.assertNotEqual(fp1, fp2)+ assert fp1 != fp2def test_hashes(self):"""Test hardcoded hashes, to make sure future changes to not introduce@@ -228,7 +226,7 @@ class FingerprintTest(unittest.TestCase):self.function(request, **kwargs) for request, _, kwargs in self.known_hashes]expected = [_fingerprint for _, _fingerprint, _ in self.known_hashes]- self.assertEqual(actual, expected)+ assert actual == expectedREQUEST_OBJECTS_TO_TEST = (@@ -260,13 +258,12 @@ REQUEST_OBJECTS_TO_TEST = ()-class RequestFingerprinterTestCase(unittest.TestCase):+class TestRequestFingerprinter:def test_default_implementation(self):crawler = get_crawler()request = Request("https://example.com")- self.assertEqual(- crawler.request_fingerprinter.fingerprint(request),- fingerprint(request),+ assert crawler.request_fingerprinter.fingerprint(request) == fingerprint(+ request)def test_deprecated_implementation(self):@@ -276,14 +273,13 @@ class RequestFingerprinterTestCase(unittest.TestCase):with warnings.catch_warnings(record=True) as logged_warnings:crawler = get_crawler(settings_dict=settings)request = Request("https://example.com")- self.assertEqual(- crawler.request_fingerprinter.fingerprint(request),- fingerprint(request),+ assert crawler.request_fingerprinter.fingerprint(request) == fingerprint(+ request)- self.assertTrue(logged_warnings)+ assert logged_warnings-class CustomRequestFingerprinterTestCase(unittest.TestCase):+class TestCustomRequestFingerprinter:def test_include_headers(self):class RequestFingerprinter:def fingerprint(self, request):@@ -298,7 +294,7 @@ class CustomRequestFingerprinterTestCase(unittest.TestCase):fp1 = crawler.request_fingerprinter.fingerprint(r1)r2 = Request("http://www.example.com", headers={"X-ID": "2"})fp2 = crawler.request_fingerprinter.fingerprint(r2)- self.assertNotEqual(fp1, fp2)+ assert fp1 != fp2def test_dont_canonicalize(self):class RequestFingerprinter:@@ -320,7 +316,7 @@ class CustomRequestFingerprinterTestCase(unittest.TestCase):fp1 = crawler.request_fingerprinter.fingerprint(r1)r2 = Request("http://www.example.com?a=2&a=1")fp2 = crawler.request_fingerprinter.fingerprint(r2)- self.assertNotEqual(fp1, fp2)+ assert fp1 != fp2def test_meta(self):class RequestFingerprinter:@@ -342,10 +338,10 @@ class CustomRequestFingerprinterTestCase(unittest.TestCase):fp3 = crawler.request_fingerprinter.fingerprint(r3)r4 = Request("http://www.example.com", meta={"fingerprint": "b"})fp4 = crawler.request_fingerprinter.fingerprint(r4)- self.assertNotEqual(fp1, fp2)- self.assertNotEqual(fp1, fp4)- self.assertNotEqual(fp2, fp4)- self.assertEqual(fp2, fp3)+ assert fp1 != fp2+ assert fp1 != fp4+ assert fp2 != fp4+ assert fp2 == fp3def test_from_crawler(self):class RequestFingerprinter:@@ -367,7 +363,7 @@ class CustomRequestFingerprinterTestCase(unittest.TestCase):request = Request("http://www.example.com")fingerprint = crawler.request_fingerprinter.fingerprint(request)- self.assertEqual(fingerprint, settings["FINGERPRINT"])+ assert fingerprint == settings["FINGERPRINT"]def test_from_settings(self):class RequestFingerprinter:@@ -391,7 +387,7 @@ class CustomRequestFingerprinterTestCase(unittest.TestCase):request = Request("http://www.example.com")fingerprint = crawler.request_fingerprinter.fingerprint(request)- self.assertEqual(fingerprint, settings["FINGERPRINT"])+ assert fingerprint == settings["FINGERPRINT"]def test_from_crawler_and_settings(self):class RequestFingerprinter:@@ -418,13 +414,13 @@ class CustomRequestFingerprinterTestCase(unittest.TestCase):request = Request("http://www.example.com")fingerprint = crawler.request_fingerprinter.fingerprint(request)- self.assertEqual(fingerprint, settings["FINGERPRINT"])+ assert fingerprint == settings["FINGERPRINT"]-class RequestToCurlTest(unittest.TestCase):+class TestRequestToCurl:def _test_request(self, request_object, expected_curl_command):curl_command = request_to_curl(request_object)- self.assertEqual(curl_command, expected_curl_command)+ assert curl_command == expected_curl_commanddef test_get(self):request_object = Request("https://www.example.com")diff --git a/tests/test_utils_response.py b/tests/test_utils_response.pyindex af7906781..80f2f25d5 100644--- a/tests/test_utils_response.py+++ b/tests/test_utils_response.py@@ -1,4 +1,3 @@-import unittestfrom pathlib import Pathfrom time import process_timefrom urllib.parse import urlparse@@ -16,7 +15,7 @@ from scrapy.utils.response import ()-class ResponseUtilsTest(unittest.TestCase):+class TestResponseUtils:dummy_response = TextResponse(url="http://example.org/", body=b"dummy_response")def test_open_in_browser(self):@@ -28,7 +27,7 @@ class ResponseUtilsTest(unittest.TestCase):if not path or not Path(path).exists():path = burl.replace("file://", "")bbody = Path(path).read_bytes()- self.assertIn(b'<base href="' + to_bytes(url) + b'">', bbody)+ assert b'<base href="' + to_bytes(url) + b'">' in bbodyreturn Trueresponse = HtmlResponse(url, body=body)@@ -68,9 +67,9 @@ class ResponseUtilsTest(unittest.TestCase):</script>""",)- self.assertEqual(get_meta_refresh(r1), (5.0, "http://example.org/newpage"))- self.assertEqual(get_meta_refresh(r2), (None, None))- self.assertEqual(get_meta_refresh(r3), (None, None))+ assert get_meta_refresh(r1) == (5.0, "http://example.org/newpage")+ assert get_meta_refresh(r2) == (None, None)+ assert get_meta_refresh(r3) == (None, None)def test_get_base_url(self):resp = HtmlResponse(@@ -81,19 +80,19 @@ class ResponseUtilsTest(unittest.TestCase):<body>blahablsdfsal&</body></html>""",)- self.assertEqual(get_base_url(resp), "http://www.example.com/img/")+ assert get_base_url(resp) == "http://www.example.com/img/"resp2 = HtmlResponse("http://www.example.com",body=b"""<html><body>blahablsdfsal&</body></html>""",)- self.assertEqual(get_base_url(resp2), "http://www.example.com")+ assert get_base_url(resp2) == "http://www.example.com"def test_response_status_message(self):- self.assertEqual(response_status_message(200), "200 OK")- self.assertEqual(response_status_message(404), "404 Not Found")- self.assertEqual(response_status_message(573), "573 Unknown Status")+ assert response_status_message(200) == "200 OK"+ assert response_status_message(404) == "404 Not Found"+ assert response_status_message(573) == "573 Unknown Status"def test_inject_base_url(self):url = "http://www.example.com"@@ -103,7 +102,7 @@ class ResponseUtilsTest(unittest.TestCase):if not path or not Path(path).exists():path = burl.replace("file://", "")bbody = Path(path).read_bytes()- self.assertEqual(bbody.count(b'<base href="' + to_bytes(url) + b'">'), 1)+ assert bbody.count(b'<base href="' + to_bytes(url) + b'">') == 1return Truer1 = HtmlResponse(@@ -185,7 +184,7 @@ class ResponseUtilsTest(unittest.TestCase):open_in_browser(response, lambda url: True)end_time = process_time()- self.assertLess(end_time - start_time, MAX_CPU_TIME)+ assert end_time - start_time < MAX_CPU_TIMEdef test_open_in_browser_redos_head(self):MAX_CPU_TIME = 0.02@@ -202,7 +201,7 @@ class ResponseUtilsTest(unittest.TestCase):open_in_browser(response, lambda url: True)end_time = process_time()- self.assertLess(end_time - start_time, MAX_CPU_TIME)+ assert end_time - start_time < MAX_CPU_TIME@pytest.mark.parametrize(diff --git a/tests/test_utils_serialize.py b/tests/test_utils_serialize.pyindex 055db4e5b..2ee3850b0 100644--- a/tests/test_utils_serialize.py+++ b/tests/test_utils_serialize.py@@ -1,7 +1,6 @@import dataclassesimport datetimeimport json-import unittestfrom decimal import Decimalimport attr@@ -11,8 +10,8 @@ from scrapy.http import Request, Responsefrom scrapy.utils.serialize import ScrapyJSONEncoder-class JsonEncoderTestCase(unittest.TestCase):- def setUp(self):+class TestJsonEncoder:+ def setup_method(self):self.encoder = ScrapyJSONEncoder(sort_keys=True)def test_encode_decode(self):@@ -39,24 +38,22 @@ class JsonEncoderTestCase(unittest.TestCase):(s, ss),(dt_set, dt_sets),]:- self.assertEqual(- self.encoder.encode(input), json.dumps(output, sort_keys=True)- )+ assert self.encoder.encode(input) == json.dumps(output, sort_keys=True)def test_encode_deferred(self):- self.assertIn("Deferred", self.encoder.encode(defer.Deferred()))+ assert "Deferred" in self.encoder.encode(defer.Deferred())def test_encode_request(self):r = Request("http://www.example.com/lala")rs = self.encoder.encode(r)- self.assertIn(r.method, rs)- self.assertIn(r.url, rs)+ assert r.method in rs+ assert r.url in rsdef test_encode_response(self):r = Response("http://www.example.com/lala")rs = self.encoder.encode(r)- self.assertIn(r.url, rs)- self.assertIn(str(r.status), rs)+ assert r.url in rs+ assert str(r.status) in rsdef test_encode_dataclass_item(self) -> None:@dataclasses.dataclass@@ -67,9 +64,7 @@ class JsonEncoderTestCase(unittest.TestCase):item = TestDataClass(name="Product", url="http://product.org", price=1)encoded = self.encoder.encode(item)- self.assertEqual(- encoded, '{"name": "Product", "price": 1, "url": "http://product.org"}'- )+ assert encoded == '{"name": "Product", "price": 1, "url": "http://product.org"}'def test_encode_attrs_item(self):@attr.s@@ -80,6 +75,4 @@ class JsonEncoderTestCase(unittest.TestCase):item = AttrsItem(name="Product", url="http://product.org", price=1)encoded = self.encoder.encode(item)- self.assertEqual(- encoded, '{"name": "Product", "price": 1, "url": "http://product.org"}'- )+ assert encoded == '{"name": "Product", "price": 1, "url": "http://product.org"}'diff --git a/tests/test_utils_signal.py b/tests/test_utils_signal.pyindex 858813e83..751a77031 100644--- a/tests/test_utils_signal.py+++ b/tests/test_utils_signal.py@@ -11,7 +11,7 @@ from scrapy.utils.signal import send_catch_log, send_catch_log_deferredfrom scrapy.utils.test import get_from_asyncio_queue-class SendCatchLogTest(unittest.TestCase):+class TestSendCatchLog(unittest.TestCase):@defer.inlineCallbacksdef test_send_catch_log(self):test_signal = object()@@ -29,13 +29,13 @@ class SendCatchLogTest(unittest.TestCase):assert self.error_handler in handlers_calledassert self.ok_handler in handlers_called- self.assertEqual(len(log.records), 1)+ assert len(log.records) == 1record = log.records[0]- self.assertIn("error_handler", record.getMessage())- self.assertEqual(record.levelname, "ERROR")- self.assertEqual(result[0][0], self.error_handler)- self.assertIsInstance(result[0][1], Failure)- self.assertEqual(result[1], (self.ok_handler, "OK"))+ assert "error_handler" in record.getMessage()+ assert record.levelname == "ERROR"+ assert result[0][0] == self.error_handler # pylint: disable=comparison-with-callable+ assert isinstance(result[0][1], Failure)+ assert result[1] == (self.ok_handler, "OK")dispatcher.disconnect(self.error_handler, signal=test_signal)dispatcher.disconnect(self.ok_handler, signal=test_signal)@@ -53,7 +53,7 @@ class SendCatchLogTest(unittest.TestCase):return "OK"-class SendCatchLogDeferredTest(SendCatchLogTest):+class SendCatchLogDeferredTest(TestSendCatchLog):def _get_result(self, signal, *a, **kw):return send_catch_log_deferred(signal, *a, **kw)@@ -85,7 +85,7 @@ class SendCatchLogDeferredAsyncioTest(SendCatchLogDeferredTest):return await get_from_asyncio_queue("OK")-class SendCatchLogTest2(unittest.TestCase):+class TestSendCatchLog2:def test_error_logged_if_deferred_not_supported(self):def test_handler():return defer.Deferred()@@ -94,6 +94,6 @@ class SendCatchLogTest2(unittest.TestCase):dispatcher.connect(test_handler, test_signal)with LogCapture() as log:send_catch_log(test_signal)- self.assertEqual(len(log.records), 1)- self.assertIn("Cannot return deferreds from signal handler", str(log))+ assert len(log.records) == 1+ assert "Cannot return deferreds from signal handler" in str(log)dispatcher.disconnect(test_handler, test_signal)diff --git a/tests/test_utils_sitemap.py b/tests/test_utils_sitemap.pyindex 69a459d8b..36d612009 100644--- a/tests/test_utils_sitemap.py+++ b/tests/test_utils_sitemap.py@@ -1,9 +1,7 @@-import unittest-from scrapy.utils.sitemap import Sitemap, sitemap_urls_from_robots-class SitemapTest(unittest.TestCase):+class TestSitemap:def test_sitemap(self):s = Sitemap(b"""<?xml version="1.0" encoding="UTF-8"?>@@ -23,23 +21,20 @@ class SitemapTest(unittest.TestCase):</urlset>""")assert s.type == "urlset"- self.assertEqual(- list(s),- [- {- "priority": "1",- "loc": "http://www.example.com/",- "lastmod": "2009-08-16",- "changefreq": "daily",- },- {- "priority": "0.8",- "loc": "http://www.example.com/Special-Offers.html",- "lastmod": "2009-08-16",- "changefreq": "weekly",- },- ],- )+ assert list(s) == [+ {+ "priority": "1",+ "loc": "http://www.example.com/",+ "lastmod": "2009-08-16",+ "changefreq": "daily",+ },+ {+ "priority": "0.8",+ "loc": "http://www.example.com/Special-Offers.html",+ "lastmod": "2009-08-16",+ "changefreq": "weekly",+ },+ ]def test_sitemap_index(self):s = Sitemap(@@ -56,19 +51,16 @@ class SitemapTest(unittest.TestCase):</sitemapindex>""")assert s.type == "sitemapindex"- self.assertEqual(- list(s),- [- {- "loc": "http://www.example.com/sitemap1.xml.gz",- "lastmod": "2004-10-01T18:23:17+00:00",- },- {- "loc": "http://www.example.com/sitemap2.xml.gz",- "lastmod": "2005-01-01",- },- ],- )+ assert list(s) == [+ {+ "loc": "http://www.example.com/sitemap1.xml.gz",+ "lastmod": "2004-10-01T18:23:17+00:00",+ },+ {+ "loc": "http://www.example.com/sitemap2.xml.gz",+ "lastmod": "2005-01-01",+ },+ ]def test_sitemap_strip(self):"""Assert we can deal with trailing spaces inside <loc> tags - we've@@ -90,18 +82,15 @@ class SitemapTest(unittest.TestCase):</urlset>""")- self.assertEqual(- list(s),- [- {- "priority": "1",- "loc": "http://www.example.com/",- "lastmod": "2009-08-16",- "changefreq": "daily",- },- {"loc": "http://www.example.com/2", "lastmod": ""},- ],- )+ assert list(s) == [+ {+ "priority": "1",+ "loc": "http://www.example.com/",+ "lastmod": "2009-08-16",+ "changefreq": "daily",+ },+ {"loc": "http://www.example.com/2", "lastmod": ""},+ ]def test_sitemap_wrong_ns(self):"""We have seen sitemaps with wrongs ns. Presumably, Google still works@@ -122,18 +111,15 @@ class SitemapTest(unittest.TestCase):</urlset>""")- self.assertEqual(- list(s),- [- {- "priority": "1",- "loc": "http://www.example.com/",- "lastmod": "2009-08-16",- "changefreq": "daily",- },- {"loc": "http://www.example.com/2", "lastmod": ""},- ],- )+ assert list(s) == [+ {+ "priority": "1",+ "loc": "http://www.example.com/",+ "lastmod": "2009-08-16",+ "changefreq": "daily",+ },+ {"loc": "http://www.example.com/2", "lastmod": ""},+ ]def test_sitemap_wrong_ns2(self):"""We have seen sitemaps with wrongs ns. Presumably, Google still works@@ -155,18 +141,15 @@ class SitemapTest(unittest.TestCase):""")assert s.type == "urlset"- self.assertEqual(- list(s),- [- {- "priority": "1",- "loc": "http://www.example.com/",- "lastmod": "2009-08-16",- "changefreq": "daily",- },- {"loc": "http://www.example.com/2", "lastmod": ""},- ],- )+ assert list(s) == [+ {+ "priority": "1",+ "loc": "http://www.example.com/",+ "lastmod": "2009-08-16",+ "changefreq": "daily",+ },+ {"loc": "http://www.example.com/2", "lastmod": ""},+ ]def test_sitemap_urls_from_robots(self):robots = """User-agent: *@@ -187,15 +170,14 @@ Sitemap: /sitemap-relative-url.xmlDisallow: /forum/search/Disallow: /forum/active/"""- self.assertEqual(- list(sitemap_urls_from_robots(robots, base_url="http://example.com")),- [- "http://example.com/sitemap.xml",- "http://example.com/sitemap-product-index.xml",- "http://example.com/sitemap-uppercase.xml",- "http://example.com/sitemap-relative-url.xml",- ],- )+ assert list(+ sitemap_urls_from_robots(robots, base_url="http://example.com")+ ) == [+ "http://example.com/sitemap.xml",+ "http://example.com/sitemap-product-index.xml",+ "http://example.com/sitemap-uppercase.xml",+ "http://example.com/sitemap-relative-url.xml",+ ]def test_sitemap_blanklines(self):"""Assert we can deal with starting blank lines before <xml> tag"""@@ -224,14 +206,11 @@ Disallow: /forum/active/</sitemapindex>""")- self.assertEqual(- list(s),- [- {"lastmod": "2013-07-15", "loc": "http://www.example.com/sitemap1.xml"},- {"lastmod": "2013-07-15", "loc": "http://www.example.com/sitemap2.xml"},- {"lastmod": "2013-07-15", "loc": "http://www.example.com/sitemap3.xml"},- ],- )+ assert list(s) == [+ {"lastmod": "2013-07-15", "loc": "http://www.example.com/sitemap1.xml"},+ {"lastmod": "2013-07-15", "loc": "http://www.example.com/sitemap2.xml"},+ {"lastmod": "2013-07-15", "loc": "http://www.example.com/sitemap3.xml"},+ ]def test_comment(self):s = Sitemap(@@ -245,7 +224,7 @@ Disallow: /forum/active/</urlset>""")- self.assertEqual(list(s), [{"loc": "http://www.example.com/"}])+ assert list(s) == [{"loc": "http://www.example.com/"}]def test_alternate(self):s = Sitemap(@@ -265,19 +244,16 @@ Disallow: /forum/active/</urlset>""")- self.assertEqual(- list(s),- [- {- "loc": "http://www.example.com/english/",- "alternate": [- "http://www.example.com/deutsch/",- "http://www.example.com/schweiz-deutsch/",- "http://www.example.com/english/",- ],- }- ],- )+ assert list(s) == [+ {+ "loc": "http://www.example.com/english/",+ "alternate": [+ "http://www.example.com/deutsch/",+ "http://www.example.com/schweiz-deutsch/",+ "http://www.example.com/english/",+ ],+ }+ ]def test_xml_entity_expansion(self):s = Sitemap(@@ -294,4 +270,4 @@ Disallow: /forum/active/""")- self.assertEqual(list(s), [{"loc": "http://127.0.0.1:8000/"}])+ assert list(s) == [{"loc": "http://127.0.0.1:8000/"}]diff --git a/tests/test_utils_spider.py b/tests/test_utils_spider.pyindex df8f37103..43e603f6c 100644--- a/tests/test_utils_spider.py+++ b/tests/test_utils_spider.py@@ -1,5 +1,3 @@-import unittest-from scrapy import Spiderfrom scrapy.http import Requestfrom scrapy.item import Item@@ -14,19 +12,19 @@ class MySpider2(Spider):name = "myspider2"-class UtilsSpidersTestCase(unittest.TestCase):+class TestUtilsSpiders:def test_iterate_spider_output(self):i = Item()r = Request("http://scrapytest.org")o = object()- self.assertEqual(list(iterate_spider_output(i)), [i])- self.assertEqual(list(iterate_spider_output(r)), [r])- self.assertEqual(list(iterate_spider_output(o)), [o])- self.assertEqual(list(iterate_spider_output([r, i, o])), [r, i, o])+ assert list(iterate_spider_output(i)) == [i]+ assert list(iterate_spider_output(r)) == [r]+ assert list(iterate_spider_output(o)) == [o]+ assert list(iterate_spider_output([r, i, o])) == [r, i, o]def test_iter_spider_classes(self):import tests.test_utils_spider # noqa: PLW0406 # pylint: disable=import-selfit = iter_spider_classes(tests.test_utils_spider)- self.assertEqual(set(it), {MySpider1, MySpider2})+ assert set(it) == {MySpider1, MySpider2}diff --git a/tests/test_utils_template.py b/tests/test_utils_template.pyindex fc6c33200..0b845fdb0 100644--- a/tests/test_utils_template.py+++ b/tests/test_utils_template.py@@ -1,4 +1,3 @@-import unittestfrom pathlib import Pathfrom shutil import rmtreefrom tempfile import mkdtemp@@ -6,11 +5,11 @@ from tempfile import mkdtempfrom scrapy.utils.template import render_templatefile-class UtilsRenderTemplateFileTestCase(unittest.TestCase):- def setUp(self):+class TestUtilsRenderTemplateFile:+ def setup_method(self):self.tmp_path = mkdtemp()- def tearDown(self):+ def teardown_method(self):rmtree(self.tmp_path)def test_simple_render(self):@@ -26,8 +25,8 @@ class UtilsRenderTemplateFileTestCase(unittest.TestCase):render_templatefile(template_path, **context)- self.assertFalse(template_path.exists())- self.assertEqual(render_path.read_text(encoding="utf8"), rendered)+ assert not template_path.exists()+ assert render_path.read_text(encoding="utf8") == renderedrender_path.unlink()assert not render_path.exists() # Failure of test itselfdiff --git a/tests/test_utils_trackref.py b/tests/test_utils_trackref.pyindex 58efad585..a945163ef 100644--- a/tests/test_utils_trackref.py+++ b/tests/test_utils_trackref.py@@ -1,4 +1,3 @@-import unittestfrom io import StringIOfrom time import sleep, timefrom unittest import mock@@ -16,48 +15,48 @@ class Bar(trackref.object_ref):pass-class TrackrefTestCase(unittest.TestCase):- def setUp(self):+class TestTrackref:+ def setup_method(self):trackref.live_refs.clear()def test_format_live_refs(self):o1 = Foo() # noqa: F841o2 = Bar() # noqa: F841o3 = Foo() # noqa: F841- self.assertEqual(- trackref.format_live_refs(),- """\+ assert (+ trackref.format_live_refs()+ == """\Live ReferencesBar 1 oldest: 0s agoFoo 2 oldest: 0s ago-""",+""")- self.assertEqual(- trackref.format_live_refs(ignore=Foo),- """\+ assert (+ trackref.format_live_refs(ignore=Foo)+ == """\Live ReferencesBar 1 oldest: 0s ago-""",+""")@mock.patch("sys.stdout", new_callable=StringIO)def test_print_live_refs_empty(self, stdout):trackref.print_live_refs()- self.assertEqual(stdout.getvalue(), "Live References\n\n\n")+ assert stdout.getvalue() == "Live References\n\n\n"@mock.patch("sys.stdout", new_callable=StringIO)def test_print_live_refs_with_objects(self, stdout):o1 = Foo() # noqa: F841trackref.print_live_refs()- self.assertEqual(- stdout.getvalue(),- """\+ assert (+ stdout.getvalue()+ == """\Live References-Foo 1 oldest: 0s ago\n\n""",+Foo 1 oldest: 0s ago\n\n""")def test_get_oldest(self):@@ -75,15 +74,12 @@ Foo 1 oldest: 0s ago\n\n""",raise SkipTest("time.time is not precise enough")o3 = Foo() # noqa: F841- self.assertIs(trackref.get_oldest("Foo"), o1)- self.assertIs(trackref.get_oldest("Bar"), o2)- self.assertIsNone(trackref.get_oldest("XXX"))+ assert trackref.get_oldest("Foo") is o1+ assert trackref.get_oldest("Bar") is o2+ assert trackref.get_oldest("XXX") is Nonedef test_iter_all(self):o1 = Foo()o2 = Bar() # noqa: F841o3 = Foo()- self.assertEqual(- set(trackref.iter_all("Foo")),- {o1, o3},- )+ assert set(trackref.iter_all("Foo")) == {o1, o3}diff --git a/tests/test_utils_url.py b/tests/test_utils_url.pyindex e99ef40c4..5841d6866 100644--- a/tests/test_utils_url.py+++ b/tests/test_utils_url.py@@ -18,301 +18,240 @@ from scrapy.utils.url import ( # type: ignore[attr-defined])-class UrlUtilsTest(unittest.TestCase):+class TestUrlUtils:def test_url_is_from_any_domain(self):url = "http://www.wheele-bin-art.co.uk/get/product/123"- self.assertTrue(url_is_from_any_domain(url, ["wheele-bin-art.co.uk"]))- self.assertFalse(url_is_from_any_domain(url, ["art.co.uk"]))+ assert url_is_from_any_domain(url, ["wheele-bin-art.co.uk"])+ assert not url_is_from_any_domain(url, ["art.co.uk"])url = "http://wheele-bin-art.co.uk/get/product/123"- self.assertTrue(url_is_from_any_domain(url, ["wheele-bin-art.co.uk"]))- self.assertFalse(url_is_from_any_domain(url, ["art.co.uk"]))+ assert url_is_from_any_domain(url, ["wheele-bin-art.co.uk"])+ assert not url_is_from_any_domain(url, ["art.co.uk"])url = "http://www.Wheele-Bin-Art.co.uk/get/product/123"- self.assertTrue(url_is_from_any_domain(url, ["wheele-bin-art.CO.UK"]))- self.assertTrue(url_is_from_any_domain(url, ["WHEELE-BIN-ART.CO.UK"]))+ assert url_is_from_any_domain(url, ["wheele-bin-art.CO.UK"])+ assert url_is_from_any_domain(url, ["WHEELE-BIN-ART.CO.UK"])url = "http://192.169.0.15:8080/mypage.html"- self.assertTrue(url_is_from_any_domain(url, ["192.169.0.15:8080"]))- self.assertFalse(url_is_from_any_domain(url, ["192.169.0.15"]))+ assert url_is_from_any_domain(url, ["192.169.0.15:8080"])+ assert not url_is_from_any_domain(url, ["192.169.0.15"])url = ("javascript:%20document.orderform_2581_1190810811.mode.value=%27add%27;%20""javascript:%20document.orderform_2581_1190810811.submit%28%29")- self.assertFalse(url_is_from_any_domain(url, ["testdomain.com"]))- self.assertFalse(- url_is_from_any_domain(url + ".testdomain.com", ["testdomain.com"])- )+ assert not url_is_from_any_domain(url, ["testdomain.com"])+ assert not url_is_from_any_domain(url + ".testdomain.com", ["testdomain.com"])def test_url_is_from_spider(self):spider = Spider(name="example.com")- self.assertTrue(- url_is_from_spider("http://www.example.com/some/page.html", spider)- )- self.assertTrue(- url_is_from_spider("http://sub.example.com/some/page.html", spider)- )- self.assertFalse(- url_is_from_spider("http://www.example.org/some/page.html", spider)- )- self.assertFalse(- url_is_from_spider("http://www.example.net/some/page.html", spider)- )+ assert url_is_from_spider("http://www.example.com/some/page.html", spider)+ assert url_is_from_spider("http://sub.example.com/some/page.html", spider)+ assert not url_is_from_spider("http://www.example.org/some/page.html", spider)+ assert not url_is_from_spider("http://www.example.net/some/page.html", spider)def test_url_is_from_spider_class_attributes(self):class MySpider(Spider):name = "example.com"- self.assertTrue(- url_is_from_spider("http://www.example.com/some/page.html", MySpider)- )- self.assertTrue(- url_is_from_spider("http://sub.example.com/some/page.html", MySpider)- )- self.assertFalse(- url_is_from_spider("http://www.example.org/some/page.html", MySpider)- )- self.assertFalse(- url_is_from_spider("http://www.example.net/some/page.html", MySpider)- )+ assert url_is_from_spider("http://www.example.com/some/page.html", MySpider)+ assert url_is_from_spider("http://sub.example.com/some/page.html", MySpider)+ assert not url_is_from_spider("http://www.example.org/some/page.html", MySpider)+ assert not url_is_from_spider("http://www.example.net/some/page.html", MySpider)def test_url_is_from_spider_with_allowed_domains(self):spider = Spider(name="example.com", allowed_domains=["example.org", "example.net"])- self.assertTrue(- url_is_from_spider("http://www.example.com/some/page.html", spider)- )- self.assertTrue(- url_is_from_spider("http://sub.example.com/some/page.html", spider)- )- self.assertTrue(url_is_from_spider("http://example.com/some/page.html", spider))- self.assertTrue(- url_is_from_spider("http://www.example.org/some/page.html", spider)- )- self.assertTrue(- url_is_from_spider("http://www.example.net/some/page.html", spider)- )- self.assertFalse(- url_is_from_spider("http://www.example.us/some/page.html", spider)- )+ assert url_is_from_spider("http://www.example.com/some/page.html", spider)+ assert url_is_from_spider("http://sub.example.com/some/page.html", spider)+ assert url_is_from_spider("http://example.com/some/page.html", spider)+ assert url_is_from_spider("http://www.example.org/some/page.html", spider)+ assert url_is_from_spider("http://www.example.net/some/page.html", spider)+ assert not url_is_from_spider("http://www.example.us/some/page.html", spider)spider = Spider(name="example.com", allowed_domains={"example.com", "example.net"})- self.assertTrue(- url_is_from_spider("http://www.example.com/some/page.html", spider)- )+ assert url_is_from_spider("http://www.example.com/some/page.html", spider)spider = Spider(name="example.com", allowed_domains=("example.com", "example.net"))- self.assertTrue(- url_is_from_spider("http://www.example.com/some/page.html", spider)- )+ assert url_is_from_spider("http://www.example.com/some/page.html", spider)def test_url_is_from_spider_with_allowed_domains_class_attributes(self):class MySpider(Spider):name = "example.com"allowed_domains = ("example.org", "example.net")- self.assertTrue(- url_is_from_spider("http://www.example.com/some/page.html", MySpider)- )- self.assertTrue(- url_is_from_spider("http://sub.example.com/some/page.html", MySpider)- )- self.assertTrue(- url_is_from_spider("http://example.com/some/page.html", MySpider)- )- self.assertTrue(- url_is_from_spider("http://www.example.org/some/page.html", MySpider)- )- self.assertTrue(- url_is_from_spider("http://www.example.net/some/page.html", MySpider)- )- self.assertFalse(- url_is_from_spider("http://www.example.us/some/page.html", MySpider)- )+ assert url_is_from_spider("http://www.example.com/some/page.html", MySpider)+ assert url_is_from_spider("http://sub.example.com/some/page.html", MySpider)+ assert url_is_from_spider("http://example.com/some/page.html", MySpider)+ assert url_is_from_spider("http://www.example.org/some/page.html", MySpider)+ assert url_is_from_spider("http://www.example.net/some/page.html", MySpider)+ assert not url_is_from_spider("http://www.example.us/some/page.html", MySpider)def test_url_has_any_extension(self):deny_extensions = {"." + e for e in arg_to_iter(IGNORED_EXTENSIONS)}- self.assertTrue(- url_has_any_extension(- "http://www.example.com/archive.tar.gz", deny_extensions- )- )- self.assertTrue(- url_has_any_extension("http://www.example.com/page.doc", deny_extensions)+ assert url_has_any_extension(+ "http://www.example.com/archive.tar.gz", deny_extensions)- self.assertTrue(- url_has_any_extension("http://www.example.com/page.pdf", deny_extensions)+ assert url_has_any_extension("http://www.example.com/page.doc", deny_extensions)+ assert url_has_any_extension("http://www.example.com/page.pdf", deny_extensions)+ assert not url_has_any_extension(+ "http://www.example.com/page.htm", deny_extensions)- self.assertFalse(- url_has_any_extension("http://www.example.com/page.htm", deny_extensions)- )- self.assertFalse(- url_has_any_extension("http://www.example.com/", deny_extensions)- )- self.assertFalse(- url_has_any_extension(- "http://www.example.com/page.doc.html", deny_extensions- )+ assert not url_has_any_extension("http://www.example.com/", deny_extensions)+ assert not url_has_any_extension(+ "http://www.example.com/page.doc.html", deny_extensions)-class AddHttpIfNoScheme(unittest.TestCase):+class TestAddHttpIfNoScheme:def test_add_scheme(self):- self.assertEqual(- add_http_if_no_scheme("www.example.com"), "http://www.example.com"- )+ assert add_http_if_no_scheme("www.example.com") == "http://www.example.com"def test_without_subdomain(self):- self.assertEqual(add_http_if_no_scheme("example.com"), "http://example.com")+ assert add_http_if_no_scheme("example.com") == "http://example.com"def test_path(self):- self.assertEqual(- add_http_if_no_scheme("www.example.com/some/page.html"),- "http://www.example.com/some/page.html",+ assert (+ add_http_if_no_scheme("www.example.com/some/page.html")+ == "http://www.example.com/some/page.html")def test_port(self):- self.assertEqual(- add_http_if_no_scheme("www.example.com:80"), "http://www.example.com:80"+ assert (+ add_http_if_no_scheme("www.example.com:80") == "http://www.example.com:80")def test_fragment(self):- self.assertEqual(- add_http_if_no_scheme("www.example.com/some/page#frag"),- "http://www.example.com/some/page#frag",+ assert (+ add_http_if_no_scheme("www.example.com/some/page#frag")+ == "http://www.example.com/some/page#frag")def test_query(self):- self.assertEqual(- add_http_if_no_scheme("www.example.com/do?a=1&b=2&c=3"),- "http://www.example.com/do?a=1&b=2&c=3",+ assert (+ add_http_if_no_scheme("www.example.com/do?a=1&b=2&c=3")+ == "http://www.example.com/do?a=1&b=2&c=3")def test_username_password(self):- self.assertEqual(- add_http_if_no_scheme("username:[email protected]"),- "http://username:[email protected]",+ assert (+ add_http_if_no_scheme("username:[email protected]")+ == "http://username:[email protected]")def test_complete_url(self):- self.assertEqual(+ assert (add_http_if_no_scheme("username:[email protected]:80/some/page/do?a=1&b=2&c=3#frag"- ),- "http://username:[email protected]:80/some/page/do?a=1&b=2&c=3#frag",+ )+ == "http://username:[email protected]:80/some/page/do?a=1&b=2&c=3#frag")def test_preserve_http(self):- self.assertEqual(- add_http_if_no_scheme("http://www.example.com"), "http://www.example.com"+ assert (+ add_http_if_no_scheme("http://www.example.com") == "http://www.example.com")def test_preserve_http_without_subdomain(self):- self.assertEqual(- add_http_if_no_scheme("http://example.com"), "http://example.com"- )+ assert add_http_if_no_scheme("http://example.com") == "http://example.com"def test_preserve_http_path(self):- self.assertEqual(- add_http_if_no_scheme("http://www.example.com/some/page.html"),- "http://www.example.com/some/page.html",+ assert (+ add_http_if_no_scheme("http://www.example.com/some/page.html")+ == "http://www.example.com/some/page.html")def test_preserve_http_port(self):- self.assertEqual(- add_http_if_no_scheme("http://www.example.com:80"),- "http://www.example.com:80",+ assert (+ add_http_if_no_scheme("http://www.example.com:80")+ == "http://www.example.com:80")def test_preserve_http_fragment(self):- self.assertEqual(- add_http_if_no_scheme("http://www.example.com/some/page#frag"),- "http://www.example.com/some/page#frag",+ assert (+ add_http_if_no_scheme("http://www.example.com/some/page#frag")+ == "http://www.example.com/some/page#frag")def test_preserve_http_query(self):- self.assertEqual(- add_http_if_no_scheme("http://www.example.com/do?a=1&b=2&c=3"),- "http://www.example.com/do?a=1&b=2&c=3",+ assert (+ add_http_if_no_scheme("http://www.example.com/do?a=1&b=2&c=3")+ == "http://www.example.com/do?a=1&b=2&c=3")def test_preserve_http_username_password(self):- self.assertEqual(- add_http_if_no_scheme("http://username:[email protected]"),- "http://username:[email protected]",+ assert (+ add_http_if_no_scheme("http://username:[email protected]")+ == "http://username:[email protected]")def test_preserve_http_complete_url(self):- self.assertEqual(+ assert (add_http_if_no_scheme("http://username:[email protected]:80/some/page/do?a=1&b=2&c=3#frag"- ),- "http://username:[email protected]:80/some/page/do?a=1&b=2&c=3#frag",+ )+ == "http://username:[email protected]:80/some/page/do?a=1&b=2&c=3#frag")def test_protocol_relative(self):- self.assertEqual(- add_http_if_no_scheme("//www.example.com"), "http://www.example.com"- )+ assert add_http_if_no_scheme("//www.example.com") == "http://www.example.com"def test_protocol_relative_without_subdomain(self):- self.assertEqual(add_http_if_no_scheme("//example.com"), "http://example.com")+ assert add_http_if_no_scheme("//example.com") == "http://example.com"def test_protocol_relative_path(self):- self.assertEqual(- add_http_if_no_scheme("//www.example.com/some/page.html"),- "http://www.example.com/some/page.html",+ assert (+ add_http_if_no_scheme("//www.example.com/some/page.html")+ == "http://www.example.com/some/page.html")def test_protocol_relative_port(self):- self.assertEqual(- add_http_if_no_scheme("//www.example.com:80"), "http://www.example.com:80"+ assert (+ add_http_if_no_scheme("//www.example.com:80") == "http://www.example.com:80")def test_protocol_relative_fragment(self):- self.assertEqual(- add_http_if_no_scheme("//www.example.com/some/page#frag"),- "http://www.example.com/some/page#frag",+ assert (+ add_http_if_no_scheme("//www.example.com/some/page#frag")+ == "http://www.example.com/some/page#frag")def test_protocol_relative_query(self):- self.assertEqual(- add_http_if_no_scheme("//www.example.com/do?a=1&b=2&c=3"),- "http://www.example.com/do?a=1&b=2&c=3",+ assert (+ add_http_if_no_scheme("//www.example.com/do?a=1&b=2&c=3")+ == "http://www.example.com/do?a=1&b=2&c=3")def test_protocol_relative_username_password(self):- self.assertEqual(- add_http_if_no_scheme("//username:[email protected]"),- "http://username:[email protected]",+ assert (+ add_http_if_no_scheme("//username:[email protected]")+ == "http://username:[email protected]")def test_protocol_relative_complete_url(self):- self.assertEqual(+ assert (add_http_if_no_scheme("//username:[email protected]:80/some/page/do?a=1&b=2&c=3#frag"- ),- "http://username:[email protected]:80/some/page/do?a=1&b=2&c=3#frag",+ )+ == "http://username:[email protected]:80/some/page/do?a=1&b=2&c=3#frag")def test_preserve_https(self):- self.assertEqual(- add_http_if_no_scheme("https://www.example.com"), "https://www.example.com"+ assert (+ add_http_if_no_scheme("https://www.example.com")+ == "https://www.example.com")def test_preserve_ftp(self):- self.assertEqual(- add_http_if_no_scheme("ftp://www.example.com"), "ftp://www.example.com"- )+ assert add_http_if_no_scheme("ftp://www.example.com") == "ftp://www.example.com"-class GuessSchemeTest(unittest.TestCase):+class TestGuessScheme:pass@@ -361,7 +300,7 @@ for k, args in enumerate():t_method = create_guess_scheme_t(args)t_method.__name__ = f"test_uri_{k:03}"- setattr(GuessSchemeTest, t_method.__name__, t_method)+ setattr(TestGuessScheme, t_method.__name__, t_method)# TODO: the following tests do not pass with current implementationfor k, skip_args in enumerate(@@ -376,29 +315,29 @@ for k, skip_args in enumerate():t_method = create_skipped_scheme_t(skip_args)t_method.__name__ = f"test_uri_skipped_{k:03}"- setattr(GuessSchemeTest, t_method.__name__, t_method)+ setattr(TestGuessScheme, t_method.__name__, t_method)-class StripUrl(unittest.TestCase):+class TestStripUrl:def test_noop(self):- self.assertEqual(- strip_url("http://www.example.com/index.html"),- "http://www.example.com/index.html",+ assert (+ strip_url("http://www.example.com/index.html")+ == "http://www.example.com/index.html")def test_noop_query_string(self):- self.assertEqual(- strip_url("http://www.example.com/index.html?somekey=somevalue"),- "http://www.example.com/index.html?somekey=somevalue",+ assert (+ strip_url("http://www.example.com/index.html?somekey=somevalue")+ == "http://www.example.com/index.html?somekey=somevalue")def test_fragments(self):- self.assertEqual(+ assert (strip_url("http://www.example.com/index.html?somekey=somevalue#section",strip_fragment=False,- ),- "http://www.example.com/index.html?somekey=somevalue#section",+ )+ == "http://www.example.com/index.html?somekey=somevalue#section")def test_path(self):@@ -407,7 +346,7 @@ class StripUrl(unittest.TestCase):("http://www.example.com", False, "http://www.example.com"),("http://www.example.com", True, "http://www.example.com/"),]:- self.assertEqual(strip_url(input_url, origin_only=origin), output_url)+ assert strip_url(input_url, origin_only=origin) == output_urldef test_credentials(self):for i, o in [@@ -424,7 +363,7 @@ class StripUrl(unittest.TestCase):"ftp://www.example.com/index.html?somekey=somevalue",),]:- self.assertEqual(strip_url(i, strip_credentials=True), o)+ assert strip_url(i, strip_credentials=True) == odef test_credentials_encoded_delims(self):for i, o in [@@ -447,7 +386,7 @@ class StripUrl(unittest.TestCase):"ftp://www.example.com/index.html?somekey=somevalue",),]:- self.assertEqual(strip_url(i, strip_credentials=True), o)+ assert strip_url(i, strip_credentials=True) == odef test_default_ports_creds_off(self):for i, o in [@@ -484,7 +423,7 @@ class StripUrl(unittest.TestCase):"ftp://www.example.com:221/file.txt",),]:- self.assertEqual(strip_url(i), o)+ assert strip_url(i) == odef test_default_ports(self):for i, o in [@@ -521,9 +460,7 @@ class StripUrl(unittest.TestCase):"ftp://username:[email protected]:221/file.txt",),]:- self.assertEqual(- strip_url(i, strip_default_port=True, strip_credentials=False), o- )+ assert strip_url(i, strip_default_port=True, strip_credentials=False) == odef test_default_ports_keep(self):for i, o in [@@ -560,9 +497,7 @@ class StripUrl(unittest.TestCase):"ftp://username:[email protected]:221/file.txt",),]:- self.assertEqual(- strip_url(i, strip_default_port=False, strip_credentials=False), o- )+ assert strip_url(i, strip_default_port=False, strip_credentials=False) == odef test_origin_only(self):for i, o in [@@ -583,10 +518,10 @@ class StripUrl(unittest.TestCase):"https://www.example.com/",),]:- self.assertEqual(strip_url(i, origin_only=True), o)+ assert strip_url(i, origin_only=True) == o-class IsPathTestCase(unittest.TestCase):+class TestIsPath:def test_path(self):for input_value, output_value in (# https://en.wikipedia.org/wiki/Path_(computing)#Representations_of_paths_by_operating_system_and_shell@@ -604,9 +539,7 @@ class IsPathTestCase(unittest.TestCase):(r"C:\user\docs\somefile.ext:alternate_stream_name", True),(r"https://example.com", False),):- self.assertEqual(- _is_filesystem_path(input_value), output_value, input_value- )+ assert _is_filesystem_path(input_value) == output_value, input_value@pytest.mark.parametrize(