ci: Add integration tests for headers.

Author: dbanty

integration-tests/integration_tests/api/parameters/__init__.py

@@ -0,0 +1,185 @@
+from typing import Any, Dict, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.post_parameters_header_response_200 import PostParametersHeaderResponse200
+from ...models.public_error import PublicError
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    boolean_header: bool,
+    string_header: str,
+    number_header: float,
+    integer_header: int,
+) -> Dict[str, Any]:
+    url = "{}/parameters/header".format(client.base_url)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    headers["Boolean-Header"] = "true" if boolean_header else "false"
+
+    headers["String-Header"] = string_header
+
+    headers["Number-Header"] = str(number_header)
+
+    headers["Integer-Header"] = str(integer_header)
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+    }
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[Union[PostParametersHeaderResponse200, PublicError]]:
+    if response.status_code == 200:
+        response_200 = PostParametersHeaderResponse200.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = PublicError.from_dict(response.json())
+
+        return response_400
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[Union[PostParametersHeaderResponse200, PublicError]]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    boolean_header: bool,
+    string_header: str,
+    number_header: float,
+    integer_header: int,
+) -> Response[Union[PostParametersHeaderResponse200, PublicError]]:
+    """
+    Args:
+        boolean_header (bool):
+        string_header (str):
+        number_header (float):
+        integer_header (int):
+
+    Returns:
+        Response[Union[PostParametersHeaderResponse200, PublicError]]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        boolean_header=boolean_header,
+        string_header=string_header,
+        number_header=number_header,
+        integer_header=integer_header,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: Client,
+    boolean_header: bool,
+    string_header: str,
+    number_header: float,
+    integer_header: int,
+) -> Optional[Union[PostParametersHeaderResponse200, PublicError]]:
+    """
+    Args:
+        boolean_header (bool):
+        string_header (str):
+        number_header (float):
+        integer_header (int):
+
+    Returns:
+        Response[Union[PostParametersHeaderResponse200, PublicError]]
+    """
+
+    return sync_detailed(
+        client=client,
+        boolean_header=boolean_header,
+        string_header=string_header,
+        number_header=number_header,
+        integer_header=integer_header,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    boolean_header: bool,
+    string_header: str,
+    number_header: float,
+    integer_header: int,
+) -> Response[Union[PostParametersHeaderResponse200, PublicError]]:
+    """
+    Args:
+        boolean_header (bool):
+        string_header (str):
+        number_header (float):
+        integer_header (int):
+
+    Returns:
+        Response[Union[PostParametersHeaderResponse200, PublicError]]
+    """
+
+    kwargs = _get_kwargs(
+        client=client,
+        boolean_header=boolean_header,
+        string_header=string_header,
+        number_header=number_header,
+        integer_header=integer_header,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)
+
+
+async def asyncio(
+    *,
+    client: Client,
+    boolean_header: bool,
+    string_header: str,
+    number_header: float,
+    integer_header: int,
+) -> Optional[Union[PostParametersHeaderResponse200, PublicError]]:
+    """
+    Args:
+        boolean_header (bool):
+        string_header (str):
+        number_header (float):
+        integer_header (int):
+
+    Returns:
+        Response[Union[PostParametersHeaderResponse200, PublicError]]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            boolean_header=boolean_header,
+            string_header=string_header,
+            number_header=number_header,
+            integer_header=integer_header,
+        )
+    ).parsed

integration-tests/integration_tests/api/parameters/post_parameters_header.py

@@ -2,5 +2,6 @@
 
 from .post_body_multipart_multipart_data import PostBodyMultipartMultipartData
 from .post_body_multipart_response_200 import PostBodyMultipartResponse200
+from .post_parameters_header_response_200 import PostParametersHeaderResponse200
 from .problem import Problem
 from .public_error import PublicError

integration-tests/integration_tests/models/__init__.py

@@ -0,0 +1,78 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="PostParametersHeaderResponse200")
+
+
+@attr.s(auto_attribs=True)
+class PostParametersHeaderResponse200:
+    """
+    Attributes:
+        boolean (bool): Echo of the 'Boolean-Header' input parameter from the header.
+        string (str): Echo of the 'String-Header' input parameter from the header.
+        number (float): Echo of the 'Number-Header' input parameter from the header.
+        integer (int): Echo of the 'Integer-Header' input parameter from the header.
+    """
+
+    boolean: bool
+    string: str
+    number: float
+    integer: int
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        boolean = self.boolean
+        string = self.string
+        number = self.number
+        integer = self.integer
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "boolean": boolean,
+                "string": string,
+                "number": number,
+                "integer": integer,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        boolean = d.pop("boolean")
+
+        string = d.pop("string")
+
+        number = d.pop("number")
+
+        integer = d.pop("integer")
+
+        post_parameters_header_response_200 = cls(
+            boolean=boolean,
+            string=string,
+            number=number,
+            integer=integer,
+        )
+
+        post_parameters_header_response_200.additional_properties = d
+        return post_parameters_header_response_200
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

integration-tests/integration_tests/models/post_parameters_header_response_200.py

@@ -0,0 +1,7 @@
+import pytest
+from integration_tests.client import Client
+
+
+@pytest.fixture(scope="session")
+def client() -> Client:
+    return Client("http://localhost:3000")

integration-tests/tests/conftest.py

@@ -7,9 +7,7 @@
 from integration_tests.types import File
 
 
-def test() -> None:
-    client = Client("http://localhost:3000")
-
+def test(client: Client) -> None:
     a_string = "a test string"
     payload = b"some file content"
     file_name = "cool_stuff.txt"

integration-tests/tests/test_api/test_body/test_post_body_multipart.py

@@ -0,0 +1,29 @@
+from integration_tests.api.parameters.post_parameters_header import sync_detailed
+from integration_tests.client import Client
+from integration_tests.models.post_parameters_header_response_200 import PostParametersHeaderResponse200
+
+
+def test(client: Client) -> None:
+    string_header = "a test string"
+    integer_header = 1
+    number_header = 1.1
+    boolean_header = True
+
+    response = sync_detailed(
+        client=client,
+        boolean_header=boolean_header,
+        string_header=string_header,
+        integer_header=integer_header,
+        number_header=number_header,
+    )
+
+    parsed = response.parsed
+    assert parsed is not None, f"{response.status_code}: {response.content}"
+    assert isinstance(
+        parsed,
+        PostParametersHeaderResponse200,
+    ), parsed
+    assert parsed.string == string_header
+    assert parsed.integer == integer_header
+    assert parsed.number == number_header
+    assert parsed.boolean == boolean_header