Merge branch 'release/0.1.3'

Author: s3rius

README.md

@@ -26,3 +26,71 @@ taskiq_aiohttp.init(broker, "project.module:app")
 It adds startup functions to the broker, so it imports your aiohttp application and creates a single worker-wide Request and Application objects that you can depend on.
 
 THIS REQUEST IS NOT RELATED TO THE ACTUAL REQUESTS IN AioHTTP! This request won't have actual data about the request you were handling while sending a task.
+
+
+## Manual context updates
+
+Sometimes it's required to update context manually. For example, for tests.
+If you need to add context in your broker by hand, please use function populate_context.
+
+Imagine, you want to use InMemoryBroker for testing and your broker file looks like this:
+
+```python
+broker = MyBroker()
+
+if env == "pytest":
+    broker = InMemoryBroker()
+```
+
+In this case your context won't be updated, because inmemory brokers cannot run as workers.
+To solve this issue, we have a populate context function. It's a bit complex and takes lots of
+parmeters. But here's a fixture that creates aiohttp test client and populates context of inmemory broker.
+
+```python
+import asyncio
+from typing import AsyncGenerator
+
+import pytest
+from aiohttp import web
+from aiohttp.test_utils import BaseTestServer, TestClient, TestServer
+from taskiq_aiohttp import populate_context
+
+
+@pytest.fixture
+async def test_client(
+    app: web.Application,
+) -> AsyncGenerator[TestClient, None]:
+    """
+    Create a test client.
+
+    This function creates a TestServer
+    and a test client for the application.
+
+    Also this fixture populates context
+    with needed variables.
+
+    :param app: current application.
+    :yield: ready to use client.
+    """
+    loop = asyncio.get_running_loop()
+    server = TestServer(app)
+    client = TestClient(server, loop=loop)
+
+    await client.start_server()
+
+    # This is important part.
+    # Since InMemoryBroker doesn't
+    # run in worker_process, we have to populate
+    # broker's context manually.
+    populate_context(
+        broker=broker,
+        server=server.runner.server,
+        app=app,
+        loop=None,
+    )
+
+    yield client
+
+    await client.close()
+
+```

pyproject.toml

@@ -3,7 +3,7 @@ name = "taskiq-aiohttp"
 description = "Taskiq integration with AioHTTP framework"
 authors = ["Taskiq team <taskiq@no-reply.com>"]
 maintainers = ["Taskiq team <taskiq@no-reply.com>"]
-version = "0.1.2"
+version = "0.1.3"
 readme = "README.md"
 license = "LICENSE"
 classifiers = [

taskiq_aiohttp/__init__.py

@@ -1,4 +1,4 @@
 """Project was generated using taskiq."""
-from taskiq_aiohttp.initializer import init
+from taskiq_aiohttp.initializer import init, populate_context
 
-__all__ = ["init"]
+__all__ = ["init", "populate_context"]

taskiq_aiohttp/initializer.py

@@ -13,6 +13,64 @@
 from taskiq.cli.utils import import_object
 
 
+def populate_context(
+    broker: AsyncBroker,
+    server: web.Server,
+    app: web.Application,
+    loop: asyncio.AbstractEventLoop,
+) -> None:
+    """
+    Function to add dependency context.
+
+    This function adds base dependency,
+    that you may need while working with AioHTTP application.
+
+    :param broker: current broker.
+    :param server: current server that handles requests.
+    :param app: your application.
+    :param loop: current event loop.
+    """
+    handler = RequestHandler(server, loop=loop)
+    handler.transport = asyncio.Transport()
+    request = web.Request(
+        RawRequestMessage(
+            "GET",
+            "/",
+            HttpVersion10,
+            headers=CIMultiDictProxy(CIMultiDict()),
+            raw_headers=(),
+            should_close=False,
+            upgrade=False,
+            chunked=False,
+            compression=None,
+            url=yarl.URL.build(
+                scheme="https",
+                host="test.com",
+                path="/",
+            ),
+        ),
+        None,
+        handler,
+        None,
+        None,
+        None,
+    )
+
+    request._match_info = UrlMappingMatchInfo(
+        match_dict={},
+        route=SystemRoute(web.HTTPBadRequest()),
+    )
+    request._match_info._apps = app._subapps
+    request._match_info._current_app = app
+
+    broker.add_dependency_context(
+        {
+            web.Application: app,
+            web.Request: request,
+        },
+    )
+
+
 def startup_event_generator(
     broker: AsyncBroker,
     app_path: str,
@@ -35,8 +93,6 @@ def startup_event_generator(
     """
 
     async def startup(state: TaskiqState) -> None:
-        loop = asyncio.get_event_loop()
-
         local_app = app
 
         if not isinstance(local_app, web.Application):
@@ -54,47 +110,16 @@ async def startup(state: TaskiqState) -> None:
         if app_runner.server is None:
             raise ValueError("Cannot construct aiohttp app to mock requests")
 
-        # Creating mocked request
-        handler = RequestHandler(app_runner.server, loop=loop)
-        handler.transport = asyncio.Transport()
-        request = web.Request(
-            RawRequestMessage(
-                "GET",
-                "/",
-                HttpVersion10,
-                headers=CIMultiDictProxy(CIMultiDict()),
-                raw_headers=(),
-                should_close=False,
-                upgrade=False,
-                chunked=False,
-                compression=None,
-                url=yarl.URL.build(
-                    scheme="https",
-                    host="test.com",
-                    path="/",
-                ),
-            ),
-            None,
-            handler,
-            None,
-            None,
-            None,
-        )
+        loop = asyncio.get_running_loop()
 
-        request._match_info = UrlMappingMatchInfo(
-            match_dict={},
-            route=SystemRoute(web.HTTPBadRequest()),
-        )
-        request._match_info._apps = local_app._subapps
-        request._match_info._current_app = local_app
-
-        broker.add_dependency_context(
-            {
-                web.Application: local_app,
-                web.Request: request,
-            },
+        populate_context(
+            broker=broker,
+            server=app_runner.server,
+            app=local_app,
+            loop=loop,
         )
 
+        # Creating mocked request
         state.aiohttp_runner = app_runner
         local_app.router._resources = []