style: Rewrite asyncFetcher tests to a cleaner version

tests/fetchers/async/test_async_httpx.py

@@ -1,92 +1,83 @@
-import asyncio
+import pytest
-import unittest
-
 import pytest_httpbin
 
 from scrapling.fetchers import AsyncFetcher
 
 
 @pytest_httpbin.use_class_based_httpbin
-class TestAsyncFetcher(unittest.TestCase):
+@pytest.mark.asyncio
-    def setUp(self):
+class TestAsyncFetcher:
-        self.fetcher = AsyncFetcher(auto_match=True)
+    @pytest.fixture(scope="class")
-        url = self.httpbin.url
+    def fetcher(self):
-        self.status_200 = f'{url}/status/200'
+        return AsyncFetcher(auto_match=True)
-        self.status_404 = f'{url}/status/404'
-        self.status_501 = f'{url}/status/501'
-        self.basic_url = f'{url}/get'
-        self.post_url = f'{url}/post'
-        self.put_url = f'{url}/put'
-        self.delete_url = f'{url}/delete'
-        self.html_url = f'{url}/html'
 
-    async def async_test(self, coro):
+    @pytest.fixture(scope="class")
-        return await coro
+    def urls(self, httpbin):
+        return {
+            'status_200': f'{httpbin.url}/status/200',
+            'status_404': f'{httpbin.url}/status/404',
+            'status_501': f'{httpbin.url}/status/501',
+            'basic_url': f'{httpbin.url}/get',
+            'post_url': f'{httpbin.url}/post',
+            'put_url': f'{httpbin.url}/put',
+            'delete_url': f'{httpbin.url}/delete',
+            'html_url': f'{httpbin.url}/html'
+        }
 
-    def test_basic_get(self):
+    async def test_basic_get(self, fetcher, urls):
         """Test doing basic get request with multiple statuses"""
+        assert (await fetcher.get(urls['status_200'])).status == 200
+        assert (await fetcher.get(urls['status_404'])).status == 404
+        assert (await fetcher.get(urls['status_501'])).status == 501
 
-        async def run_tests():
+    async def test_get_properties(self, fetcher, urls):
-            self.assertEqual((await self.fetcher.get(self.status_200)).status, 200)
-            self.assertEqual((await self.fetcher.get(self.status_404)).status, 404)
-            self.assertEqual((await self.fetcher.get(self.status_501)).status, 501)
-
-        asyncio.run(run_tests())
-
-    def test_get_properties(self):
         """Test if different arguments with GET request breaks the code or not"""
+        assert (await fetcher.get(urls['status_200'], stealthy_headers=True)).status == 200
+        assert (await fetcher.get(urls['status_200'], follow_redirects=True)).status == 200
+        assert (await fetcher.get(urls['status_200'], timeout=None)).status == 200
+        assert (await fetcher.get(
+            urls['status_200'],
+            stealthy_headers=True,
+            follow_redirects=True,
+            timeout=None
+        )).status == 200
 
-        async def run_tests():
+    async def test_post_properties(self, fetcher, urls):
-            self.assertEqual((await self.fetcher.get(self.status_200, stealthy_headers=True)).status, 200)
-            self.assertEqual((await self.fetcher.get(self.status_200, follow_redirects=True)).status, 200)
-            self.assertEqual((await self.fetcher.get(self.status_200, timeout=None)).status, 200)
-            self.assertEqual(
-                (await self.fetcher.get(self.status_200, stealthy_headers=True, follow_redirects=True, timeout=None)).status,
-                200
-            )
-
-        asyncio.run(run_tests())
-
-    def test_post_properties(self):
         """Test if different arguments with POST request breaks the code or not"""
