Update pytest-asyncio to actually run async tests (#119)

* bump pytest and pytest-asyncio to latest versions

* regenerate lockfiles

* remove unnecessary @pytest.mark.asyncio (we have asyncio_mode=auto)

* fix endpoint provider unit test

* equality operator for URI objects

* update pants and ignore W503 which conflicts with black

Author: jonemo

codegen/smithy-python-codegen/src/main/java/software/amazon/smithy/python/codegen/HttpProtocolTestGenerator.java

@@ -375,7 +375,7 @@ private void writeUtilStubs(Symbol serviceSymbol) {
         LOGGER.fine(String.format("Writing utility stubs for %s : %s", serviceSymbol.getName(), protocol.getName()));
         writer.addStdlibImport("typing", "Any");
         writer.addImports("smithy_python.interfaces.http", Set.of(
-                "HeadersList", "HttpRequestConfiguration", "Request", "Response")
+                "Fields", "HttpRequestConfiguration", "Request", "Response")
         );
         writer.addImport("smithy_python._private.http", "Response", "_Response");
 
@@ -415,7 +415,7 @@ async def read(self, size: int = -1) -> bytes:
                         class $4L:
                             ""\"An asynchronous HTTP client solely for testing purposes.""\"
 
-                            def __init__(self, status_code: int, headers: HeadersList, body: bytes):
+                            def __init__(self, status_code: int, headers: Fields, body: bytes):
                                 self.status_code = status_code
                                 self.headers = headers
                                 self.body = AwaitableBody(body)

codegen/smithy-python-codegen/src/main/java/software/amazon/smithy/python/codegen/integration/HttpBindingProtocolGenerator.java

@@ -186,8 +186,8 @@ private void serializeHeaders(
         writer.pushState(new SerializeFieldsSection(operation));
         // TODO: map headers from inputs
         // TODO: write out default http and protocol headers
-        writer.addImport("smithy_python.interfaces.http", "HeadersList", "_HeadersList");
-        writer.write("headers: _HeadersList = []");
+        writer.addImport("smithy_python.interfaces.http", "Fields", "_Fields");
+        writer.write("headers: _Fields = []");
         writer.popState();
     }
 

python-packages/smithy-python/smithy_python/_private/http/__init__.py

@@ -13,36 +13,50 @@
 
 # TODO: move all of this out of _private
 
+<<<<<<< HEAD
 
 from collections import OrderedDict
 from dataclasses import dataclass, field
 from typing import Any, Iterable, Protocol
+=======
+from collections import OrderedDict
+from collections.abc import AsyncIterable
+from dataclasses import dataclass, field
+from typing import Protocol
+>>>>>>> 23a2690 (Update pytest-asyncio to actually run async tests (#119))
 from urllib.parse import urlparse, urlunparse
 
 from ... import interfaces
 from ...interfaces.http import FieldPosition as FieldPosition  # re-export
 
 
-class URI:
-    def __init__(
-        self,
-        host: str,
-        path: str | None = None,
-        scheme: str | None = None,
-        query: str | None = None,
-        port: int | None = None,
-        username: str | None = None,
-        password: str | None = None,
-        fragment: str | None = None,
-    ):
-        self.scheme: str = "https" if scheme is None else scheme
-        self.host = host
-        self.port = port
-        self.path = path
-        self.query = query
-        self.username = username
-        self.password = password
-        self.fragment = fragment
+@dataclass(kw_only=True)
+class URI(interfaces.URI):
+    """Universal Resource Identifier, target location for a :py:class:`HTTPRequest`."""
+
+    scheme: str = "https"
+    """For example ``http`` or ``https``."""
+
+    username: str | None = None
+    """Username part of the userinfo URI component."""
+
+    password: str | None = None
+    """Password part of the userinfo URI component."""
+
+    host: str
+    """The hostname, for example ``amazonaws.com``."""
+
+    port: int | None = None
+    """An explicit port number."""
+
+    path: str | None = None
+    """Path component of the URI."""
+
+    query: str | None = None
+    """Query component of the URI as string."""
+
+    fragment: str | None = None
+    """Part of the URI specification, but may not be transmitted by a client."""
 
     @property
     def netloc(self) -> str:
@@ -89,10 +103,68 @@ def __eq__(self, other: object) -> bool:
             and self.fragment == other.fragment
         )
 
+<<<<<<< HEAD
+=======
+
+@dataclass(kw_only=True)
+class HTTPRequest(interfaces.http.HTTPRequest):
+    """
+    HTTP primitives for an Exchange to construct a version agnostic HTTP message.
+    """
+
+    destination: interfaces.URI
+    body: AsyncIterable[bytes]
+    method: str
+    fields: interfaces.http.Fields
+
+    async def consume_body(self) -> bytes:
+        """Iterate over request body and return as bytes."""
+        body = b""
+        async for chunk in self.body:
+            body += chunk
+        return body
+
+
+@dataclass(kw_only=True)
+class HTTPResponse(interfaces.http.HTTPResponse):
+    body: AsyncIterable[bytes]
+    status: int
+    fields: interfaces.http.Fields
+    reason: str | None = None
+
+    async def consume_body(self) -> bytes:
+        """Iterate over response body and return as bytes."""
+        body = b""
+        async for chunk in self.body:
+            body += chunk
+        return body
+
+    @property
+    def done(self) -> bool:
+        """
+        Has the complete body been received.
+
+        Always returns True. Subclasses in implementations that support response
+        streaming may override this.
+        """
+        return True
+
+
+class Field(interfaces.http.Field):
+    """
+    A name-value pair representing a single field in an HTTP Request or Response.
+
+    The kind will dictate metadata placement within an HTTP message.
+
+    All field names are case insensitive and case-variance must be treated as
+    equivalent. Names may be normalized but should be preserved for accuracy during
+    transmission.
+    """
+>>>>>>> 23a2690 (Update pytest-asyncio to actually run async tests (#119))
 
-class Request:
     def __init__(
         self,
+<<<<<<< HEAD
         url: interfaces.http.URI,
         method: str = "GET",
         headers: interfaces.http.HeadersList | None = None,
@@ -104,18 +176,135 @@ def __init__(
         self.headers: interfaces.http.HeadersList = []
         if headers is not None:
             self.headers = headers
+=======
+        name: str,
+        value: list[str] | None = None,
+        kind: FieldPosition | None = FieldPosition.HEADER,
+    ) -> None:
+        self.name = name
+        self.value = value
+        self.kind = kind
+
+    def add(self, value: str) -> None:
+        """Append a value to a field"""
+        if self.value is None:
+            self.value = [value]
+        else:
+            self.value.append(value)
+
+    def set(self, value: list[str]) -> None:
+        """Overwrite existing field values."""
+        self.value = value
+
+    def remove(self, value: str) -> None:
+        """Remove all matching entries from list"""
+        if self.value is None:
+            return
+        try:
+            while True:
+                self.value.remove(value)
+        except ValueError:
+            return
+
+    def _quote_and_escape_single_value(self, value: str) -> str:
+        """Escapes and quotes a single value if necessary.
+
+        A value is surrounded by double quotes if it contains comma (,) or whitespace.
+        Any double quote characters present in the value (before quoting) are escaped
+        with a backslash.
+        """
+        escaped = value.replace('"', '\\"')
+        needs_quoting = any(char == "," or char.isspace() for char in escaped)
+        quoted = f'"{escaped}"' if needs_quoting else escaped
+        return quoted
+
+    def get_value(self) -> str:
+        """
+        Get comma-delimited string values.
+
+        Values with spaces or commas are double-quoted.
+        """
+        if self.value is None:
+            return ""
+        return ",".join(self._quote_and_escape_single_value(val) for val in self.value)
+
+    def get_value_list(self) -> list[str]:
+        """Get string values as a list"""
+        if self.value is None:
+            return []
+        else:
+            return self.value
+
+    def __eq__(self, other: object) -> bool:
+        """Name, values, and kind must match. Values order must match."""
+        if not isinstance(other, Field):
+            return False
+        return (
+            self.name == other.name
+            and self.kind == other.kind
+            and self.value == other.value
+        )
+
+    def __repr__(self) -> str:
+        return f"Field({self.kind.name} {self.name}: {self.get_value()})"
+>>>>>>> 23a2690 (Update pytest-asyncio to actually run async tests (#119))
+
 
+class Fields(interfaces.http.Fields):
+    """Collection of Field entries mapped by name."""
 
-class Response:
     def __init__(
         self,
+<<<<<<< HEAD
         status_code: int,
         headers: interfaces.http.HeadersList,
         body: Any,
     ):
         self.status_code: int = status_code
         self.headers: interfaces.http.HeadersList = headers
         self.body: Any = body
+=======
+        initial: list[interfaces.http.Field] | None = None,
+        *,
+        encoding: str = "utf-8",
+    ) -> None:
+        init_tuples = [] if initial is None else [(fld.name, fld) for fld in initial]
+        self.entries: OrderedDict[str, interfaces.http.Field] = OrderedDict(init_tuples)
+        self.encoding: str = encoding
+
+    def set_field(self, field: interfaces.http.Field) -> None:
+        """Set entry for a Field name."""
+        self.entries[field.name] = field
+
+    def get_field(self, name: str) -> interfaces.http.Field:
+        """Retrieve Field entry"""
+        return self.entries[name]
+
+    def remove_field(self, name: str) -> None:
+        """Delete entry from collection"""
+        del self.entries[name]
+
+    def get_by_type(self, kind: FieldPosition) -> list[interfaces.http.Field]:
+        """Helper function for retrieving specific types of fields
+
+        Used to grab all headers or all trailers
+        """
+        return [entry for entry in self.entries.values() if entry.kind == kind]
+
+    def __eq__(self, other: object) -> bool:
+        """Encoding must match. Entries must match in values but not order."""
+        if not isinstance(other, Fields):
+            return False
+        if self.encoding != other.encoding:
+            return False
+        if set(self.entries.keys()) != set(other.entries.keys()):
+            return False
+        for field_name, self_field in self.entries.items():
+            other_field = other.get_field(field_name)
+            if self_field != other_field:
+                return False
+        return True
+>>>>>>> 23a2690 (Update pytest-asyncio to actually run async tests (#119))
 
 
 class Field(interfaces.http.Field):
@@ -251,8 +440,13 @@ def __iter__(self) -> Iterable[interfaces.http.Field]:
 
 @dataclass
 class Endpoint(interfaces.http.Endpoint):
+<<<<<<< HEAD
     url: interfaces.http.URI
     headers: interfaces.http.HeadersList = field(default_factory=list)
+=======
+    url: interfaces.URI
+    headers: interfaces.http.Fields = field(default_factory=Fields)
+>>>>>>> 23a2690 (Update pytest-asyncio to actually run async tests (#119))
 
 
 @dataclass
@@ -263,7 +457,11 @@ class StaticEndpointParams:
     :params url: A static URI to route requests to.
     """
 
+<<<<<<< HEAD
     url: str | interfaces.http.URI
+=======
+    url: str | interfaces.URI
+>>>>>>> 23a2690 (Update pytest-asyncio to actually run async tests (#119))
 
 
 class StaticEndpointResolver(interfaces.http.EndpointResolver[StaticEndpointParams]):