def make_request(
self: BaseApi,
petid: int,
) -> Pet:
"""Find pet by ID"""
body = None
m = ApiRequest(
method="GET",
path="/api/v3/pet/{petId}".format(petId=petid, ),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": Pet,
"application/xml": Pet,
},
"400": {
"default": None,
},
"404": {
"default": None,
},
},
m,
)
def make_request(
self: BaseApi,
__request__: User,
) -> None:
"""Create user"""
body = __request__
m = ApiRequest(
method="POST",
path="/api/v3/user".format(),
content_type="application/json",
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"content": {
"default": None,
},
"default": {
"application/json": User,
"application/xml": User,
},
"description": {
"default": None,
},
},
m,
)
def make_request(self: BaseApi, username: str = ..., password: str = ...,) -> str:
"""Logs user into the system"""
def serialize_item(item):
if isinstance(item, pydantic.BaseModel):
return item.dict()
return item
body = None
m = ApiRequest(
method="GET",
path="/api/v3/user/login".format(),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({"username": username, "password": password,}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {"application/json": str, "application/xml": str,},
"400": {"default": None,},
},
m,
)
def make_request(
self: BaseApi,
orderid: int,
) -> None:
"""Delete purchase order by ID"""
body = None
m = ApiRequest(
method="DELETE",
path="/api/v3/store/order/{orderId}".format(orderId=orderid, ),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"400": {
"default": None,
},
"404": {
"default": None,
},
},
m,
)
def make_request(
self,
tags: typing.List[str] = ...,
) -> typing.List[Pet]:
"""Finds Pets by tags"""
m = ApiRequest(
method="GET",
path="/api/v3/pet/findByTags".format(),
content_type=None,
body=None,
headers=self._only_provided({}),
query_params=self._only_provided({
"tags": tags,
}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": typing.List[Pet],
"application/xml": typing.List[Pet],
},
},
m,
)
def make_request(
self: BaseApi,
orderid: int,
) -> Order:
"""Find purchase order by ID"""
body = None
m = ApiRequest(
method="GET",
path="/api/v3/store/order/{orderId}".format(orderId=orderid, ),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": Order,
"application/xml": Order,
},
"400": {
"default": None,
},
"404": {
"default": None,
},
},
m,
)
def make_request(
self: BaseApi,
cpf: int,
) -> Cliente:
"""Obtem um cliente usando CPF como chave"""
body = None
m = ApiRequest(
method="GET",
path="/api/clientes/{cpf}".format(cpf=cpf, ),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": Cliente,
"application/xml": Cliente,
},
"400": {
"default": None,
},
"404": {
"default": None,
},
}, m)
def make_request(
self: BaseApi,
petid: int,
api_key: str = ...,
) -> None:
"""Deletes a pet"""
def serialize_item(item):
if isinstance(item, pydantic.BaseModel):
return item.dict()
return item
body = None
m = ApiRequest(
method="DELETE",
path="/api/v3/pet/{petId}".format(petId=petid, ),
content_type=None,
body=body,
headers=self._only_provided({
"api_key": api_key,
}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request({
"400": {
"default": None,
},
}, m)
def make_request(
self: BaseApi,
__request__: Pet,
) -> Pet:
"""Update an existing pet"""
body = __request__
m = ApiRequest(
method="PUT",
path="/api/v3/pet".format(),
content_type="application/json",
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": Pet,
"application/xml": Pet,
},
"400": {
"default": None,
},
"404": {
"default": None,
},
"405": {
"default": None,
},
},
m,
)
def make_request(
self: BaseApi,
tags: typing.List[str] = ...,
) -> typing.List[Pet]:
"""Finds Pets by tags"""
def serialize_item(item):
if isinstance(item, pydantic.BaseModel):
return item.dict()
return item
body = None
m = ApiRequest(
method="GET",
path="/api/v3/pet/findByTags".format(),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({
"tags": tags,
}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": typing.List[Pet],
"application/xml": typing.List[Pet],
},
"400": {
"default": None,
},
},
m,
)
def make_request(self: BaseApi, petid: int,) -> Pet:
"""Find pet by ID"""
def serialize_item(item):
if isinstance(item, pydantic.BaseModel):
return item.dict()
return item
body = None
m = ApiRequest(
method="GET",
path="/api/v3/pet/{petId}".format(petId=petid,),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {"application/json": Pet, "application/xml": Pet,},
"400": {"default": None,},
"404": {"default": None,},
},
m,
)
def make_request(
self: BaseApi,
__request__: Cliente,
) -> None:
"""Cadastrar um novo cliente"""
body = __request__
m = ApiRequest(
method="POST",
path="/api/clientes".format(),
content_type="application/json",
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"201": {
"default": None,
},
"405": {
"default": None,
},
}, m)
def make_request(
self: BaseApi,
status: str = "available",
) -> typing.List[Pet]:
"""Finds Pets by status"""
body = None
m = ApiRequest(
method="GET",
path="/api/v3/pet/findByStatus".format(),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({
"status": status,
}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": typing.List[Pet],
"application/xml": typing.List[Pet],
},
"400": {
"default": None,
},
},
m,
)
def make_request(
self: BaseApi,
petid: int,
api_key: str = ...,
) -> None:
"""Deletes a pet"""
body = None
m = ApiRequest(
method="DELETE",
path="/api/v3/pet/{petId}".format(petId=petid, ),
content_type=None,
body=body,
headers=self._only_provided({
"api_key": api_key,
}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"400": {
"default": None,
},
},
m,
)
def make_request(
self: BaseApi,
__request__: User,
username: str,
) -> None:
"""Update user"""
body = __request__
m = ApiRequest(
method="PUT",
path="/api/v3/user/{username}".format(username=username, ),
content_type="application/json",
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"default": {
"default": None,
},
},
m,
)
def make_request(self: BaseApi, username: str,) -> User:
"""Get user by user name"""
def serialize_item(item):
if isinstance(item, pydantic.BaseModel):
return item.dict()
return item
body = None
m = ApiRequest(
method="GET",
path="/api/v3/user/{username}".format(username=username,),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {"application/json": User, "application/xml": User,},
"400": {"default": None,},
"404": {"default": None,},
},
m,
)
def make_request(
self: BaseApi,
petid: int,
name: str = ...,
status: str = ...,
) -> None:
"""Updates a pet in the store with form data"""
body = None
m = ApiRequest(
method="POST",
path="/api/v3/pet/{petId}".format(petId=petid, ),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({
"name": name,
"status": status,
}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"405": {
"default": None,
},
},
m,
)
def test_post(url: Callable, adapter: HttpClientAdapter):
class Payload(BaseModel):
field: str
request_body = {
"string": "string",
"number": 1,
"list": [1, "string", Payload(field="payload")],
"bool": True,
}
request_url = url("post")
request = ApiRequest(
method="POST",
path=request_url,
query_params={"value": 10},
headers={"X-Test-Header": "test"},
cookies={"my-cookie": "test"},
content_type="application/json",
body=request_body,
)
response = adapter.call(request)
assert isinstance(response, ApiResponse)
assert isinstance(response.body, dict)
assert response.body["args"] == {"value": "10"}
assert response.body["headers"]["X-Test-Header"] == "test"
assert response.body["headers"]["Cookie"] == "my-cookie=test"
assert response.content_type == "application/json"
assert response.status_code == 200
assert response.url == request_url + "?value=10"
assert response.body["data"] == json.dumps(request_body)
assert response.body["json"] == request_body
def make_request(
self: BaseApi,
__request__: Instalacao,
) -> None:
"""Cria uma nova instalação"""
body = __request__
m = ApiRequest(
method="POST",
path="/api/instalacoes".format(),
content_type="application/json",
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"201": {
"default": None,
},
"405": {
"default": None,
},
}, m)
def make_request(
self: BaseApi,
codigo: int,
) -> Fatura:
"""Obtem uma fatura pelo código"""
body = None
m = ApiRequest(
method="GET",
path="/api/faturas/{codigo}".format(codigo=codigo, ),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": Fatura,
"application/xml": Fatura,
},
"400": {
"default": None,
},
"404": {
"default": None,
},
}, m)
def make_request(
self: BaseApi,
__request__: typing.List[User],
) -> User:
"""Creates list of users with given input array"""
body = __request__
m = ApiRequest(
method="POST",
path="/api/v3/user/createWithList".format(),
content_type="application/json",
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": User,
"application/xml": User,
},
"default": {
"default": None,
},
},
m,
)
def make_request(
self: BaseApi,
username: str,
) -> None:
"""Delete user"""
body = None
m = ApiRequest(
method="DELETE",
path="/api/v3/user/{username}".format(username=username, ),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"400": {
"default": None,
},
"404": {
"default": None,
},
},
m,
)
def make_request(
self,
username: str = ...,
password: str = ...,
) -> str:
"""Logs user into the system"""
m = ApiRequest(
method="GET",
path="/api/v3/user/login".format(),
content_type=None,
body=None,
headers=self._only_provided({}),
query_params=self._only_provided({
"username": username,
"password": password,
}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": str,
"application/xml": str,
},
}, m)
def make_request(
self: BaseApi,
username: str,
) -> User:
"""Get user by user name"""
body = None
m = ApiRequest(
method="GET",
path="/api/v3/user/{username}".format(username=username, ),
content_type=None,
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": User,
"application/xml": User,
},
"400": {
"default": None,
},
"404": {
"default": None,
},
},
m,
)
def make_request(
self: BaseApi,
__request__: User,
username: str,
) -> None:
"""Update user"""
def serialize_item(item):
if isinstance(item, pydantic.BaseModel):
return item.dict()
return item
if isinstance(__request__, (list, tuple, set)):
body = [serialize_item(item) for item in __request__]
else:
body = __request__.dict()
m = ApiRequest(
method="PUT",
path="/api/v3/user/{username}".format(username=username, ),
content_type="application/json",
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request({
"default": {
"default": None,
},
}, m)
def make_request(
self: BaseApi,
__request__: bytes,
petid: int,
additionalmetadata: str = ...,
) -> ApiResponse:
"""uploads an image"""
body = __request__
m = ApiRequest(
method="POST",
path="/api/v3/pet/{petId}/uploadImage".format(
petId=petid,
),
content_type="application/json",
body=body,
headers=self._only_provided({}),
query_params=self._only_provided(
{
"additionalMetadata": additionalmetadata,
}
),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": ApiResponse,
},
},
m,
)
def make_request(
self: BaseApi,
__request__: Order,
) -> Order:
"""Place an order for a pet"""
def serialize_item(item):
if isinstance(item, pydantic.BaseModel):
return item.dict()
return item
if isinstance(__request__, (list, tuple, set)):
body = [serialize_item(item) for item in __request__]
else:
body = __request__.dict()
m = ApiRequest(
method="POST",
path="/api/v3/store/order".format(),
content_type="application/json",
body=body,
headers=self._only_provided({}),
query_params=self._only_provided({}),
cookies=self._only_provided({}),
)
return self.make_request(
{
"200": {
"application/json": Order,
},
"405": {
"default": None,
},
}, m)
def test_get_image(url: Callable, adapter: HttpClientAdapter):
request_url = url("image/png")
request = ApiRequest(method="GET", path=request_url,)
response = adapter.call(request)
assert isinstance(response, ApiResponse)
assert isinstance(response.body, bytes)
assert response.content_type == "image/png"
assert response.status_code == 200
def test_multiple_responses():
response_200 = ApiResponse(
url="/multiple-status-codes",
status_code=200,
content_type="application/json",
body={"message": "response-a"},
headers={},
)
response_400 = ApiResponse(
url="/multiple-status-codes",
status_code=400,
content_type="application/json",
body=None,
headers={},
)
adapter = mock.Mock()
adapter.call = mock.Mock(return_value=response_400)
configuration = Configuration(host="")
client = ApiClient(configuration, adapter)
api = BaseApi(client, configuration)
request = ApiRequest(
method="GET",
path="/multiple-status-codes",
content_type=None,
body=None,
headers={},
query_params={},
cookies={},
)
response_mapping = {
"200": {
"application/json": ResponseA
},
"400": {
"default": None
},
"422": {
"application/json": ResponseB
},
}
# 400
try:
api.make_request(response_mapping, request)
except ErrorApiResponse as e:
assert e.request == request
assert e.response == response_400
assert e.response_body is None
# 200
adapter.call = mock.Mock(return_value=response_200)
assert api.make_request(response_mapping,
request) == ResponseA(message="response-a")
def call_api(
self, api_request: ApiRequest
) -> Union[ApiResponse, Coroutine[None, None, ApiResponse]]:
method = api_request.clone(
path=self._configuration.host + api_request.path,
headers={
**api_request.headers,
**self._configuration.headers
},
)
return self._adapter.call(method)
