rsgiadapter 0.0.3__tar.gz

rsgiadapter-0.0.3/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: rsgiadapter
+Version: 0.0.3
+Summary: An adapter for asgi to rsgi
+Keywords: asgi,rsgi,adapter,asgi adapter,rsgi adapter,asgi to rsgi,rsgi to asgi,asyncio
+Author-Email: belingud <im.victor@qq.com>
+License: BSD-3-Clause
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: Internet
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://github.com/belingud/rsgiadapter
+Requires-Python: <4.0,>=3.8
+Requires-Dist: asgiref>=3.8.1
+Description-Content-Type: text/markdown
+
+# rsgiadapter
+
+An Asgi to rsgi adapter.
+
+RSGI Specification ref: https://github.com/emmett-framework/granian/blob/master/docs/spec/RSGI.md
+
+`rsgiadapter` is an adapter for [RSGI](https://github.com/emmett-framework/granian/blob/master/docs/spec/RSGI.md) server run [ASGI](https://asgi.readthedocs.io) application like FastAPI and BlackSheep.
+
+Usage:
+
+`app.py`
+```python
+import granian
+from granian.constants import Interfaces
+from rsgiadapter import ASGIToRSGI
+
+app = None  # Define your asgi application here
+
+rsgi_app = ASGIToRSGI(app)
+
+serve = granian.Granian("app:rsgi_app", interface=Interfaces.RSGI)
+serve.serve()
+
+```
+
+Supported Feature:
+
+- [x] HTTP Request Response
+  - [x] ASGI scope
+  - [x] ASGI receive
+  - [x] ASGI send
+- [x] Extensions
+  - [x] http.response.pathsend
+  - [ ] websocket.http.response
+  - [ ] http.response.push
+  - [ ] http.response.zerocopysend
+  - [ ] http.response.early_hint
+  - [ ] http.response.trailers
+  - [ ] http.response.debug
+- [ ] Lifespan
+  - [ ] lifespan.startup
+  - [ ] lifespan.startup.complete
+  - [ ] lifespan.startup.failed
+  - [ ] lifespan.shutdown
+  - [ ] lifespan.shutdown.complete
+  - [ ] lifespan.shutdown.failed
+
+Ref:
+
+- Granian: https://github.com/emmett-framework/granian

rsgiadapter-0.0.3/README.md

@@ -0,0 +1,50 @@
+# rsgiadapter
+
+An Asgi to rsgi adapter.
+
+RSGI Specification ref: https://github.com/emmett-framework/granian/blob/master/docs/spec/RSGI.md
+
+`rsgiadapter` is an adapter for [RSGI](https://github.com/emmett-framework/granian/blob/master/docs/spec/RSGI.md) server run [ASGI](https://asgi.readthedocs.io) application like FastAPI and BlackSheep.
+
+Usage:
+
+`app.py`
+```python
+import granian
+from granian.constants import Interfaces
+from rsgiadapter import ASGIToRSGI
+
+app = None  # Define your asgi application here
+
+rsgi_app = ASGIToRSGI(app)
+
+serve = granian.Granian("app:rsgi_app", interface=Interfaces.RSGI)
+serve.serve()
+
+```
+
+Supported Feature:
+
+- [x] HTTP Request Response
+  - [x] ASGI scope
+  - [x] ASGI receive
+  - [x] ASGI send
+- [x] Extensions
+  - [x] http.response.pathsend
+  - [ ] websocket.http.response
+  - [ ] http.response.push
+  - [ ] http.response.zerocopysend
+  - [ ] http.response.early_hint
+  - [ ] http.response.trailers
+  - [ ] http.response.debug
+- [ ] Lifespan
+  - [ ] lifespan.startup
+  - [ ] lifespan.startup.complete
+  - [ ] lifespan.startup.failed
+  - [ ] lifespan.shutdown
+  - [ ] lifespan.shutdown.complete
+  - [ ] lifespan.shutdown.failed
+
+Ref:
+
+- Granian: https://github.com/emmett-framework/granian

rsgiadapter-0.0.3/pyproject.toml

@@ -0,0 +1,92 @@
+[project]
+name = "rsgiadapter"
+dynamic = []
+description = "An adapter for asgi to rsgi"
+authors = [
+    { name = "belingud", email = "im.victor@qq.com" },
+]
+dependencies = [
+    "asgiref>=3.8.1",
+]
+requires-python = ">=3.8,<4.0"
+readme = "README.md"
+keywords = [
+    "asgi",
+    "rsgi",
+    "adapter",
+    "asgi adapter",
+    "rsgi adapter",
+    "asgi to rsgi",
+    "rsgi to asgi",
+    "asyncio",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: OS Independent",
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: System Administrators",
+    "Topic :: Internet",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development",
+    "Typing :: Typed",
+]
+version = "0.0.3"
+
+[project.license]
+text = "BSD-3-Clause"
+
+[project.urls]
+Homepage = "https://github.com/belingud/rsgiadapter"
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm]
+distribution = true
+
+[tool.pdm.build]
+excludes = [
+    "./**/.git",
+]
+package-dir = "src"
+includes = [
+    "src/rsgiadapter",
+]
+
+[tool.pdm.version]
+source = "file"
+path = "src/rsgiadapter/__init__.py"
+
+[tool.pdm.dev-dependencies]
+dev = [
+    "fastapi>=0.111.0",
+    "black>=24.4.2",
+    "isort>=5.13.2",
+    "granian>=1.4.1",
+    "uvicorn>=0.30.1",
+    "bump2version>=1.0.1",
+]
+
+[tool.pytest.ini_options]
+addopts = "-rsxX -l --tb=short --strict"
+testpaths = [
+    "tests/",
+]
+python_files = [
+    "tests/*/test*.py",
+]

rsgiadapter-0.0.3/src/rsgiadapter/__init__.py

@@ -0,0 +1,5 @@
+from .asgi import ASGIToRSGI
+
+__all__ = ["ASGIToRSGI"]
+
+__version__ = "0.0.3"

rsgiadapter-0.0.3/src/rsgiadapter/asgi.py

@@ -0,0 +1,216 @@
+import asyncio
+import logging
+from os import PathLike, environ
+from typing import AsyncGenerator, TYPE_CHECKING, Union
+
+from asgiref.compatibility import guarantee_single_callable
+
+from .constant import EventTypeEnum
+
+if TYPE_CHECKING:
+    from .protocol import (
+        ASGIScope,
+        RSGIHTTPProtocol,
+        RSGIHTTPScope,
+        RSGIWebsocketProtocol,
+        RSGIWebsocketScope,
+    )
+from .response import BodyIter, Response
+
+logger = logging.getLogger("rsgiadapter")
+if environ.get("RSGI_ADAPTER_DEBUG", "0") == "1":
+    logger.setLevel(logging.DEBUG)
+
+DEFAULT_ASGI_VERSION = "3.0"
+DEFAULT_SPEC_VERSION = "2.3"
+
+
+class ASGIToRSGI:
+
+    def __init__(
+        self,
+        asgi_application,
+        asgi_version=DEFAULT_ASGI_VERSION,
+        spec_version=DEFAULT_SPEC_VERSION,
+    ):
+        self.asgi_application = asgi_application
+        self.asgi_version = asgi_version
+        self.spec_version = spec_version
+
+    async def __call__(self, scope, protocol):
+        await ASGIToRSGIAdapter(
+            self.asgi_application, self.asgi_version, self.spec_version
+        )(scope, protocol)
+
+
+class ASGIToRSGIAdapter:
+    def __init__(
+        self,
+        asgi_app,
+        asgi_version=DEFAULT_ASGI_VERSION,
+        spec_version=DEFAULT_SPEC_VERSION,
+    ):
+        self.asgi_app = asgi_app
+        self.asgi_version = asgi_version
+        self.spec_version = spec_version
+        self.event_status = EventTypeEnum.HTTP_REQUEST
+
+        self.state = {}
+        self.response_started = False
+        self.response_content_length = None
+
+    async def yield_body(
+        self, protocol: Union["RSGIHTTPProtocol", "RSGIWebsocketProtocol"]
+    ) -> AsyncGenerator:
+        """
+        Asynchronously yields messages from the given rsgi `protocol`.
+
+        Args:
+            protocol (RSGIHTTPProtocol | RSGIWebsocketProtocol): RSGIHTTPProtocol or RSGIWebsocketProtocol instance.
+
+        Yields:
+            Any: The next message from the rsgi protocol.
+
+        """
+        async for msg in protocol:
+            yield msg
+
+    def make_asgi_scope(
+        self, scope: Union["RSGIHTTPScope", "RSGIWebsocketScope"]
+    ) -> "ASGIScope":
+        """
+        Generates an ASGI scope based on RSGI scope, extracting relevant information,
+        such as versions, protocol, HTTP version, server details, client details, scheme,
+        method, path, query string, headers, and state.
+
+        Args:
+            scope (Union["RSGIHTTPScope", "RSGIWebsocketScope"]): The scope object containing the necessary information.
+
+        Returns:
+            dict: A dictionary representing the ASGI scope with version details
+
+        Raises:
+            ValueError: If the scope is None
+        """
+        if not scope:
+            raise ValueError("Scope cannot be None")
+
+        asgi_version = self.asgi_version
+        spec_version = self.spec_version
+        proto = scope.proto
+        http_version = scope.http_version
+        server = scope.server.split(":") if scope.server else []
+        client = scope.client.split(":") if scope.client else []
+        scheme = scope.scheme
+        method = scope.method
+        path = scope.path
+        raw_path = path.encode("latin-1") if path else b""
+        query_string = (
+            scope.query_string.encode("latin-1") if scope.query_string else b""
+        )
+        headers = (
+            [
+                (k.encode("latin-1"), v.encode("latin-1"))
+                for k, v in scope.headers.items()
+            ]
+            if scope.headers
+            else []
+        )
+
+        return {
+            "asgi": {"version": asgi_version, "spec_version": spec_version},
+            "extensions": {"http.response.pathsend": {}},
+            "type": proto,
+            "http_version": http_version,
+            "server": server,
+            "client": client,
+            "scheme": scheme,
+            "method": method,
+            "path": path,
+            "raw_path": raw_path,
+            "query_string": query_string,
+            "headers": headers,
+            "root_path": "",
+            "state": self.state,
+        }
+
+    async def __call__(
+        self,
+        scope: Union["RSGIHTTPScope", "RSGIWebsocketScope"],
+        protocol: Union["RSGIHTTPProtocol", "RSGIWebsocketProtocol"],
+    ):
+        asgi_scope = self.make_asgi_scope(scope)
+        send_queue = asyncio.Queue()
+        asgi_body = self.yield_body(protocol)
+
+        async def receive():
+            try:
+                return {
+                    "type": self.event_status,
+                    "body": await anext(asgi_body),
+                    "more_body": True,
+                }
+            except StopAsyncIteration:
+                return {
+                    "type": self.event_status,
+                    "body": b"",
+                    "more_body": False,
+                }
+
+        async def send(msg):
+            if msg.get("more_body", None) is False:
+                self.event_status = EventTypeEnum.HTTP_DISCONNECT
+            await send_queue.put(msg)
+
+        try:
+            await guarantee_single_callable(self.asgi_app)(asgi_scope, receive, send)
+        except asyncio.CancelledError:
+            logger.debug("ASGI app cancelled")
+        except Exception:
+            logger.debug("ASGI app raised an exception", exc_info=True)
+        response = await self.get_response(send_queue)
+
+        await self.perform_response(protocol, response)
+
+    async def get_response(self, send_queue: asyncio.Queue):
+        response = Response(
+            status=None, headers=[], body=BodyIter(), path=None, stream=None, type=None
+        )
+        while not send_queue.empty():
+            message = await send_queue.get()
+            if message["type"] == EventTypeEnum.HTTP_RESP_START:
+                response.status = message["status"]
+                response.headers = [
+                    (k.decode(), v.decode()) for k, v in message["headers"]
+                ]
+            elif message["type"] == EventTypeEnum.HTTP_RESP_BODY:
+                response.body.append(message["body"])
+            elif message["type"] == EventTypeEnum.PATH_SEND:
+                response.path = message["path"]
+                response.type = EventTypeEnum.PATH_SEND
+        return response
+
+    async def perform_response(
+        self,
+        protocol: Union["RSGIHTTPProtocol", "RSGIWebsocketProtocol"],
+        response: Response,
+    ) -> None:
+        if response.path is not None and isinstance(response.path, (str, PathLike)):
+            protocol.response_file(
+                status=response.status, headers=response.headers, file=response.path
+            )
+            return
+        if len(response.body) > 1:
+            trx = protocol.response_stream(
+                status=response.status,
+                headers=response.headers,
+            )
+            async for chunk in response.body:
+                await trx.send_bytes(chunk)
+        else:
+            protocol.response_bytes(
+                status=response.status,
+                headers=response.headers,
+                body=b"".join(response.get_body()),
+            )
+            response.clear_body()

rsgiadapter-0.0.3/src/rsgiadapter/constant.py

@@ -0,0 +1,22 @@
+from enum import StrEnum
+
+
+class EventTypeEnum(StrEnum):
+    """
+    ASGI event types
+    """
+    # http
+    HTTP_REQUEST = "http.request"
+    HTTP_DISCONNECT = "http.disconnect"
+    HTTP_RESP_START = "http.response.start"
+    HTTP_RESP_END = "http.response.end"
+    HTTP_RESP_BODY = "http.response.body"
+
+    # websocket
+    WEBSOCKET_CONNECT = "websocket.connect"
+    WEBSOCKET_DISCONNECT = "websocket.disconnect"
+    WEBSOCKET_RECEIVE = "websocket.receive"
+    WEBSOCKET_SEND = "websocket.send"
+
+    # extensions
+    PATH_SEND = "http.response.pathsend"

rsgiadapter-0.0.3/src/rsgiadapter/protocol.py

@@ -0,0 +1,141 @@
+from typing import Any, Dict, Iterable, List, Optional, Tuple, TypedDict, Union
+
+
+class ASGIScope(TypedDict):
+    asgi: Dict[str, str]
+    extensions: Dict[str, Dict[str, Any]]
+    type: str
+    http_version: str
+    server: Iterable[Union[str, int, None]]
+    client: Iterable[Union[str, int, None]]
+    scheme: str
+    method: str
+    path: str
+    raw_path: bytes
+    query_string: bytes
+    headers: Iterable[Tuple[Union[str, bytes], Union[str, bytes]]]
+    root_path: str
+    state: Optional[Dict[str, Any]]
+
+
+class RSGIHTTPScope(object):
+    """RSGI HTTP Scope template, for type hinting"""
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    @staticmethod
+    def __new__(cls, *args, **kwargs):
+        pass
+
+    authority = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    client = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    headers = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    http_version = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    method = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    path = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    proto = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    query_string = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    rsgi_version = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    scheme = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    server = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+
+class RSGIHTTPProtocol(object):
+    """RSGI HTTP Protocol template, for type hinting"""
+
+    proto: str
+    http_version: str
+    rsgi_version: str
+    server: str
+    client: str
+    scheme: str
+    method: str
+    path: str
+    query_string: str
+    headers: List
+    body: bytes
+
+    def response_bytes(self, *args, **kwargs):
+        pass
+
+    def response_empty(self, *args, **kwargs):
+        pass
+
+    def response_file(self, *args, **kwargs):
+        pass
+
+    def response_str(self, *args, **kwargs):
+        pass
+
+    def response_stream(self, *args, **kwargs):
+        pass
+
+    def __aiter__(self, *args, **kwargs):
+        return self
+
+    async def __anext__(self, *args, **kwargs):
+        if self.data:
+            return self.data.pop(0)
+        raise StopAsyncIteration
+
+    def __call__(self, *args, **kwargs):
+        pass
+
+    def __init__(self, *args, **kwargs):
+        self.data = list(args)
+
+    @staticmethod
+    def __new__(cls, *args, **kwargs):
+        pass
+
+
+class RSGIWebsocketProtocol(object):
+    def accept(self, *args, **kwargs):
+        pass
+
+    def close(self, *args, **kwargs):
+        pass
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    @staticmethod
+    def __new__(cls, *args, **kwargs):
+        pass
+
+
+class RSGIWebsocketScope(RSGIHTTPScope):
+    pass

rsgiadapter-0.0.3/src/rsgiadapter/response.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Union
+
+
+class BodyIter:
+    def __init__(self):
+        self._body = []
+
+    def __len__(self):
+        return len(self._body)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if not self._body:
+            raise StopIteration
+        return self._body.pop(0)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        if not self._body:
+            raise StopAsyncIteration
+        return self._body.pop(0)
+
+    def append(self, data: Union[Dict[str, Union[bytes, str]], bytes]):
+        self._body.append(data)
+
+    def get_body(self):
+        return self._body
+
+    def clear_body(self):
+        self._body.clear()
+
+
+@dataclass
+class Response:
+    status: Optional[int] = None
+    headers: Union[List[tuple], Tuple[tuple]] = field(default_factory=list)
+    body: BodyIter = field(default_factory=BodyIter)
+    path: Optional[str] = b""
+    stream: Optional[bool] = False
+    type: Optional[str] = None
+
+    def get_body(self):
+        return self.body.get_body()
+
+    def clear_body(self):
+        self.body.clear_body()

rsgiadapter-0.0.3/tests/test_asgi.py

@@ -0,0 +1,180 @@
+import inspect
+import unittest
+from pathlib import Path
+from types import CodeType
+from unittest.mock import AsyncMock, MagicMock, Mock, NonCallableMock, call
+
+from rsgiadapter.asgi import ASGIToRSGIAdapter
+from rsgiadapter.response import BodyIter, Response
+
+
+class Stream(Mock):
+
+    send_bytes = AsyncMock()
+
+    send_str = AsyncMock()
+
+
+class MockAsyncIterator:
+    """
+    Wraps an iterator in an asynchronous iterator.
+    """
+
+    def __init__(self, iterator):
+        self.iterator = iterator
+        code_mock = NonCallableMock(spec_set=CodeType)
+        code_mock.co_flags = inspect.CO_ITERABLE_COROUTINE
+        self.__dict__["__code__"] = code_mock
+
+    async def __anext__(self):
+        try:
+            return next(self.iterator)
+        except StopIteration:
+            pass
+        raise StopAsyncIteration
+
+    def __aiter__(self):
+        return self
+
+
+class TestMakeASGIScope(unittest.TestCase):
+
+    def setUp(self):
+        self.test_scope = Mock()
+        self.test_scope.proto = "http"
+        self.test_scope.http_version = "1.1"
+        self.test_scope.server = "example.com:80"
+        self.test_scope.client = "127.0.0.1:1234"
+        self.test_scope.scheme = "https"
+        self.test_scope.method = "GET"
+        self.test_scope.path = "/test"
+        self.test_scope.query_string = "key=value"
+        self.test_scope.headers = {"Content-Type": "application/json"}
+
+        self.asgi_app = ASGIToRSGIAdapter(None)
+
+    def test_scope_not_none(self):
+        result = self.asgi_app.make_asgi_scope(self.test_scope)
+        self.assertIsNotNone(result)
+
+    def test_raise_value_error_if_scope_none(self):
+        with self.assertRaises(ValueError):
+            self.asgi_app.make_asgi_scope(None)
+
+    def test_correct_attribute_assignment(self):
+        result = self.asgi_app.make_asgi_scope(self.test_scope)
+        self.assertEqual(result["type"], "http")
+        self.assertEqual(result["http_version"], "1.1")
+        self.assertEqual(result["server"], ["example.com", "80"])
+        self.assertEqual(result["client"], ["127.0.0.1", "1234"])
+        self.assertEqual(result["scheme"], "https")
+        self.assertEqual(result["method"], "GET")
+        self.assertEqual(result["path"], "/test")
+        self.assertEqual(result["raw_path"], b"/test")
+        self.assertEqual(result["query_string"], b"key=value")
+        self.assertEqual(result["headers"], [(b"Content-Type", b"application/json")])
+
+
+class TestYieldBody(unittest.IsolatedAsyncioTestCase):
+    async def test_yield_body(self):
+        # Test case: yielding messages from a protocol
+        mock_protocol = AsyncMock()
+
+        async def mock_protocol_async_iter():
+            yield 1
+            yield 2
+            yield 3
+            # 模拟迭代结束
+            raise StopAsyncIteration
+
+        mock_protocol = AsyncMock()
+
+        mock_protocol.__aiter__ = AsyncMock(return_value=mock_protocol_async_iter())
+
+        mock_protocol.__anext__.side_effect = mock_protocol_async_iter()
+        mock_protocol = MockAsyncIterator(iter([1, 2, 3]))
+        adapter = ASGIToRSGIAdapter(None)
+        result = []
+        async for msg in adapter.yield_body(mock_protocol):
+            result.append(msg)
+
+        self.assertEqual(result, [1, 2, 3])
+
+        # Test case: yielding an empty result
+        protocol = MockAsyncIterator(iter([]))
+
+        adapter = ASGIToRSGIAdapter(None)
+        result = []
+        async for msg in adapter.yield_body(protocol):
+            result.append(msg)
+
+        self.assertEqual(result, [])
+
+        # Test case: yielding a single message
+        protocol = MockAsyncIterator(iter([4]))
+
+        adapter = ASGIToRSGIAdapter(None)
+        result = []
+        async for msg in adapter.yield_body(protocol):
+            result.append(msg)
+
+        self.assertEqual(result, [4])
+
+
+class TestPerformResponse(unittest.IsolatedAsyncioTestCase):
+
+    def setUp(self):
+        self.protocol = AsyncMock()
+        body = BodyIter()
+        body.append(b"hello")
+        body.append(b"world")
+        self.response = Response(
+            status=200,
+            headers=[("Content-Type", "text/plain")],
+            body=body,
+            path=None,
+            stream=None,
+            type=None,
+        )
+        self.mock_response_stream_return = Stream()
+        self.protocol.response_stream = Mock(
+            return_value=self.mock_response_stream_return
+        )
+        self.protocol.response_bytes = Mock()
+        self.protocol.response_file = Mock()
+        self.adapter = ASGIToRSGIAdapter(None, None, None)
+
+    async def test_response_file(self):
+        self.response.path = Path("test.txt")
+        await self.adapter.perform_response(self.protocol, self.response)
+        self.protocol.response_file.assert_called_once_with(
+            status=200,
+            headers=[("Content-Type", "text/plain")],
+            file=Path("test.txt"),
+        )
+
+    async def test_response_stream(self):
+        await self.adapter.perform_response(self.protocol, self.response)
+        self.protocol.response_stream.assert_called_once_with(
+            status=200,
+            headers=[("Content-Type", "text/plain")],
+        )
+        self.mock_response_stream_return.send_bytes.assert_has_calls(
+            [
+                call(b"hello"),
+                call(b"world"),
+            ]
+        )
+
+    async def test_response_bytes(self):
+        self.response.body = BodyIter()
+        await self.adapter.perform_response(self.protocol, self.response)
+        self.protocol.response_bytes.assert_called_once_with(
+            status=200,
+            headers=[("Content-Type", "text/plain")],
+            body=b"",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()