Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-mocket for openSUSE:Factory checked in at 2023-02-18 17:10:14 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-mocket (Old) and /work/SRC/openSUSE:Factory/.python-mocket.new.22824 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-mocket" Sat Feb 18 17:10:14 2023 rev:25 rq:1065962 version:3.10.9 Changes: -------- --- /work/SRC/openSUSE:Factory/python-mocket/python-mocket.changes 2023-01-10 14:58:49.480889785 +0100 +++ /work/SRC/openSUSE:Factory/.python-mocket.new.22824/python-mocket.changes 2023-02-18 17:10:17.554700699 +0100 @@ -1,0 +2,14 @@ +Thu Feb 2 11:44:50 UTC 2023 - Dirk Müller <dmuel...@suse.com> + +- add these commits as patches from the upstream PR: + 0007-Switching-to-httptools.parser.HttpRequestParser.patch + 0008-Disabling-tests-for-pook-when-testing-Python-3.11.patch + 0009-Removing-DeprecationWarning-all-over-the-place.patch + 0010-Python-3.11-needs-an-async-decorator.patch + 0012-Removing-async-timeout-dependency.patch + 0013-Refactoring-using-event_loop-fixture.patch + 0014-Refactoring-using-tempfile-as-a-context-manager.patch + 0015-Skip-those-tests-and-see-what-happens-to-the-rest.patch +- skip now failing tests, update buildrequires for tests on py 3.11 + +------------------------------------------------------------------- New: ---- 0007-Switching-to-httptools.parser.HttpRequestParser.patch 0008-Disabling-tests-for-pook-when-testing-Python-3.11.patch 0009-Removing-DeprecationWarning-all-over-the-place.patch 0010-Python-3.11-needs-an-async-decorator.patch 0012-Removing-async-timeout-dependency.patch 0013-Refactoring-using-event_loop-fixture.patch 0014-Refactoring-using-tempfile-as-a-context-manager.patch 0015-Skip-those-tests-and-see-what-happens-to-the-rest.patch ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-mocket.spec ++++++ --- /var/tmp/diff_new_pack.03XBNR/_old 2023-02-18 17:10:18.138704387 +0100 +++ /var/tmp/diff_new_pack.03XBNR/_new 2023-02-18 17:10:18.142704412 +0100 @@ -33,11 +33,21 @@ License: BSD-3-Clause URL: https://github.com/mindflayer/python-mocket Source0: https://files.pythonhosted.org/packages/source/m/mocket/mocket-%{version}.tar.gz +# PATCH-FIX-UPSTREAM: taken from https://github.com/mindflayer/python-mocket/pull/181 +Patch1: 0007-Switching-to-httptools.parser.HttpRequestParser.patch +Patch2: 0008-Disabling-tests-for-pook-when-testing-Python-3.11.patch +Patch3: 0009-Removing-DeprecationWarning-all-over-the-place.patch +Patch4: 0010-Python-3.11-needs-an-async-decorator.patch +Patch5: 0012-Removing-async-timeout-dependency.patch +Patch6: 0013-Refactoring-using-event_loop-fixture.patch +Patch7: 0014-Refactoring-using-tempfile-as-a-context-manager.patch +Patch8: 0015-Skip-those-tests-and-see-what-happens-to-the-rest.patch BuildRequires: %{python_module setuptools} BuildRequires: fdupes BuildRequires: python-rpm-macros Requires: python-decorator >= 4 Requires: python-http-parser >= 0.9.0 +Requires: python-httptools Requires: python-python-magic >= 0.4.5 Requires: python-urllib3 >= 1.25.3 Suggests: python-pook >= 0.2.1 @@ -45,9 +55,10 @@ BuildArch: noarch %if %{with test} BuildRequires: %{python_module aiohttp} -BuildRequires: %{python_module async_timeout} +BuildRequires: %{python_module asgiref} BuildRequires: %{python_module fastapi} BuildRequires: %{python_module gevent} +BuildRequires: %{python_module httptools} BuildRequires: %{python_module mocket = %{version}} BuildRequires: %{python_module pook >= 0.2.1} BuildRequires: %{python_module pytest} @@ -64,7 +75,7 @@ included, with gevent/asyncio/SSL support. %prep -%setup -q -n mocket-%{version} +%autosetup -p1 -n mocket-%{version} sed -i '/cov/ d' setup.cfg sed -i '/pipenv/ d' setup.py @@ -97,6 +108,8 @@ %if %{pkg_vcmp python3-httpx < 0.23} donttest="$donttest or test_truesendall_with_dump_from_recording" %endif +# these fail after the python 3.11 patches +donttest="$donttest or test_http_session or test_https_session or test_httprettish_session" %pytest -rfEs -k "not ($donttest)" ${pytest_$python_ignore} %endif ++++++ 0007-Switching-to-httptools.parser.HttpRequestParser.patch ++++++ >From dbf7b8d2ce480285ec30c682eb746d912d1304a3 Mon Sep 17 00:00:00 2001 From: Giorgio Salluzzo <giorgio.sallu...@gmail.com> Date: Mon, 5 Dec 2022 00:54:16 +0100 Subject: [PATCH 07/15] Switching to `httptools.parser.HttpRequestParser`. --- Pipfile | 2 +- mocket/mockhttp.py | 71 +++++++++++++++++++--------- mocket/plugins/httpretty/__init__.py | 10 ++-- tests/main/test_http.py | 2 +- 4 files changed, 56 insertions(+), 29 deletions(-) Index: mocket-3.10.9/mocket/mockhttp.py =================================================================== --- mocket-3.10.9.orig/mocket/mockhttp.py +++ mocket-3.10.9/mocket/mockhttp.py @@ -3,13 +3,10 @@ import time from http.server import BaseHTTPRequestHandler from urllib.parse import parse_qs, unquote, urlsplit -from .compat import decode_from_bytes, do_the_magic, encode_to_bytes -from .mocket import Mocket, MocketEntry +from httptools.parser import HttpRequestParser -try: - from http_parser.parser import HttpParser -except ImportError: - from http_parser.pyparser import HttpParser +from .compat import ENCODING, decode_from_bytes, do_the_magic, encode_to_bytes +from .mocket import Mocket, MocketEntry try: import magic @@ -21,31 +18,59 @@ STATUS = {k: v[0] for k, v in BaseHTTPRe CRLF = "\r\n" +class Protocol: + def __init__(self): + self.url = None + self.body = None + self.headers = {} + + def on_header(self, name: bytes, value: bytes): + self.headers[name.decode("ascii")] = value.decode("ascii") + + def on_body(self, body: bytes): + try: + self.body = body.decode(ENCODING) + except UnicodeDecodeError: + self.body = body + + def on_url(self, url: bytes): + self.url = url.decode("ascii") + + class Request: - parser = None - _body = None + _protocol = None + _parser = None def __init__(self, data): - self.parser = HttpParser() - self.parser.execute(data, len(data)) - - self.method = self.parser.get_method() - self.path = self.parser.get_path() - self.headers = self.parser.get_headers() - self.querystring = parse_qs( - unquote(self.parser.get_query_string()), keep_blank_values=True - ) - if self.querystring: - self.path += "?{}".format(self.parser.get_query_string()) + self._protocol = Protocol() + self._parser = HttpRequestParser(self._protocol) + self.add_data(data) def add_data(self, data): - self.parser.execute(data, len(data)) + self._parser.feed_data(data) + + @property + def method(self): + return self._parser.get_method().decode("ascii") + + @property + def path(self): + return self._protocol.url + + @property + def headers(self): + return self._protocol.headers + + @property + def querystring(self): + parts = self._protocol.url.split("?", 1) + if len(parts) == 2: + return parse_qs(unquote(parts[1]), keep_blank_values=True) + return {} @property def body(self): - if self._body is None: - self._body = decode_from_bytes(self.parser.recv_body()) - return self._body + return self._protocol.body def __str__(self): return "{} - {} - {}".format(self.method, self.path, self.headers) Index: mocket-3.10.9/mocket/plugins/httpretty/__init__.py =================================================================== --- mocket-3.10.9.orig/mocket/plugins/httpretty/__init__.py +++ mocket-3.10.9/mocket/plugins/httpretty/__init__.py @@ -1,6 +1,6 @@ from mocket import Mocket, mocketize from mocket.async_mocket import async_mocketize -from mocket.compat import byte_type, text_type +from mocket.compat import ENCODING, byte_type, text_type from mocket.mockhttp import Entry as MocketHttpEntry from mocket.mockhttp import Request as MocketHttpRequest from mocket.mockhttp import Response as MocketHttpResponse @@ -13,9 +13,11 @@ def httprettifier_headers(headers): class Request(MocketHttpRequest): @property def body(self): - if self._body is None: - self._body = self.parser.recv_body() - return self._body + return super().body.encode(ENCODING) + + @property + def headers(self): + return httprettifier_headers(super().headers) class Response(MocketHttpResponse): Index: mocket-3.10.9/tests/main/test_http.py =================================================================== --- mocket-3.10.9.orig/tests/main/test_http.py +++ mocket-3.10.9/tests/main/test_http.py @@ -23,7 +23,7 @@ class HttpTestCase(TestCase): def assertEqualHeaders(self, first, second, msg=None): first = {k.lower(): v for k, v in first.items()} second = {k.lower(): v for k, v in second.items()} - self.assertEqual(first, second, msg) + self.assertDictEqual(first, second, msg) @pytest.mark.skipif('os.getenv("SKIP_TRUE_HTTP", False)') ++++++ 0008-Disabling-tests-for-pook-when-testing-Python-3.11.patch ++++++ >From 5e0d8a8b75280372536bc85ea44b82e0acc841c4 Mon Sep 17 00:00:00 2001 From: Giorgio Salluzzo <giorgio.sallu...@gmail.com> Date: Mon, 5 Dec 2022 01:08:23 +0100 Subject: [PATCH 08/15] Disabling tests for `pook` when testing Python 3.11 --- mocket/plugins/pook_mock_engine.py | 147 +++++++++++++++-------------- setup.py | 1 + tests/main/test_pook.py | 47 ++++----- 3 files changed, 102 insertions(+), 93 deletions(-) diff --git a/mocket/plugins/pook_mock_engine.py b/mocket/plugins/pook_mock_engine.py index 5b1d207..8df8776 100644 --- a/mocket/plugins/pook_mock_engine.py +++ b/mocket/plugins/pook_mock_engine.py @@ -1,71 +1,76 @@ -from pook.engine import MockEngine -from pook.interceptors.base import BaseInterceptor - -from mocket.mocket import Mocket -from mocket.mockhttp import Entry, Response - - -class MocketPookEntry(Entry): - pook_request = None - pook_engine = None - - def can_handle(self, data): - can_handle = super(MocketPookEntry, self).can_handle(data) - - if can_handle: - self.pook_engine.match(self.pook_request) - return can_handle - - @classmethod - def single_register(cls, method, uri, body='', status=200, headers=None, match_querystring=True): - entry = cls( - uri, method, Response( - body=body, status=status, headers=headers - ), match_querystring=match_querystring - ) - Mocket.register(entry) - return entry - - -class MocketInterceptor(BaseInterceptor): - @staticmethod - def activate(): - Mocket.disable() - Mocket.enable() - - @staticmethod - def disable(): - Mocket.disable() - - -class MocketEngine(MockEngine): - - def __init__(self, engine): - def mocket_mock_fun(*args, **kwargs): - mock = self.pook_mock_fun(*args, **kwargs) - - request = mock._request - method = request.method - url = request.rawurl - - response = mock._response - body = response._body - status = response._status - headers = response._headers - - entry = MocketPookEntry.single_register(method, url, body, status, headers) - entry.pook_engine = self.engine - entry.pook_request = request - - return mock - - # Store plugins engine - self.engine = engine - # Store HTTP client interceptors - self.interceptors = [] - # Self-register MocketInterceptor - self.add_interceptor(MocketInterceptor) - - # mocking pook.mock() - self.pook_mock_fun = self.engine.mock - self.engine.mock = mocket_mock_fun +import platform + +if not platform.python_version().startswith("3.11."): + # it looks like `pook` is not compatible with Python 3.11 + from pook.engine import MockEngine + from pook.interceptors.base import BaseInterceptor + + from mocket.mocket import Mocket + from mocket.mockhttp import Entry, Response + + class MocketPookEntry(Entry): + pook_request = None + pook_engine = None + + def can_handle(self, data): + can_handle = super(MocketPookEntry, self).can_handle(data) + + if can_handle: + self.pook_engine.match(self.pook_request) + return can_handle + + @classmethod + def single_register( + cls, method, uri, body="", status=200, headers=None, match_querystring=True + ): + entry = cls( + uri, + method, + Response(body=body, status=status, headers=headers), + match_querystring=match_querystring, + ) + Mocket.register(entry) + return entry + + class MocketInterceptor(BaseInterceptor): + @staticmethod + def activate(): + Mocket.disable() + Mocket.enable() + + @staticmethod + def disable(): + Mocket.disable() + + class MocketEngine(MockEngine): + def __init__(self, engine): + def mocket_mock_fun(*args, **kwargs): + mock = self.pook_mock_fun(*args, **kwargs) + + request = mock._request + method = request.method + url = request.rawurl + + response = mock._response + body = response._body + status = response._status + headers = response._headers + + entry = MocketPookEntry.single_register( + method, url, body, status, headers + ) + entry.pook_engine = self.engine + entry.pook_request = request + + return mock + + # Store plugins engine + self.engine = engine + # Store HTTP client interceptors + self.interceptors = [] + # Self-register MocketInterceptor + self.add_interceptor(MocketInterceptor) + + # mocking pook.mock() + self.pook_mock_fun = self.engine.mock + self.engine.mock = mocket_mock_fun diff --git a/setup.py b/setup.py index 544e624..145fced 100644 --- a/setup.py +++ b/setup.py @@ -57,6 +57,7 @@ setup( "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", "Programming Language :: Python :: Implementation :: CPython", "Programming Language :: Python :: Implementation :: PyPy", "Topic :: Software Development", diff --git a/tests/main/test_pook.py b/tests/main/test_pook.py index 2d95d3d..2207e8f 100644 --- a/tests/main/test_pook.py +++ b/tests/main/test_pook.py @@ -1,30 +1,33 @@ -import pook -import requests +import platform -from mocket.plugins.pook_mock_engine import MocketEngine +if not platform.python_version().startswith("3.11."): + # it looks like `pook` is not compatible with Python 3.11 + import pook + import requests -pook.set_mock_engine(MocketEngine) + from mocket.plugins.pook_mock_engine import MocketEngine + pook.set_mock_engine(MocketEngine) -@pook.on -def test_pook_engine(): + @pook.on + def test_pook_engine(): - url = "http://twitter.com/api/1/foobar"; - status = 404 - response_json = {"error": "foo"} + url = "http://twitter.com/api/1/foobar"; + status = 404 + response_json = {"error": "foo"} - mock = pook.get( - url, - headers={"content-type": "application/json"}, - reply=status, - response_json=response_json, - ) - mock.persist() + mock = pook.get( + url, + headers={"content-type": "application/json"}, + reply=status, + response_json=response_json, + ) + mock.persist() - requests.get(url) - assert mock.calls == 1 + requests.get(url) + assert mock.calls == 1 - resp = requests.get(url) - assert resp.status_code == status - assert resp.json() == response_json - assert mock.calls == 2 + resp = requests.get(url) + assert resp.status_code == status + assert resp.json() == response_json + assert mock.calls == 2 -- 2.39.1 ++++++ 0009-Removing-DeprecationWarning-all-over-the-place.patch ++++++ >From 10cf45b071776cd36f9c7070f5d47a26ea010d7d Mon Sep 17 00:00:00 2001 From: Giorgio Salluzzo <giorgio.sallu...@gmail.com> Date: Sat, 17 Dec 2022 12:09:48 +0100 Subject: [PATCH 09/15] Removing DeprecationWarning all over the place. --- README.rst | 14 +++++++------- tests/main/test_http_aiohttp.py | 16 ++++++++-------- tests/tests37/test_asyncio.py | 2 +- tests/tests38/test_http_aiohttp.py | 10 +++++----- 4 files changed, 21 insertions(+), 21 deletions(-) diff --git a/README.rst b/README.rst index 67cc956..a810dc1 100644 --- a/README.rst +++ b/README.rst @@ -249,12 +249,12 @@ Example: async def main(l): async with aiohttp.ClientSession(loop=l) as session: - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.get(url) as get_response: assert get_response.status == 200 assert await get_response.text() == '{"origin": "127.0.0.1"}' - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() loop.set_debug(True) loop.run_until_complete(main(loop)) @@ -278,17 +278,17 @@ Example: async def main(l): async with aiohttp.ClientSession(loop=l) as session: - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.get(url) as get_response: assert get_response.status == 404 assert await get_response.text() == body - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.post(url, data=body * 6) as post_response: assert post_response.status == 201 assert await post_response.text() == body * 2 - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() loop.run_until_complete(main(loop)) # or again with a unittest.IsolatedAsyncioTestCase @@ -303,12 +303,12 @@ Example: Entry.single_register(Entry.POST, url, body=body * 2, status=201) async with aiohttp.ClientSession() as session: - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.get(url) as get_response: assert get_response.status == 404 assert await get_response.text() == body - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.post(url, data=body * 6) as post_response: assert post_response.status == 201 assert await post_response.text() == body * 2 diff --git a/tests/main/test_http_aiohttp.py b/tests/main/test_http_aiohttp.py index 076fc93..6cfd2d8 100644 --- a/tests/main/test_http_aiohttp.py +++ b/tests/main/test_http_aiohttp.py @@ -20,19 +20,19 @@ class AioHttpEntryTestCase(TestCase): async def main(_loop): async with aiohttp.ClientSession(loop=_loop) as session: - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.get(url) as get_response: assert get_response.status == 404 assert await get_response.text() == body - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.post(url, data=body * 6) as post_response: assert post_response.status == 201 assert await post_response.text() == body * 2 assert Mocket.last_request().method == "POST" assert Mocket.last_request().body == body * 6 - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() loop.set_debug(True) loop.run_until_complete(main(loop)) self.assertEqual(len(Mocket.request_list()), 2) @@ -46,17 +46,17 @@ class AioHttpEntryTestCase(TestCase): async def main(_loop): async with aiohttp.ClientSession(loop=_loop) as session: - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.get(url) as get_response: assert get_response.status == 404 assert await get_response.text() == body - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.post(url, data=body * 6) as post_response: assert post_response.status == 201 assert await post_response.text() == body * 2 - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() loop.set_debug(True) loop.run_until_complete(main(loop)) self.assertEqual(len(Mocket.request_list()), 2) @@ -72,11 +72,11 @@ class AioHttpEntryTestCase(TestCase): async def main(_loop): async with aiohttp.ClientSession(loop=_loop) as session: - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.get(url) as get_response: assert get_response.status == 200 assert await get_response.text() == '{"origin": "127.0.0.1"}' - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() loop.set_debug(True) loop.run_until_complete(main(loop)) diff --git a/tests/tests37/test_asyncio.py b/tests/tests37/test_asyncio.py index 9e6e0d4..66f8cc9 100644 --- a/tests/tests37/test_asyncio.py +++ b/tests/tests37/test_asyncio.py @@ -33,7 +33,7 @@ class AsyncIoRecordTestCase(TestCase): writer.close() await writer.wait_closed() - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() loop.set_debug(True) loop.run_until_complete(test_asyncio_connection()) diff --git a/tests/tests38/test_http_aiohttp.py b/tests/tests38/test_http_aiohttp.py index fe3817f..348a7a0 100644 --- a/tests/tests38/test_http_aiohttp.py +++ b/tests/tests38/test_http_aiohttp.py @@ -19,12 +19,12 @@ class AioHttpEntryTestCase(IsolatedAsyncioTestCase): Entry.single_register(Entry.POST, url, body=body * 2, status=201) async with aiohttp.ClientSession() as session: - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.get(url) as get_response: assert get_response.status == 404 assert await get_response.text() == body - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.post(url, data=body * 6) as post_response: assert post_response.status == 201 assert await post_response.text() == body * 2 @@ -41,12 +41,12 @@ class AioHttpEntryTestCase(IsolatedAsyncioTestCase): Entry.single_register(Entry.POST, url, body=body * 2, status=201) async with aiohttp.ClientSession() as session: - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.get(url) as get_response: assert get_response.status == 404 assert await get_response.text() == body - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.post(url, data=body * 6) as post_response: assert post_response.status == 201 assert await post_response.text() == body * 2 @@ -63,7 +63,7 @@ class AioHttpEntryTestCase(IsolatedAsyncioTestCase): ) async with aiohttp.ClientSession() as session: - with async_timeout.timeout(3): + async with async_timeout.timeout(3): async with session.get(url) as get_response: assert get_response.status == 200 assert await get_response.text() == '{"origin": "127.0.0.1"}' -- 2.39.1 ++++++ 0010-Python-3.11-needs-an-async-decorator.patch ++++++ >From 77f91f7fcff89291e16c2f5b9b7d904b975e1bbe Mon Sep 17 00:00:00 2001 From: Giorgio Salluzzo <giorgio.sallu...@gmail.com> Date: Sat, 17 Dec 2022 12:39:31 +0100 Subject: [PATCH 10/15] Python 3.11 needs an async decorator. --- tests/main/test_http_aiohttp.py | 127 +++++++++++++++++--------------- 1 file changed, 66 insertions(+), 61 deletions(-) Index: mocket-3.10.9/tests/main/test_http_aiohttp.py =================================================================== --- mocket-3.10.9.orig/tests/main/test_http_aiohttp.py +++ mocket-3.10.9/tests/main/test_http_aiohttp.py @@ -1,5 +1,6 @@ import asyncio import json +import platform from unittest import TestCase import aiohttp @@ -9,74 +10,78 @@ from mocket.mocket import Mocket, mocket from mocket.mockhttp import Entry from mocket.plugins.httpretty import HTTPretty, httprettified - -class AioHttpEntryTestCase(TestCase): - @mocketize - def test_http_session(self): - url = "http://httpbin.org/ip"; - body = "asd" * 100 - Entry.single_register(Entry.GET, url, body=body, status=404) - Entry.single_register(Entry.POST, url, body=body * 2, status=201) - - async def main(_loop): - async with aiohttp.ClientSession(loop=_loop) as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 404 - assert await get_response.text() == body - - async with async_timeout.timeout(3): - async with session.post(url, data=body * 6) as post_response: - assert post_response.status == 201 - assert await post_response.text() == body * 2 - assert Mocket.last_request().method == "POST" - assert Mocket.last_request().body == body * 6 - - loop = asyncio.new_event_loop() - loop.set_debug(True) - loop.run_until_complete(main(loop)) - self.assertEqual(len(Mocket.request_list()), 2) - - @mocketize - def test_https_session(self): - url = "https://httpbin.org/ip"; - body = "asd" * 100 - Entry.single_register(Entry.GET, url, body=body, status=404) - Entry.single_register(Entry.POST, url, body=body * 2, status=201) - - async def main(_loop): - async with aiohttp.ClientSession(loop=_loop) as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 404 - assert await get_response.text() == body - - async with async_timeout.timeout(3): - async with session.post(url, data=body * 6) as post_response: - assert post_response.status == 201 - assert await post_response.text() == body * 2 - - loop = asyncio.new_event_loop() - loop.set_debug(True) - loop.run_until_complete(main(loop)) - self.assertEqual(len(Mocket.request_list()), 2) - - @httprettified - def test_httprettish_session(self): - url = "https://httpbin.org/ip"; - HTTPretty.register_uri( - HTTPretty.GET, - url, - body=json.dumps(dict(origin="127.0.0.1")), - ) - - async def main(_loop): - async with aiohttp.ClientSession(loop=_loop) as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 200 - assert await get_response.text() == '{"origin": "127.0.0.1"}' - - loop = asyncio.new_event_loop() - loop.set_debug(True) - loop.run_until_complete(main(loop)) +if not platform.python_version().startswith("3.11."): + # Python 3.11 needs async decorators, or aiohttp + # will fail with "Cannot write to closing transport" + class AioHttpEntryTestCase(TestCase): + @mocketize + def test_http_session(self): + url = "http://httpbin.org/ip"; + body = "asd" * 100 + Entry.single_register(Entry.GET, url, body=body, status=404) + Entry.single_register(Entry.POST, url, body=body * 2, status=201) + + async def main(_loop): + async with aiohttp.ClientSession(loop=_loop) as session: + async with async_timeout.timeout(3): + async with session.get(url) as get_response: + assert get_response.status == 404 + assert await get_response.text() == body + + async with async_timeout.timeout(3): + async with session.post(url, data=body * 6) as post_response: + assert post_response.status == 201 + assert await post_response.text() == body * 2 + assert Mocket.last_request().method == "POST" + assert Mocket.last_request().body == body * 6 + + loop = asyncio.new_event_loop() + loop.set_debug(True) + loop.run_until_complete(main(loop)) + self.assertEqual(len(Mocket.request_list()), 2) + + @mocketize + def test_https_session(self): + url = "https://httpbin.org/ip"; + body = "asd" * 100 + Entry.single_register(Entry.GET, url, body=body, status=404) + Entry.single_register(Entry.POST, url, body=body * 2, status=201) + + async def main(_loop): + async with aiohttp.ClientSession(loop=_loop) as session: + async with async_timeout.timeout(3): + async with session.get(url) as get_response: + assert get_response.status == 404 + assert await get_response.text() == body + + async with async_timeout.timeout(3): + async with session.post(url, data=body * 6) as post_response: + assert post_response.status == 201 + assert await post_response.text() == body * 2 + + loop = asyncio.new_event_loop() + loop.set_debug(True) + loop.run_until_complete(main(loop)) + self.assertEqual(len(Mocket.request_list()), 2) + + @httprettified + def test_httprettish_session(self): + url = "https://httpbin.org/ip"; + HTTPretty.register_uri( + HTTPretty.GET, + url, + body=json.dumps(dict(origin="127.0.0.1")), + ) + + async def main(_loop): + async with aiohttp.ClientSession(loop=_loop) as session: + async with async_timeout.timeout(3): + async with session.get(url) as get_response: + assert get_response.status == 200 + assert ( + await get_response.text() == '{"origin": "127.0.0.1"}' + ) + + loop = asyncio.new_event_loop() + loop.set_debug(True) + loop.run_until_complete(main(loop)) ++++++ 0012-Removing-async-timeout-dependency.patch ++++++ >From 6719547e1d3d5bb672258bc30fed835ddc659ce8 Mon Sep 17 00:00:00 2001 From: Giorgio Salluzzo <giorgio.sallu...@gmail.com> Date: Sun, 18 Dec 2022 00:44:02 +0100 Subject: [PATCH 12/15] Removing `async-timeout` dependency. --- Pipfile | 1 - README.rst | 54 ++++++------ tests/main/test_http_aiohttp.py | 131 ++++++++++++++--------------- tests/tests38/test_http_aiohttp.py | 48 +++++------ 4 files changed, 113 insertions(+), 121 deletions(-) Index: mocket-3.10.9/README.rst =================================================================== --- mocket-3.10.9.orig/README.rst +++ mocket-3.10.9/README.rst @@ -231,7 +231,6 @@ Example: import aiohttp import asyncio - import async_timeout from unittest import TestCase from mocket.plugins.httpretty import httpretty, httprettified @@ -248,11 +247,12 @@ Example: ) async def main(l): - async with aiohttp.ClientSession(loop=l) as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 200 - assert await get_response.text() == '{"origin": "127.0.0.1"}' + async with aiohttp.ClientSession( + loop=l, timeout=aiohttp.ClientTimeout(total=3) + ) as session: + async with session.get(url) as get_response: + assert get_response.status == 200 + assert await get_response.text() == '{"origin": "127.0.0.1"}' loop = asyncio.new_event_loop() loop.set_debug(True) @@ -277,16 +277,16 @@ Example: Entry.single_register(Entry.POST, url, body=body*2, status=201) async def main(l): - async with aiohttp.ClientSession(loop=l) as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 404 - assert await get_response.text() == body - - async with async_timeout.timeout(3): - async with session.post(url, data=body * 6) as post_response: - assert post_response.status == 201 - assert await post_response.text() == body * 2 + async with aiohttp.ClientSession( + loop=l, timeout=aiohttp.ClientTimeout(total=3) + ) as session: + async with session.get(url) as get_response: + assert get_response.status == 404 + assert await get_response.text() == body + + async with session.post(url, data=body * 6) as post_response: + assert post_response.status == 201 + assert await post_response.text() == body * 2 loop = asyncio.new_event_loop() loop.run_until_complete(main(loop)) @@ -302,18 +302,18 @@ Example: Entry.single_register(Entry.GET, url, body=body, status=404) Entry.single_register(Entry.POST, url, body=body * 2, status=201) - async with aiohttp.ClientSession() as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 404 - assert await get_response.text() == body - - async with async_timeout.timeout(3): - async with session.post(url, data=body * 6) as post_response: - assert post_response.status == 201 - assert await post_response.text() == body * 2 - assert Mocket.last_request().method == 'POST' - assert Mocket.last_request().body == body * 6 + async with aiohttp.ClientSession( + timeout=aiohttp.ClientTimeout(total=3) + ) as session: + async with session.get(url) as get_response: + assert get_response.status == 404 + assert await get_response.text() == body + + async with session.post(url, data=body * 6) as post_response: + assert post_response.status == 201 + assert await post_response.text() == body * 2 + assert Mocket.last_request().method == 'POST' + assert Mocket.last_request().body == body * 6 Works well with others Index: mocket-3.10.9/tests/main/test_http_aiohttp.py =================================================================== --- mocket-3.10.9.orig/tests/main/test_http_aiohttp.py +++ mocket-3.10.9/tests/main/test_http_aiohttp.py @@ -1,87 +1,84 @@ import asyncio import json -import platform from unittest import TestCase import aiohttp -import async_timeout from mocket.mocket import Mocket, mocketize from mocket.mockhttp import Entry from mocket.plugins.httpretty import HTTPretty, httprettified -if not platform.python_version().startswith("3.11."): - # Python 3.11 needs async decorators, or aiohttp - # will fail with "Cannot write to closing transport" - class AioHttpEntryTestCase(TestCase): - @mocketize - def test_http_session(self): - url = "http://httpbin.org/ip"; - body = "asd" * 100 - Entry.single_register(Entry.GET, url, body=body, status=404) - Entry.single_register(Entry.POST, url, body=body * 2, status=201) - - async def main(_loop): - async with aiohttp.ClientSession(loop=_loop) as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 404 - assert await get_response.text() == body - - async with async_timeout.timeout(3): - async with session.post(url, data=body * 6) as post_response: - assert post_response.status == 201 - assert await post_response.text() == body * 2 - assert Mocket.last_request().method == "POST" - assert Mocket.last_request().body == body * 6 - - loop = asyncio.new_event_loop() - loop.set_debug(True) - loop.run_until_complete(main(loop)) - self.assertEqual(len(Mocket.request_list()), 2) - - @mocketize - def test_https_session(self): - url = "https://httpbin.org/ip"; - body = "asd" * 100 - Entry.single_register(Entry.GET, url, body=body, status=404) - Entry.single_register(Entry.POST, url, body=body * 2, status=201) - - async def main(_loop): - async with aiohttp.ClientSession(loop=_loop) as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 404 - assert await get_response.text() == body - - async with async_timeout.timeout(3): - async with session.post(url, data=body * 6) as post_response: - assert post_response.status == 201 - assert await post_response.text() == body * 2 - - loop = asyncio.new_event_loop() - loop.set_debug(True) - loop.run_until_complete(main(loop)) - self.assertEqual(len(Mocket.request_list()), 2) - - @httprettified - def test_httprettish_session(self): - url = "https://httpbin.org/ip"; - HTTPretty.register_uri( - HTTPretty.GET, - url, - body=json.dumps(dict(origin="127.0.0.1")), - ) - - async def main(_loop): - async with aiohttp.ClientSession(loop=_loop) as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 200 - assert ( - await get_response.text() == '{"origin": "127.0.0.1"}' - ) - - loop = asyncio.new_event_loop() - loop.set_debug(True) - loop.run_until_complete(main(loop)) + +class AioHttpEntryTestCase(TestCase): + timeout = aiohttp.ClientTimeout(total=3) + + @mocketize + def test_http_session(self): + url = "http://httpbin.org/ip"; + body = "asd" * 100 + Entry.single_register(Entry.GET, url, body=body, status=404) + Entry.single_register(Entry.POST, url, body=body * 2, status=201) + + async def main(_loop): + async with aiohttp.ClientSession( + loop=_loop, timeout=self.timeout + ) as session: + async with session.get(url) as get_response: + assert get_response.status == 404 + assert await get_response.text() == body + + async with session.post(url, data=body * 6) as post_response: + assert post_response.status == 201 + assert await post_response.text() == body * 2 + assert Mocket.last_request().method == "POST" + assert Mocket.last_request().body == body * 6 + + loop = asyncio.new_event_loop() + loop.set_debug(True) + loop.run_until_complete(main(loop)) + self.assertEqual(len(Mocket.request_list()), 2) + + @mocketize + def test_https_session(self): + url = "https://httpbin.org/ip"; + body = "asd" * 100 + Entry.single_register(Entry.GET, url, body=body, status=404) + Entry.single_register(Entry.POST, url, body=body * 2, status=201) + + async def main(_loop): + async with aiohttp.ClientSession( + loop=_loop, timeout=self.timeout + ) as session: + async with session.get(url) as get_response: + assert get_response.status == 404 + assert await get_response.text() == body + + async with session.post(url, data=body * 6) as post_response: + assert post_response.status == 201 + assert await post_response.text() == body * 2 + + loop = asyncio.new_event_loop() + loop.set_debug(True) + loop.run_until_complete(main(loop)) + self.assertEqual(len(Mocket.request_list()), 2) + + @httprettified + def test_httprettish_session(self): + url = "https://httpbin.org/ip"; + HTTPretty.register_uri( + HTTPretty.GET, + url, + body=json.dumps(dict(origin="127.0.0.1")), + ) + + async def main(_loop): + async with aiohttp.ClientSession( + loop=_loop, timeout=self.timeout + ) as session: + async with session.get(url) as get_response: + assert get_response.status == 200 + assert await get_response.text() == '{"origin": "127.0.0.1"}' + + loop = asyncio.new_event_loop() + loop.set_debug(True) + loop.run_until_complete(main(loop)) Index: mocket-3.10.9/tests/tests38/test_http_aiohttp.py =================================================================== --- mocket-3.10.9.orig/tests/tests38/test_http_aiohttp.py +++ mocket-3.10.9/tests/tests38/test_http_aiohttp.py @@ -2,7 +2,6 @@ import json from unittest import IsolatedAsyncioTestCase import aiohttp -import async_timeout from mocket.async_mocket import async_mocketize from mocket.mocket import Mocket @@ -11,6 +10,8 @@ from mocket.plugins.httpretty import HTT class AioHttpEntryTestCase(IsolatedAsyncioTestCase): + timeout = aiohttp.ClientTimeout(total=3) + @async_mocketize async def test_http_session(self): url = "http://httpbin.org/ip"; @@ -18,18 +19,16 @@ class AioHttpEntryTestCase(IsolatedAsync Entry.single_register(Entry.GET, url, body=body, status=404) Entry.single_register(Entry.POST, url, body=body * 2, status=201) - async with aiohttp.ClientSession() as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 404 - assert await get_response.text() == body - - async with async_timeout.timeout(3): - async with session.post(url, data=body * 6) as post_response: - assert post_response.status == 201 - assert await post_response.text() == body * 2 - assert Mocket.last_request().method == "POST" - assert Mocket.last_request().body == body * 6 + async with aiohttp.ClientSession(timeout=self.timeout) as session: + async with session.get(url) as get_response: + assert get_response.status == 404 + assert await get_response.text() == body + + async with session.post(url, data=body * 6) as post_response: + assert post_response.status == 201 + assert await post_response.text() == body * 2 + assert Mocket.last_request().method == "POST" + assert Mocket.last_request().body == body * 6 self.assertEqual(len(Mocket.request_list()), 2) @@ -40,16 +39,14 @@ class AioHttpEntryTestCase(IsolatedAsync Entry.single_register(Entry.GET, url, body=body, status=404) Entry.single_register(Entry.POST, url, body=body * 2, status=201) - async with aiohttp.ClientSession() as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 404 - assert await get_response.text() == body - - async with async_timeout.timeout(3): - async with session.post(url, data=body * 6) as post_response: - assert post_response.status == 201 - assert await post_response.text() == body * 2 + async with aiohttp.ClientSession(timeout=self.timeout) as session: + async with session.get(url) as get_response: + assert get_response.status == 404 + assert await get_response.text() == body + + async with session.post(url, data=body * 6) as post_response: + assert post_response.status == 201 + assert await post_response.text() == body * 2 self.assertEqual(len(Mocket.request_list()), 2) @@ -62,8 +59,7 @@ class AioHttpEntryTestCase(IsolatedAsync body=json.dumps(dict(origin="127.0.0.1")), ) - async with aiohttp.ClientSession() as session: - async with async_timeout.timeout(3): - async with session.get(url) as get_response: - assert get_response.status == 200 - assert await get_response.text() == '{"origin": "127.0.0.1"}' + async with aiohttp.ClientSession(timeout=self.timeout) as session: + async with session.get(url) as get_response: + assert get_response.status == 200 + assert await get_response.text() == '{"origin": "127.0.0.1"}' ++++++ 0013-Refactoring-using-event_loop-fixture.patch ++++++ >From 63120c44526e31e22c16c9d8029a715eef38e145 Mon Sep 17 00:00:00 2001 From: Giorgio Salluzzo <giorgio.sallu...@gmail.com> Date: Tue, 27 Dec 2022 15:38:02 +0100 Subject: [PATCH 13/15] Refactoring using `event_loop` fixture. --- tests/main/test_http_aiohttp.py | 19 ++++++------------- tests/tests37/test_asyncio.py | 6 ++---- 2 files changed, 8 insertions(+), 17 deletions(-) diff --git a/tests/main/test_http_aiohttp.py b/tests/main/test_http_aiohttp.py index a98cb37..ab72397 100644 --- a/tests/main/test_http_aiohttp.py +++ b/tests/main/test_http_aiohttp.py @@ -1,4 +1,3 @@ -import asyncio import json from unittest import TestCase @@ -13,7 +12,7 @@ class AioHttpEntryTestCase(TestCase): timeout = aiohttp.ClientTimeout(total=3) @mocketize - def test_http_session(self): + def test_http_session(self, event_loop): url = "http://httpbin.org/ip"; body = "asd" * 100 Entry.single_register(Entry.GET, url, body=body, status=404) @@ -33,13 +32,11 @@ class AioHttpEntryTestCase(TestCase): assert Mocket.last_request().method == "POST" assert Mocket.last_request().body == body * 6 - loop = asyncio.new_event_loop() - loop.set_debug(True) - loop.run_until_complete(main(loop)) + event_loop.run_until_complete(main(event_loop)) self.assertEqual(len(Mocket.request_list()), 2) @mocketize - def test_https_session(self): + def test_https_session(self, event_loop): url = "https://httpbin.org/ip"; body = "asd" * 100 Entry.single_register(Entry.GET, url, body=body, status=404) @@ -57,13 +54,11 @@ class AioHttpEntryTestCase(TestCase): assert post_response.status == 201 assert await post_response.text() == body * 2 - loop = asyncio.new_event_loop() - loop.set_debug(True) - loop.run_until_complete(main(loop)) + event_loop.run_until_complete(main(event_loop)) self.assertEqual(len(Mocket.request_list()), 2) @httprettified - def test_httprettish_session(self): + def test_httprettish_session(self, event_loop): url = "https://httpbin.org/ip"; HTTPretty.register_uri( HTTPretty.GET, @@ -79,6 +74,4 @@ class AioHttpEntryTestCase(TestCase): assert get_response.status == 200 assert await get_response.text() == '{"origin": "127.0.0.1"}' - loop = asyncio.new_event_loop() - loop.set_debug(True) - loop.run_until_complete(main(loop)) + event_loop.run_until_complete(main(event_loop)) diff --git a/tests/tests37/test_asyncio.py b/tests/tests37/test_asyncio.py index 66f8cc9..72b3a0e 100644 --- a/tests/tests37/test_asyncio.py +++ b/tests/tests37/test_asyncio.py @@ -14,7 +14,7 @@ class AsyncIoRecordTestCase(TestCase): temp_dir = tempfile.mkdtemp() @mocketize(truesocket_recording_dir=temp_dir) - def test_asyncio_record_replay(self): + def test_asyncio_record_replay(self, event_loop): async def test_asyncio_connection(): reader, writer = await asyncio.open_connection( host="google.com", @@ -33,9 +33,7 @@ class AsyncIoRecordTestCase(TestCase): writer.close() await writer.wait_closed() - loop = asyncio.new_event_loop() - loop.set_debug(True) - loop.run_until_complete(test_asyncio_connection()) + event_loop.run_until_complete(test_asyncio_connection()) files = glob.glob(f"{self.temp_dir}/*.json") self.assertEqual(len(files), 1) -- 2.39.1 ++++++ 0014-Refactoring-using-tempfile-as-a-context-manager.patch ++++++ >From 5c718f123517ce02fced64677825d1ff3a4684c5 Mon Sep 17 00:00:00 2001 From: Giorgio Salluzzo <giorgio.sallu...@gmail.com> Date: Wed, 28 Dec 2022 09:43:58 +0100 Subject: [PATCH 14/15] Refactoring using `tempfile` as a context manager. --- tests/main/test_http.py | 96 ++++++++++++----------- tests/main/test_http_aiohttp.py | 130 +++++++++++++++----------------- tests/main/test_https.py | 31 ++++---- tests/main/test_mocket.py | 6 +- tests/tests37/test_asyncio.py | 52 ++++++------- 5 files changed, 154 insertions(+), 161 deletions(-) diff --git a/tests/main/test_http.py b/tests/main/test_http.py index f1893be..60a54fb 100644 --- a/tests/main/test_http.py +++ b/tests/main/test_http.py @@ -13,11 +13,9 @@ from urllib.request import urlopen import pytest import requests -from mocket import Mocket, mocketize +from mocket import Mocket, Mocketizer, mocketize from mocket.mockhttp import Entry, Response -recording_directory = tempfile.mkdtemp() - class HttpTestCase(TestCase): def assertEqualHeaders(self, first, second, msg=None): @@ -36,57 +34,63 @@ class TrueHttpEntryTestCase(HttpTestCase): resp = requests.get(url) self.assertEqual(resp.status_code, 200) - @mocketize(truesocket_recording_dir=recording_directory) def test_truesendall_with_recording(self): - url = "http://httpbin.org/ip"; - - urlopen(url) - requests.get(url) - resp = urlopen(url) - self.assertEqual(resp.code, 200) - resp = requests.get(url) - self.assertEqual(resp.status_code, 200) - assert "origin" in resp.json() - - dump_filename = os.path.join( - Mocket.get_truesocket_recording_dir(), Mocket.get_namespace() + ".json" - ) - with io.open(dump_filename) as f: - responses = json.load(f) + with tempfile.TemporaryDirectory() as temp_dir: + with Mocketizer(truesocket_recording_dir=temp_dir): + url = "http://httpbin.org/ip"; + + urlopen(url) + requests.get(url) + resp = urlopen(url) + self.assertEqual(resp.code, 200) + resp = requests.get(url) + self.assertEqual(resp.status_code, 200) + assert "origin" in resp.json() + + dump_filename = os.path.join( + Mocket.get_truesocket_recording_dir(), + Mocket.get_namespace() + ".json", + ) + with io.open(dump_filename) as f: + responses = json.load(f) + + self.assertEqual(len(responses["httpbin.org"]["80"].keys()), 2) - self.assertEqual(len(responses["httpbin.org"]["80"].keys()), 2) - - @mocketize(truesocket_recording_dir=recording_directory) def test_truesendall_with_gzip_recording(self): - url = "http://httpbin.org/gzip"; + with tempfile.TemporaryDirectory() as temp_dir: + with Mocketizer(truesocket_recording_dir=temp_dir): + url = "http://httpbin.org/gzip"; - requests.get(url) - resp = requests.get(url) - self.assertEqual(resp.status_code, 200) + requests.get(url) + resp = requests.get(url) + self.assertEqual(resp.status_code, 200) - dump_filename = os.path.join( - Mocket.get_truesocket_recording_dir(), Mocket.get_namespace() + ".json" - ) - with io.open(dump_filename) as f: - responses = json.load(f) + dump_filename = os.path.join( + Mocket.get_truesocket_recording_dir(), + Mocket.get_namespace() + ".json", + ) + with io.open(dump_filename) as f: + responses = json.load(f) - assert len(responses["httpbin.org"]["80"].keys()) == 1 + assert len(responses["httpbin.org"]["80"].keys()) == 1 - @mocketize(truesocket_recording_dir=recording_directory) def test_truesendall_with_chunk_recording(self): - url = "http://httpbin.org/range/70000?chunk_size=65536"; - - requests.get(url) - resp = requests.get(url) - self.assertEqual(resp.status_code, 200) - - dump_filename = os.path.join( - Mocket.get_truesocket_recording_dir(), Mocket.get_namespace() + ".json" - ) - with io.open(dump_filename) as f: - responses = json.load(f) - - assert len(responses["httpbin.org"]["80"].keys()) == 1 + with tempfile.TemporaryDirectory() as temp_dir: + with Mocketizer(truesocket_recording_dir=temp_dir): + url = "http://httpbin.org/range/70000?chunk_size=65536"; + + requests.get(url) + resp = requests.get(url) + self.assertEqual(resp.status_code, 200) + + dump_filename = os.path.join( + Mocket.get_truesocket_recording_dir(), + Mocket.get_namespace() + ".json", + ) + with io.open(dump_filename) as f: + responses = json.load(f) + + assert len(responses["httpbin.org"]["80"].keys()) == 1 @mocketize def test_wrongpath_truesendall(self): diff --git a/tests/main/test_http_aiohttp.py b/tests/main/test_http_aiohttp.py index ab72397..b8539eb 100644 --- a/tests/main/test_http_aiohttp.py +++ b/tests/main/test_http_aiohttp.py @@ -1,5 +1,4 @@ import json -from unittest import TestCase import aiohttp @@ -7,71 +6,66 @@ from mocket.mocket import Mocket, mocketize from mocket.mockhttp import Entry from mocket.plugins.httpretty import HTTPretty, httprettified +timeout = aiohttp.ClientTimeout(total=3) -class AioHttpEntryTestCase(TestCase): - timeout = aiohttp.ClientTimeout(total=3) - - @mocketize - def test_http_session(self, event_loop): - url = "http://httpbin.org/ip"; - body = "asd" * 100 - Entry.single_register(Entry.GET, url, body=body, status=404) - Entry.single_register(Entry.POST, url, body=body * 2, status=201) - - async def main(_loop): - async with aiohttp.ClientSession( - loop=_loop, timeout=self.timeout - ) as session: - async with session.get(url) as get_response: - assert get_response.status == 404 - assert await get_response.text() == body - - async with session.post(url, data=body * 6) as post_response: - assert post_response.status == 201 - assert await post_response.text() == body * 2 - assert Mocket.last_request().method == "POST" - assert Mocket.last_request().body == body * 6 - - event_loop.run_until_complete(main(event_loop)) - self.assertEqual(len(Mocket.request_list()), 2) - - @mocketize - def test_https_session(self, event_loop): - url = "https://httpbin.org/ip"; - body = "asd" * 100 - Entry.single_register(Entry.GET, url, body=body, status=404) - Entry.single_register(Entry.POST, url, body=body * 2, status=201) - - async def main(_loop): - async with aiohttp.ClientSession( - loop=_loop, timeout=self.timeout - ) as session: - async with session.get(url) as get_response: - assert get_response.status == 404 - assert await get_response.text() == body - - async with session.post(url, data=body * 6) as post_response: - assert post_response.status == 201 - assert await post_response.text() == body * 2 - - event_loop.run_until_complete(main(event_loop)) - self.assertEqual(len(Mocket.request_list()), 2) - - @httprettified - def test_httprettish_session(self, event_loop): - url = "https://httpbin.org/ip"; - HTTPretty.register_uri( - HTTPretty.GET, - url, - body=json.dumps(dict(origin="127.0.0.1")), - ) - - async def main(_loop): - async with aiohttp.ClientSession( - loop=_loop, timeout=self.timeout - ) as session: - async with session.get(url) as get_response: - assert get_response.status == 200 - assert await get_response.text() == '{"origin": "127.0.0.1"}' - - event_loop.run_until_complete(main(event_loop)) + +@mocketize +def test_http_session(event_loop): + url = "http://httpbin.org/ip"; + body = "asd" * 100 + Entry.single_register(Entry.GET, url, body=body, status=404) + Entry.single_register(Entry.POST, url, body=body * 2, status=201) + + async def main(_loop): + async with aiohttp.ClientSession(loop=_loop, timeout=timeout) as session: + async with session.get(url) as get_response: + assert get_response.status == 404 + assert await get_response.text() == body + + async with session.post(url, data=body * 6) as post_response: + assert post_response.status == 201 + assert await post_response.text() == body * 2 + assert Mocket.last_request().method == "POST" + assert Mocket.last_request().body == body * 6 + + event_loop.run_until_complete(main(event_loop)) + assert len(Mocket.request_list()) == 2 + + +@mocketize +def test_https_session(event_loop): + url = "https://httpbin.org/ip"; + body = "asd" * 100 + Entry.single_register(Entry.GET, url, body=body, status=404) + Entry.single_register(Entry.POST, url, body=body * 2, status=201) + + async def main(_loop): + async with aiohttp.ClientSession(loop=_loop, timeout=timeout) as session: + async with session.get(url) as get_response: + assert get_response.status == 404 + assert await get_response.text() == body + + async with session.post(url, data=body * 6) as post_response: + assert post_response.status == 201 + assert await post_response.text() == body * 2 + + event_loop.run_until_complete(main(event_loop)) + assert len(Mocket.request_list()) == 2 + + +@httprettified +def test_httprettish_session(event_loop): + url = "https://httpbin.org/ip"; + HTTPretty.register_uri( + HTTPretty.GET, + url, + body=json.dumps(dict(origin="127.0.0.1")), + ) + + async def main(_loop): + async with aiohttp.ClientSession(loop=_loop, timeout=timeout) as session: + async with session.get(url) as get_response: + assert get_response.status == 200 + assert await get_response.text() == '{"origin": "127.0.0.1"}' + + event_loop.run_until_complete(main(event_loop)) diff --git a/tests/main/test_https.py b/tests/main/test_https.py index 0a54e32..10652b5 100644 --- a/tests/main/test_https.py +++ b/tests/main/test_https.py @@ -42,22 +42,23 @@ recording_directory = tempfile.mkdtemp() @pytest.mark.skipif('os.getenv("SKIP_TRUE_HTTP", False)') -@mocketize(truesocket_recording_dir=recording_directory) def test_truesendall_with_recording_https(): - url = "https://httpbin.org/ip"; - - requests.get(url, headers={"Accept": "application/json"}) - resp = requests.get(url, headers={"Accept": "application/json"}) - assert resp.status_code == 200 - - dump_filename = os.path.join( - Mocket.get_truesocket_recording_dir(), - Mocket.get_namespace() + ".json", - ) - with io.open(dump_filename) as f: - responses = json.load(f) - - assert len(responses["httpbin.org"]["443"].keys()) == 1 + with tempfile.TemporaryDirectory() as temp_dir: + with Mocketizer(truesocket_recording_dir=temp_dir): + url = "https://httpbin.org/ip"; + + requests.get(url, headers={"Accept": "application/json"}) + resp = requests.get(url, headers={"Accept": "application/json"}) + assert resp.status_code == 200 + + dump_filename = os.path.join( + Mocket.get_truesocket_recording_dir(), + Mocket.get_namespace() + ".json", + ) + with io.open(dump_filename) as f: + responses = json.load(f) + + assert len(responses["httpbin.org"]["443"].keys()) == 1 @pytest.mark.skipif('os.getenv("SKIP_TRUE_HTTP", False)') diff --git a/tests/main/test_mocket.py b/tests/main/test_mocket.py index 67ad337..14057b1 100644 --- a/tests/main/test_mocket.py +++ b/tests/main/test_mocket.py @@ -174,13 +174,13 @@ def test_mocketize_outside_a_test_class(): @pytest.fixture -def fixture(): +def two(): return 2 @mocketize -def test_mocketize_with_fixture(fixture): - assert 2 == fixture +def test_mocketize_with_fixture(two): + assert 2 == two @mocketize diff --git a/tests/tests37/test_asyncio.py b/tests/tests37/test_asyncio.py index 72b3a0e..c90bcb8 100644 --- a/tests/tests37/test_asyncio.py +++ b/tests/tests37/test_asyncio.py @@ -2,45 +2,39 @@ import asyncio import glob import io import json -import shutil import socket import tempfile -from unittest import TestCase -from mocket.mocket import mocketize +from mocket import Mocketizer -class AsyncIoRecordTestCase(TestCase): - temp_dir = tempfile.mkdtemp() +def test_asyncio_record_replay(event_loop): + async def test_asyncio_connection(): + reader, writer = await asyncio.open_connection( + host="google.com", + port=80, + family=socket.AF_INET, + proto=socket.IPPROTO_TCP, + ssl=None, + server_hostname=None, + ) - @mocketize(truesocket_recording_dir=temp_dir) - def test_asyncio_record_replay(self, event_loop): - async def test_asyncio_connection(): - reader, writer = await asyncio.open_connection( - host="google.com", - port=80, - family=socket.AF_INET, - proto=socket.IPPROTO_TCP, - ssl=None, - server_hostname=None, - ) + buf = "GET / HTTP/1.1\r\nHost: google.com\r\n\r\n" + writer.write(buf.encode()) + await writer.drain() - buf = "GET / HTTP/1.1\r\nHost: google.com\r\n\r\n" - writer.write(buf.encode()) - await writer.drain() + await reader.readline() + writer.close() + await writer.wait_closed() - await reader.readline() - writer.close() - await writer.wait_closed() + with tempfile.TemporaryDirectory() as temp_dir: + with Mocketizer(truesocket_recording_dir=temp_dir): + event_loop.run_until_complete(test_asyncio_connection()) - event_loop.run_until_complete(test_asyncio_connection()) - - files = glob.glob(f"{self.temp_dir}/*.json") - self.assertEqual(len(files), 1) + files = glob.glob(f"{temp_dir}/*.json") + assert len(files) == 1 with io.open(files[0]) as f: responses = json.load(f) - self.assertEqual(len(responses["google.com"]["80"].keys()), 1) - - shutil.rmtree(self.temp_dir) + assert len(responses["google.com"]["80"].keys()) == 1 -- 2.39.1 ++++++ 0015-Skip-those-tests-and-see-what-happens-to-the-rest.patch ++++++ >From b736f854e1bc65a091498102e8102c6db98009a1 Mon Sep 17 00:00:00 2001 From: Giorgio Salluzzo <giorgio.sallu...@gmail.com> Date: Wed, 28 Dec 2022 16:03:37 +0100 Subject: [PATCH 15/15] Skip those tests and see what happens to the rest. --- Pipfile | 3 ++- mocket/plugins/httpretty/__init__.py | 1 + tests/main/test_http_aiohttp.py | 33 ++++++++++++++++++---------- 3 files changed, 24 insertions(+), 13 deletions(-) Index: mocket-3.10.9/mocket/plugins/httpretty/__init__.py =================================================================== --- mocket-3.10.9.orig/mocket/plugins/httpretty/__init__.py +++ mocket-3.10.9/mocket/plugins/httpretty/__init__.py @@ -118,6 +118,7 @@ httpretty = HTTPretty __all__ = ( "HTTPretty", + "httpretty", "activate", "async_httprettified", "httprettified", Index: mocket-3.10.9/tests/main/test_http_aiohttp.py =================================================================== --- mocket-3.10.9.orig/tests/main/test_http_aiohttp.py +++ mocket-3.10.9/tests/main/test_http_aiohttp.py @@ -1,10 +1,13 @@ import json +import sys import aiohttp +import pytest +from asgiref.sync import async_to_sync from mocket.mocket import Mocket, mocketize from mocket.mockhttp import Entry -from mocket.plugins.httpretty import HTTPretty, httprettified +from mocket.plugins.httpretty import httprettified, httpretty timeout = aiohttp.ClientTimeout(total=3) @@ -16,8 +19,9 @@ def test_http_session(event_loop): Entry.single_register(Entry.GET, url, body=body, status=404) Entry.single_register(Entry.POST, url, body=body * 2, status=201) - async def main(_loop): - async with aiohttp.ClientSession(loop=_loop, timeout=timeout) as session: + @async_to_sync + async def perform_aiohttp_transactions(): + async with aiohttp.ClientSession(timeout=timeout) as session: async with session.get(url) as get_response: assert get_response.status == 404 assert await get_response.text() == body @@ -28,10 +32,11 @@ def test_http_session(event_loop): assert Mocket.last_request().method == "POST" assert Mocket.last_request().body == body * 6 - event_loop.run_until_complete(main(event_loop)) + perform_aiohttp_transactions() assert len(Mocket.request_list()) == 2 +@pytest.mark.skipif(sys.version_info >= (3, 11), reason="Failing with Python 3.11") @mocketize def test_https_session(event_loop): url = "https://httpbin.org/ip"; @@ -39,8 +44,9 @@ def test_https_session(event_loop): Entry.single_register(Entry.GET, url, body=body, status=404) Entry.single_register(Entry.POST, url, body=body * 2, status=201) - async def main(_loop): - async with aiohttp.ClientSession(loop=_loop, timeout=timeout) as session: + @async_to_sync + async def perform_aiohttp_transactions(): + async with aiohttp.ClientSession(timeout=timeout) as session: async with session.get(url) as get_response: assert get_response.status == 404 assert await get_response.text() == body @@ -49,23 +55,26 @@ def test_https_session(event_loop): assert post_response.status == 201 assert await post_response.text() == body * 2 - event_loop.run_until_complete(main(event_loop)) + perform_aiohttp_transactions() assert len(Mocket.request_list()) == 2 +@pytest.mark.skipif(sys.version_info >= (3, 11), reason="Failing with Python 3.11") @httprettified def test_httprettish_session(event_loop): url = "https://httpbin.org/ip"; - HTTPretty.register_uri( - HTTPretty.GET, + httpretty.register_uri( + httpretty.GET, url, body=json.dumps(dict(origin="127.0.0.1")), ) - async def main(_loop): - async with aiohttp.ClientSession(loop=_loop, timeout=timeout) as session: + @async_to_sync + async def perform_aiohttp_transactions(): + async with aiohttp.ClientSession(timeout=timeout) as session: async with session.get(url) as get_response: assert get_response.status == 200 assert await get_response.text() == '{"origin": "127.0.0.1"}' - event_loop.run_until_complete(main(event_loop)) + perform_aiohttp_transactions() + assert len(httpretty.latest_requests) == 1
