ci: Add integration tests

Author: dbanty

.github/workflows/checks.yml

@@ -61,3 +61,57 @@ jobs:
     - uses: codecov/codecov-action@v2
       with:
         files: ./coverage.xml
+
+  integration:
+    name: Integration Tests
+    runs-on: ubuntu-latest
+    env:
+      PYTHON_VERSION: 3.10
+    services:
+      openapi-test-server:
+        image: ghcr.io/openapi-generators/openapi-test-server:latest
+        ports:
+          - "3000:3000"
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Cache dependencies
+        uses: actions/cache@v2
+        with:
+          path: .venv
+          key: ${{ runner.os }}-${{ env.PYTHON_VERSION }}-dependencies-${{ hashFiles('**/poetry.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-${{ env.PYTHON_VERSION }}-dependencies
+      - name: Install dependencies
+        run: |
+          pip install poetry
+          python -m venv .venv
+          poetry run python -m pip install --upgrade pip
+          poetry install
+      - name: Regenerate Integration Client
+        run: |
+          poetry shell
+          cd integration_tests
+          openapi-python-client update --url http://localhost:3000/openapi.json
+      - name: Check if there are changes to the client
+        run: changed_files=$(git status --porcelain | wc -l) && [ changed_files != 0 ] && exit 1
+      - name: Cache Generated Client Dependencies
+        uses: actions/cache@v2
+        with:
+          path: integration_tests/openapi-test-server-client/.venv
+          key: ${{ runner.os }}-${{ env.PYTHON_VERSION }}-integration-dependencies-${{ hashFiles('**/poetry.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-${{ env.PYTHON_VERSION }}-integration-dependencies
+      - name: Install Integration Dependencies
+        run: |
+          cd integration_tests/openapi-test-server-client
+          python -m venv .venv
+          poetry run python -m pip install --upgrade pip
+          poetry install
+      - name: Run Tests
+        run: |
+          cd integration_tests/openapi-test-server-client
+          poetry run pytest

integration_tests/open-api-test-server-client/.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+
+# pyenv
+.python-version
+
+# Environments
+.env
+.venv
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# JetBrains
+.idea/
+
+/coverage.xml
+/.coverage

integration_tests/open-api-test-server-client/README.md

@@ -0,0 +1,87 @@
+# open-api-test-server-client
+A client library for accessing OpenAPI Test Server
+
+## Usage
+First, create a client:
+
+```python
+from open_api_test_server_client import Client
+
+client = Client(base_url="https://api.example.com")
+```
+
+If the endpoints you're going to hit require authentication, use `AuthenticatedClient` instead:
+
+```python
+from open_api_test_server_client import AuthenticatedClient
+
+client = AuthenticatedClient(base_url="https://api.example.com", token="SuperSecretToken")
+```
+
+Now call your endpoint and use your models:
+
+```python
+from open_api_test_server_client.models import MyDataModel
+from open_api_test_server_client.api.my_tag import get_my_data_model
+from open_api_test_server_client.types import Response
+
+my_data: MyDataModel = get_my_data_model.sync(client=client)
+# or if you need more info (e.g. status_code)
+response: Response[MyDataModel] = get_my_data_model.sync_detailed(client=client)
+```
+
+Or do the same thing with an async version:
+
+```python
+from open_api_test_server_client.models import MyDataModel
+from open_api_test_server_client.api.my_tag import get_my_data_model
+from open_api_test_server_client.types import Response
+
+my_data: MyDataModel = await get_my_data_model.asyncio(client=client)
+response: Response[MyDataModel] = await get_my_data_model.asyncio_detailed(client=client)
+```
+
+By default, when you're calling an HTTPS API it will attempt to verify that SSL is working correctly. Using certificate verification is highly recommended most of the time, but sometimes you may need to authenticate to a server (especially an internal server) using a custom certificate bundle.
+
+```python
+client = AuthenticatedClient(
+    base_url="https://internal_api.example.com", 
+    token="SuperSecretToken",
+    verify_ssl="/path/to/certificate_bundle.pem",
+)
+```
+
+You can also disable certificate validation altogether, but beware that **this is a security risk**.
+
+```python
+client = AuthenticatedClient(
+    base_url="https://internal_api.example.com", 
+    token="SuperSecretToken", 
+    verify_ssl=False
+)
+```
+
+Things to know:
+1. Every path/method combo becomes a Python module with four functions:
+    1. `sync`: Blocking request that returns parsed data (if successful) or `None`
+    1. `sync_detailed`: Blocking request that always returns a `Request`, optionally with `parsed` set if the request was successful.
+    1. `asyncio`: Like `sync` but the async instead of blocking
+    1. `asyncio_detailed`: Like `sync_detailed` by async instead of blocking
+
+1. All path/query params, and bodies become method arguments.
+1. If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)
+1. Any endpoint which did not have a tag will be in `open_api_test_server_client.api.default`
+
+## Building / publishing this Client
+This project uses [Poetry](https://python-poetry.org/) to manage dependencies  and packaging.  Here are the basics:
+1. Update the metadata in pyproject.toml (e.g. authors, version)
+1. If you're using a private repository, configure it with Poetry
+    1. `poetry config repositories.<your-repository-name> <url-to-your-repository>`
+    1. `poetry config http-basic.<your-repository-name> <username> <password>`
+1. Publish the client with `poetry publish --build -r <your-repository-name>` or, if for public PyPI, just `poetry publish --build`
+
+If you want to install this client into another project without publishing it (e.g. for development) then:
+1. If that project **is using Poetry**, you can simply do `poetry add <path-to-this-client>` from that project
+1. If that project is not using Poetry:
+    1. Build a wheel with `poetry build -f wheel`
+    1. Install that wheel from the other project `pip install <path-to-wheel>`

integration_tests/open-api-test-server-client/open_api_test_server_client/__init__.py

@@ -0,0 +1,2 @@
+""" A client library for accessing OpenAPI Test Server """
+from .client import AuthenticatedClient, Client

integration_tests/open-api-test-server-client/open_api_test_server_client/api/__init__.py

@@ -0,0 +1 @@
+""" Contains methods for accessing the API """

integration_tests/open-api-test-server-client/open_api_test_server_client/api/body/__init__.py

@@ -0,0 +1,113 @@
+from typing import Any, Dict, Optional, Union
+
+import httpx
+
+from ...client import Client
+from ...models.post_body_multipart_multipart_data import PostBodyMultipartMultipartData
+from ...models.post_body_multipart_response_200 import PostBodyMultipartResponse200
+from ...models.public_error import PublicError
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    multipart_data: PostBodyMultipartMultipartData,
+) -> Dict[str, Any]:
+    url = "{}/body/multipart".format(client.base_url)
+
+    headers: Dict[str, Any] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    multipart_multipart_data = multipart_data.to_multipart()
+
+    return {
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "files": multipart_multipart_data,
+    }
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[Union[PostBodyMultipartResponse200, PublicError]]:
+    if response.status_code == 200:
+        response_200 = PostBodyMultipartResponse200.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[PostBodyMultipartResponse200, PublicError]]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    multipart_data: PostBodyMultipartMultipartData,
+) -> Response[Union[PostBodyMultipartResponse200, PublicError]]:
+    kwargs = _get_kwargs(
+        client=client,
+        multipart_data=multipart_data,
+    )
+
+    response = httpx.post(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+def sync(
+    *,
+    client: Client,
+    multipart_data: PostBodyMultipartMultipartData,
+) -> Optional[Union[PostBodyMultipartResponse200, PublicError]]:
+    """ """
+
+    return sync_detailed(
+        client=client,
+        multipart_data=multipart_data,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    multipart_data: PostBodyMultipartMultipartData,
+) -> Response[Union[PostBodyMultipartResponse200, PublicError]]:
+    kwargs = _get_kwargs(
+        client=client,
+        multipart_data=multipart_data,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.post(**kwargs)
+
+    return _build_response(response=response)
+
+
+async def asyncio(
+    *,
+    client: Client,
+    multipart_data: PostBodyMultipartMultipartData,
+) -> Optional[Union[PostBodyMultipartResponse200, PublicError]]:
+    """ """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            multipart_data=multipart_data,
+        )
+    ).parsed

integration_tests/open-api-test-server-client/open_api_test_server_client/api/body/post_body_multipart.py

@@ -0,0 +1,48 @@
+import ssl
+from typing import Dict, Union
+
+import attr
+
+
+@attr.s(auto_attribs=True)
+class Client:
+    """A class for keeping track of data related to the API"""
+
+    base_url: str
+    cookies: Dict[str, str] = attr.ib(factory=dict, kw_only=True)
+    headers: Dict[str, str] = attr.ib(factory=dict, kw_only=True)
+    timeout: float = attr.ib(5.0, kw_only=True)
+    verify_ssl: Union[str, bool, ssl.SSLContext] = attr.ib(True, kw_only=True)
+
+    def get_headers(self) -> Dict[str, str]:
+        """Get headers to be used in all endpoints"""
+        return {**self.headers}
+
+    def with_headers(self, headers: Dict[str, str]) -> "Client":
+        """Get a new client matching this one with additional headers"""
+        return attr.evolve(self, headers={**self.headers, **headers})
+
+    def get_cookies(self) -> Dict[str, str]:
+        return {**self.cookies}
+
+    def with_cookies(self, cookies: Dict[str, str]) -> "Client":
+        """Get a new client matching this one with additional cookies"""
+        return attr.evolve(self, cookies={**self.cookies, **cookies})
+
+    def get_timeout(self) -> float:
+        return self.timeout
+
+    def with_timeout(self, timeout: float) -> "Client":
+        """Get a new client matching this one with a new timeout (in seconds)"""
+        return attr.evolve(self, timeout=timeout)
+
+
+@attr.s(auto_attribs=True)
+class AuthenticatedClient(Client):
+    """A Client which has been authenticated for use on secured endpoints"""
+
+    token: str
+
+    def get_headers(self) -> Dict[str, str]:
+        """Get headers to be used in authenticated endpoints"""
+        return {"Authorization": f"Bearer {self.token}", **self.headers}

integration_tests/open-api-test-server-client/open_api_test_server_client/client.py

@@ -0,0 +1,6 @@
+""" Contains all the data models used in inputs/outputs """
+
+from .post_body_multipart_multipart_data import PostBodyMultipartMultipartData
+from .post_body_multipart_response_200 import PostBodyMultipartResponse200
+from .problem import Problem
+from .public_error import PublicError