+        assert (await fetcher.post(urls['post_url'], data={'key': 'value'})).status == 200
+        assert (await fetcher.post(urls['post_url'], data={'key': 'value'}, stealthy_headers=True)).status == 200
+        assert (await fetcher.post(urls['post_url'], data={'key': 'value'}, follow_redirects=True)).status == 200
+        assert (await fetcher.post(urls['post_url'], data={'key': 'value'}, timeout=None)).status == 200
+        assert (await fetcher.post(
+            urls['post_url'],
+            data={'key': 'value'},
+            stealthy_headers=True,
+            follow_redirects=True,
+            timeout=None
+        )).status == 200
 
-        async def run_tests():
+    async def test_put_properties(self, fetcher, urls):
-            self.assertEqual((await self.fetcher.post(self.post_url, data={'key': 'value'})).status, 200)
-            self.assertEqual((await self.fetcher.post(self.post_url, data={'key': 'value'}, stealthy_headers=True)).status, 200)
-            self.assertEqual((await self.fetcher.post(self.post_url, data={'key': 'value'}, follow_redirects=True)).status, 200)
-            self.assertEqual((await self.fetcher.post(self.post_url, data={'key': 'value'}, timeout=None)).status, 200)
-            self.assertEqual(
-                (await self.fetcher.post(self.post_url, data={'key': 'value'}, stealthy_headers=True, follow_redirects=True, timeout=None)).status,
-                200
-            )
-
-        asyncio.run(run_tests())
-
-    def test_put_properties(self):
         """Test if different arguments with PUT request breaks the code or not"""
+        assert (await fetcher.put(urls['put_url'], data={'key': 'value'})).status in [200, 405]
+        assert (await fetcher.put(urls['put_url'], data={'key': 'value'}, stealthy_headers=True)).status in [200, 405]
+        assert (await fetcher.put(urls['put_url'], data={'key': 'value'}, follow_redirects=True)).status in [200, 405]
+        assert (await fetcher.put(urls['put_url'], data={'key': 'value'}, timeout=None)).status in [200, 405]
+        assert (await fetcher.put(
+            urls['put_url'],
+            data={'key': 'value'},
+            stealthy_headers=True,
+            follow_redirects=True,
+            timeout=None
+        )).status in [200, 405]
 
-        async def run_tests():
+    async def test_delete_properties(self, fetcher, urls):
-            self.assertIn((await self.fetcher.put(self.put_url, data={'key': 'value'})).status, [200, 405])
-            self.assertIn((await self.fetcher.put(self.put_url, data={'key': 'value'}, stealthy_headers=True)).status, [200, 405])
-            self.assertIn((await self.fetcher.put(self.put_url, data={'key': 'value'}, follow_redirects=True)).status, [200, 405])
-            self.assertIn((await self.fetcher.put(self.put_url, data={'key': 'value'}, timeout=None)).status, [200, 405])
-            self.assertIn(
-                (await self.fetcher.put(self.put_url, data={'key': 'value'}, stealthy_headers=True, follow_redirects=True, timeout=None)).status,
-                [200, 405]
-            )
-
-        asyncio.run(run_tests())
-
-    def test_delete_properties(self):
         """Test if different arguments with DELETE request breaks the code or not"""
-
+        assert (await fetcher.delete(urls['delete_url'], stealthy_headers=True)).status == 200
-        async def run_tests():
+        assert (await fetcher.delete(urls['delete_url'], follow_redirects=True)).status == 200
-            self.assertEqual((await self.fetcher.delete(self.delete_url, stealthy_headers=True)).status, 200)
+        assert (await fetcher.delete(urls['delete_url'], timeout=None)).status == 200
-            self.assertEqual((await self.fetcher.delete(self.delete_url, follow_redirects=True)).status, 200)
+        assert (await fetcher.delete(
-            self.assertEqual((await self.fetcher.delete(self.delete_url, timeout=None)).status, 200)
+            urls['delete_url'],
-            self.assertEqual(
+            stealthy_headers=True,
-                (await self.fetcher.delete(self.delete_url, stealthy_headers=True, follow_redirects=True, timeout=None)).status,
+            follow_redirects=True,
-                200
+            timeout=None
-            )
+        )).status == 200
-
-        asyncio.run(run_tests())