def test_from_data_standard(self, mocker):
from openapi_python_client.parser.openapi import Endpoint
path = mocker.MagicMock()
method = mocker.MagicMock()
param_schemas = mocker.MagicMock()
param_endpoint = mocker.MagicMock()
_add_parameters = mocker.patch.object(Endpoint,
"_add_parameters",
return_value=(param_endpoint,
param_schemas))
response_schemas = mocker.MagicMock()
response_endpoint = mocker.MagicMock()
_add_responses = mocker.patch.object(Endpoint,
"_add_responses",
return_value=(response_endpoint,
response_schemas))
body_schemas = mocker.MagicMock()
body_endpoint = mocker.MagicMock()
_add_body = mocker.patch.object(Endpoint,
"_add_body",
return_value=(body_endpoint,
body_schemas))
data = oai.Operation.construct(
description=mocker.MagicMock(),
operationId=mocker.MagicMock(),
security={"blah": "bloo"},
responses=mocker.MagicMock(),
)
initial_schemas = mocker.MagicMock()
mocker.patch("openapi_python_client.utils.remove_string_escapes",
return_value=data.description)
endpoint = Endpoint.from_data(data=data,
path=path,
method=method,
tag="default",
schemas=initial_schemas)
assert endpoint == _add_body.return_value
_add_parameters.assert_called_once_with(
endpoint=Endpoint(
path=path,
method=method,
description=data.description,
name=data.operationId,
requires_security=True,
tag="default",
),
data=data,
schemas=initial_schemas,
)
_add_responses.assert_called_once_with(endpoint=param_endpoint,
data=data.responses,
schemas=param_schemas)
_add_body.assert_called_once_with(endpoint=response_endpoint,
data=data,
schemas=response_schemas)
def test_add_body_bad_data(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
mocker.patch.object(Endpoint, "parse_request_form_body")
parse_error = ParseError(data=mocker.MagicMock())
other_schemas = mocker.MagicMock()
mocker.patch.object(Endpoint,
"parse_request_json_body",
return_value=(parse_error, other_schemas))
endpoint = Endpoint(
path="path",
method="method",
description=None,
name="name",
requires_security=False,
tag="tag",
relative_imports={"import_3"},
)
request_body = mocker.MagicMock()
schemas = Schemas()
result = Endpoint._add_body(
endpoint=endpoint,
data=oai.Operation.construct(requestBody=request_body),
schemas=schemas)
assert result == (
ParseError(detail=f"cannot parse body of endpoint {endpoint.name}",
data=parse_error.data),
other_schemas,
)
def test_add_body_happy(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Reference, Schemas
from openapi_python_client.parser.properties import Property
request_body = mocker.MagicMock()
form_body_reference = Reference.from_ref(ref="a")
multipart_body_reference = Reference.from_ref(ref="b")
parse_request_form_body = mocker.patch.object(
Endpoint,
"parse_request_form_body",
return_value=form_body_reference)
parse_multipart_body = mocker.patch.object(
Endpoint,
"parse_multipart_body",
return_value=multipart_body_reference)
json_body = mocker.MagicMock(autospec=Property)
json_body_imports = mocker.MagicMock()
json_body.get_imports.return_value = {json_body_imports}
parsed_schemas = mocker.MagicMock()
parse_request_json_body = mocker.patch.object(
Endpoint,
"parse_request_json_body",
return_value=(json_body, parsed_schemas))
import_string_from_reference = mocker.patch(
f"{MODULE_NAME}.import_string_from_reference",
side_effect=["import_1", "import_2"])
endpoint = Endpoint(
path="path",
method="method",
description=None,
name="name",
requires_security=False,
tag="tag",
relative_imports={"import_3"},
)
initial_schemas = mocker.MagicMock()
(endpoint, response_schemas) = Endpoint._add_body(
endpoint=endpoint,
data=oai.Operation.construct(requestBody=request_body),
schemas=initial_schemas)
assert response_schemas == parsed_schemas
parse_request_form_body.assert_called_once_with(request_body)
parse_request_json_body.assert_called_once_with(
body=request_body, schemas=initial_schemas, parent_name="name")
parse_multipart_body.assert_called_once_with(request_body)
import_string_from_reference.assert_has_calls([
mocker.call(form_body_reference, prefix="...models"),
mocker.call(multipart_body_reference, prefix="...models"),
])
json_body.get_imports.assert_called_once_with(prefix="...")
assert endpoint.relative_imports == {
"import_1", "import_2", "import_3", json_body_imports
}
assert endpoint.json_body == json_body
assert endpoint.form_body_reference == form_body_reference
assert endpoint.multipart_body_reference == multipart_body_reference
def test__add_parameters_parse_error(self, mocker):
from openapi_python_client.parser.openapi import Endpoint
endpoint = Endpoint(
path="path",
method="method",
description=None,
name="name",
requires_security=False,
tag="tag",
)
initial_schemas = mocker.MagicMock()
parse_error = ParseError(data=mocker.MagicMock())
property_schemas = mocker.MagicMock()
mocker.patch(f"{MODULE_NAME}.property_from_data",
return_value=(parse_error, property_schemas))
param = oai.Parameter.construct(name="test",
required=True,
param_schema=mocker.MagicMock(),
param_in="cookie")
result = Endpoint._add_parameters(
endpoint=endpoint,
data=oai.Operation.construct(parameters=[param]),
schemas=initial_schemas)
assert result == (
ParseError(
data=parse_error.data,
detail=f"cannot parse parameter of endpoint {endpoint.name}"),
property_schemas,
)
def test__add_responses_status_code_error(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
schemas = Schemas()
response_1_data = mocker.MagicMock()
response_2_data = mocker.MagicMock()
data = {
"not_a_number": response_1_data,
}
endpoint = Endpoint(
path="path",
method="method",
description=None,
name="name",
requires_security=False,
tag="tag",
relative_imports={"import_3"},
)
parse_error = ParseError(data=mocker.MagicMock())
response_from_data = mocker.patch(f"{MODULE_NAME}.response_from_data",
return_value=(parse_error, schemas))
response, schemas = Endpoint._add_responses(endpoint=endpoint,
data=data,
schemas=schemas)
assert response.errors == [
ParseError(
detail=
f"Invalid response status code not_a_number (not a number), response will be ommitted from generated client"
)
]
def test__add_parameters_fail_loudly_when_location_not_supported(
self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
endpoint = Endpoint(
path="path",
method="method",
description=None,
name="name",
requires_security=False,
tag="tag",
)
parsed_schemas = mocker.MagicMock()
mocker.patch(f"{MODULE_NAME}.property_from_data",
return_value=(mocker.MagicMock(), parsed_schemas))
param = oai.Parameter.construct(name="test",
required=True,
param_schema=mocker.MagicMock(),
param_in="cookie")
schemas = Schemas()
result = Endpoint._add_parameters(
endpoint=endpoint,
data=oai.Operation.construct(parameters=[param]),
schemas=schemas)
assert result == (ParseError(
data=param, detail="Parameter must be declared in path or query"),
parsed_schemas)
def test_from_data_no_security(self, mocker):
from openapi_python_client.parser.openapi import Endpoint
data = oai.Operation.construct(
description=mocker.MagicMock(),
operationId=mocker.MagicMock(),
security=None,
responses=mocker.MagicMock(),
)
_add_parameters = mocker.patch.object(
Endpoint,
"_add_parameters",
return_value=(mocker.MagicMock(), mocker.MagicMock()))
_add_responses = mocker.patch.object(Endpoint,
"_add_responses",
return_value=(mocker.MagicMock(),
mocker.MagicMock()))
_add_body = mocker.patch.object(Endpoint,
"_add_body",
return_value=(mocker.MagicMock(),
mocker.MagicMock()))
path = mocker.MagicMock()
method = mocker.MagicMock()
mocker.patch("openapi_python_client.utils.remove_string_escapes",
return_value=data.description)
schemas = mocker.MagicMock()
config = MagicMock()
Endpoint.from_data(data=data,
path=path,
method=method,
tag="a",
schemas=schemas,
config=config)
_add_parameters.assert_called_once_with(
endpoint=Endpoint(
path=path,
method=method,
description=data.description,
name=data.operationId,
requires_security=False,
tag="a",
),
data=data,
schemas=schemas,
config=config,
)
_add_responses.assert_called_once_with(
endpoint=_add_parameters.return_value[0],
data=data.responses,
schemas=_add_parameters.return_value[1],
config=config,
)
_add_body.assert_called_once_with(
endpoint=_add_responses.return_value[0],
data=data,
schemas=_add_responses.return_value[1],
config=config)
def test_add_body_no_data(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
parse_request_form_body = mocker.patch.object(Endpoint, "parse_request_form_body")
endpoint = self.make_endpoint()
schemas = Schemas()
Endpoint._add_body(endpoint=endpoint, data=oai.Operation.construct(), schemas=schemas, config=MagicMock())
parse_request_form_body.assert_not_called()
def test_from_data_no_operation_id(self, mocker):
from openapi_python_client.parser.openapi import Endpoint
path = "/path/with/{param}/"
method = "get"
_add_parameters = mocker.patch.object(
Endpoint,
"_add_parameters",
return_value=(mocker.MagicMock(), mocker.MagicMock()))
_add_responses = mocker.patch.object(Endpoint,
"_add_responses",
return_value=(mocker.MagicMock(),
mocker.MagicMock()))
_add_body = mocker.patch.object(Endpoint,
"_add_body",
return_value=(mocker.MagicMock(),
mocker.MagicMock()))
data = oai.Operation.construct(
description=mocker.MagicMock(),
operationId=None,
security={"blah": "bloo"},
responses=mocker.MagicMock(),
)
schemas = mocker.MagicMock()
mocker.patch("openapi_python_client.utils.remove_string_escapes",
return_value=data.description)
result = Endpoint.from_data(data=data,
path=path,
method=method,
tag="default",
schemas=schemas)
assert result == _add_body.return_value
_add_parameters.assert_called_once_with(
endpoint=Endpoint(
path=path,
method=method,
description=data.description,
name="get_path_with_param",
requires_security=True,
tag="default",
),
data=data,
schemas=schemas,
)
_add_responses.assert_called_once_with(
endpoint=_add_parameters.return_value[0],
data=data.responses,
schemas=_add_parameters.return_value[1])
_add_body.assert_called_once_with(
endpoint=_add_responses.return_value[0],
data=data,
schemas=_add_responses.return_value[1])
def test__add_responses_error(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
schemas = Schemas()
response_1_data = mocker.MagicMock()
response_2_data = mocker.MagicMock()
data = {
"200": response_1_data,
"404": response_2_data,
}
endpoint = Endpoint(
path="path",
method="method",
description=None,
name="name",
requires_security=False,
tag="tag",
relative_imports={"import_3"},
)
parse_error = ParseError(data=mocker.MagicMock())
response_from_data = mocker.patch(f"{MODULE_NAME}.response_from_data",
return_value=(parse_error, schemas))
response, schemas = Endpoint._add_responses(endpoint=endpoint,
data=data,
schemas=schemas)
response_from_data.assert_has_calls([
mocker.call(status_code=200,
data=response_1_data,
schemas=schemas,
parent_name="name"),
mocker.call(status_code=404,
data=response_2_data,
schemas=schemas,
parent_name="name"),
])
assert response.errors == [
ParseError(
detail=
f"Cannot parse response for status code 200, response will be ommitted from generated client",
data=parse_error.data,
),
ParseError(
detail=
f"Cannot parse response for status code 404, response will be ommitted from generated client",
data=parse_error.data,
),
]
def test_parse_multipart_body_existing_schema(self, mocker, model_property_factory):
from openapi_python_client.parser.openapi import Endpoint, Schemas
from openapi_python_client.parser.properties import Class
class_info = Class(name="class_name", module_name="module_name")
prop_before = model_property_factory(class_info=class_info, is_multipart_body=False)
schemas_before = Schemas(classes_by_name={class_info.name: prop_before})
schema = mocker.MagicMock()
body = oai.RequestBody.construct(
content={"multipart/form-data": oai.MediaType.construct(media_type_schema=schema)}
)
config = MagicMock()
property_from_data = mocker.patch(
f"{MODULE_NAME}.property_from_data", return_value=(prop_before, schemas_before)
)
result = Endpoint.parse_multipart_body(body=body, schemas=schemas_before, parent_name="parent", config=config)
property_from_data.assert_called_once_with(
name="multipart_data",
required=True,
data=schema,
schemas=schemas_before,
parent_name="parent",
config=config,
)
prop_after = model_property_factory(class_info=class_info, is_multipart_body=True)
schemas_after = Schemas(classes_by_name={class_info.name: prop_after})
assert result == (prop_after, schemas_after)
def test__add_responses_error(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
schemas = Schemas()
response_1_data = mocker.MagicMock()
response_2_data = mocker.MagicMock()
data = {
"200": response_1_data,
"404": response_2_data,
}
endpoint = self.make_endpoint()
parse_error = ParseError(data=mocker.MagicMock())
response_from_data = mocker.patch(f"{MODULE_NAME}.response_from_data", return_value=(parse_error, schemas))
config = MagicMock()
response, schemas = Endpoint._add_responses(endpoint=endpoint, data=data, schemas=schemas, config=config)
response_from_data.assert_has_calls(
[
mocker.call(status_code=200, data=response_1_data, schemas=schemas, parent_name="name", config=config),
mocker.call(status_code=404, data=response_2_data, schemas=schemas, parent_name="name", config=config),
]
)
assert response.errors == [
ParseError(
detail=f"Cannot parse response for status code 200, response will be ommitted from generated client",
data=parse_error.data,
),
ParseError(
detail=f"Cannot parse response for status code 404, response will be ommitted from generated client",
data=parse_error.data,
),
]
def test_add_body_bad_data(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
mocker.patch.object(Endpoint, "parse_request_form_body")
parse_error = ParseError(data=mocker.MagicMock())
other_schemas = mocker.MagicMock()
mocker.patch.object(Endpoint,
"parse_request_json_body",
return_value=(parse_error, other_schemas))
endpoint = self.make_endpoint()
request_body = mocker.MagicMock()
schemas = Schemas()
result = Endpoint._add_body(
endpoint=endpoint,
data=oai.Operation.construct(requestBody=request_body),
schemas=schemas,
config=MagicMock(),
)
assert result == (
ParseError(detail=f"cannot parse body of endpoint {endpoint.name}",
data=parse_error.data),
other_schemas,
)
def test__add_responses_status_code_error(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
schemas = Schemas()
response_1_data = mocker.MagicMock()
data = {
"not_a_number": response_1_data,
}
endpoint = self.make_endpoint()
parse_error = ParseError(data=mocker.MagicMock())
response_from_data = mocker.patch(f"{MODULE_NAME}.response_from_data",
return_value=(parse_error, schemas))
config = MagicMock()
response, schemas = Endpoint._add_responses(endpoint=endpoint,
data=data,
schemas=schemas,
config=config)
assert response.errors == [
ParseError(
detail=
f"Invalid response status code not_a_number (not a number), response will be ommitted from generated client"
)
]
response_from_data.assert_not_called()
def test__add_parameters_parse_error(self, mocker):
from openapi_python_client.parser.openapi import Endpoint
endpoint = self.make_endpoint()
initial_schemas = mocker.MagicMock()
parse_error = ParseError(data=mocker.MagicMock())
property_schemas = mocker.MagicMock()
mocker.patch(f"{MODULE_NAME}.property_from_data",
return_value=(parse_error, property_schemas))
param = oai.Parameter.construct(name="test",
required=True,
param_schema=mocker.MagicMock(),
param_in="cookie")
config = MagicMock()
result = Endpoint._add_parameters(
endpoint=endpoint,
data=oai.Operation.construct(parameters=[param]),
schemas=initial_schemas,
config=config)
assert result == (
ParseError(
data=parse_error.data,
detail=f"cannot parse parameter of endpoint {endpoint.name}"),
property_schemas,
)
def test_from_data_bad_responses(self, mocker):
from openapi_python_client.parser.openapi import Endpoint
path = mocker.MagicMock()
method = mocker.MagicMock()
parse_error = ParseError(data=mocker.MagicMock())
param_schemas = mocker.MagicMock()
_add_parameters = mocker.patch.object(Endpoint,
"_add_parameters",
return_value=(mocker.MagicMock(),
param_schemas))
response_schemas = mocker.MagicMock()
_add_responses = mocker.patch.object(Endpoint,
"_add_responses",
return_value=(parse_error,
response_schemas))
data = oai.Operation.construct(
description=mocker.MagicMock(),
operationId=mocker.MagicMock(),
security={"blah": "bloo"},
responses=mocker.MagicMock(),
)
initial_schemas = mocker.MagicMock()
result = Endpoint.from_data(data=data,
path=path,
method=method,
tag="default",
schemas=initial_schemas)
assert result == (parse_error, response_schemas)
def test_parse_multipart_body_no_data(self):
body = oai.RequestBody.construct(content={})
from openapi_python_client.parser.openapi import Endpoint
result = Endpoint.parse_multipart_body(body=body, config=MagicMock())
assert result is None
def test_parse_request_form_body_no_data(self):
body = oai.RequestBody.construct(content={})
from openapi_python_client.parser.openapi import Endpoint
result = Endpoint.parse_request_form_body(body)
assert result is None
def test_add_body_happy(self, mocker):
from openapi_python_client.parser.openapi import Class, Endpoint
from openapi_python_client.parser.properties import Property
request_body = mocker.MagicMock()
config = mocker.MagicMock()
form_body_class = Class(name="A", module_name="a")
multipart_body_class = Class(name="B", module_name="b")
parse_request_form_body = mocker.patch.object(
Endpoint, "parse_request_form_body", return_value=form_body_class)
parse_multipart_body = mocker.patch.object(
Endpoint,
"parse_multipart_body",
return_value=multipart_body_class)
json_body = mocker.MagicMock(autospec=Property)
json_body_imports = mocker.MagicMock()
json_body.get_imports.return_value = {json_body_imports}
parsed_schemas = mocker.MagicMock()
parse_request_json_body = mocker.patch.object(
Endpoint,
"parse_request_json_body",
return_value=(json_body, parsed_schemas))
import_string_from_class = mocker.patch(
f"{MODULE_NAME}.import_string_from_class",
side_effect=["import_1", "import_2"])
endpoint = self.make_endpoint()
initial_schemas = mocker.MagicMock()
(endpoint, response_schemas) = Endpoint._add_body(
endpoint=endpoint,
data=oai.Operation.construct(requestBody=request_body),
schemas=initial_schemas,
config=config,
)
assert response_schemas == parsed_schemas
parse_request_form_body.assert_called_once_with(body=request_body,
config=config)
parse_request_json_body.assert_called_once_with(
body=request_body,
schemas=initial_schemas,
parent_name="name",
config=config)
parse_multipart_body.assert_called_once_with(body=request_body,
config=config)
import_string_from_class.assert_has_calls([
mocker.call(form_body_class, prefix="...models"),
mocker.call(multipart_body_class, prefix="...models"),
])
json_body.get_imports.assert_called_once_with(prefix="...")
assert endpoint.relative_imports == {
"import_1", "import_2", "import_3", json_body_imports
}
assert endpoint.json_body == json_body
assert endpoint.form_body_class == form_body_class
assert endpoint.multipart_body_class == multipart_body_class
def test_parse_request_json_body_no_data(self):
from openapi_python_client.parser.openapi import Endpoint, Schemas
body = oai.RequestBody.construct(content={})
schemas = Schemas()
result = Endpoint.parse_request_json_body(body=body, schemas=schemas, parent_name="parent", config=MagicMock())
assert result == (None, schemas)
def test__add_parameters_handles_no_params(self):
from openapi_python_client.parser.openapi import Endpoint, Schemas
endpoint = Endpoint(
path="path",
method="method",
description=None,
name="name",
requires_security=False,
tag="tag",
)
schemas = Schemas()
# Just checking there's no exception here
assert Endpoint._add_parameters(endpoint=endpoint,
data=oai.Operation.construct(),
schemas=schemas) == (
endpoint,
schemas,
)
def test_parse_multipart_body_no_data(self):
from openapi_python_client.parser.openapi import Endpoint, Schemas
body = oai.RequestBody.construct(content={})
schemas = Schemas()
prop, schemas = Endpoint.parse_multipart_body(
body=body, schemas=schemas, parent_name="parent", config=MagicMock()
)
assert prop is None
def make_endpoint(self):
from openapi_python_client.parser.openapi import Endpoint
return Endpoint(
path="path",
method="method",
description=None,
name="name",
requires_security=False,
tag="tag",
relative_imports={"import_3"},
)
def test_add_body_no_data(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
parse_request_form_body = mocker.patch.object(
Endpoint, "parse_request_form_body")
endpoint = Endpoint(
path="path",
method="method",
description=None,
name="name",
requires_security=False,
tag="tag",
relative_imports={"import_3"},
)
schemas = Schemas()
Endpoint._add_body(endpoint=endpoint,
data=oai.Operation.construct(),
schemas=schemas)
parse_request_form_body.assert_not_called()
def test_parse_multipart_body(self, mocker):
ref = mocker.MagicMock()
body = oai.RequestBody.construct(
content={"multipart/form-data": oai.MediaType.construct(media_type_schema=oai.Reference.construct(ref=ref))}
)
from_string = mocker.patch(f"{MODULE_NAME}.Class.from_string")
config = MagicMock()
from openapi_python_client.parser.openapi import Endpoint
result = Endpoint.parse_multipart_body(body=body, config=config)
from_string.assert_called_once_with(string=ref, config=config)
assert result == from_string.return_value
def test__add_parameters_handles_no_params(self):
from openapi_python_client.parser.openapi import Endpoint, Schemas
endpoint = self.make_endpoint()
schemas = Schemas()
config = MagicMock()
# Just checking there's no exception here
assert Endpoint._add_parameters(
endpoint=endpoint, data=oai.Operation.construct(), schemas=schemas, config=config
) == (
endpoint,
schemas,
)
def test__add_responses(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Response
from openapi_python_client.parser.properties import DateProperty, DateTimeProperty
response_1_data = mocker.MagicMock()
response_2_data = mocker.MagicMock()
data = {
"200": response_1_data,
"404": response_2_data,
}
endpoint = self.make_endpoint()
schemas = mocker.MagicMock()
schemas_1 = mocker.MagicMock()
schemas_2 = mocker.MagicMock()
response_1 = Response(
status_code=200,
source="source",
prop=DateTimeProperty(name="datetime", required=True, nullable=False, default=None),
)
response_2 = Response(
status_code=404,
source="source",
prop=DateProperty(name="date", required=True, nullable=False, default=None),
)
response_from_data = mocker.patch(
f"{MODULE_NAME}.response_from_data", side_effect=[(response_1, schemas_1), (response_2, schemas_2)]
)
config = MagicMock()
endpoint, response_schemas = Endpoint._add_responses(
endpoint=endpoint, data=data, schemas=schemas, config=config
)
response_from_data.assert_has_calls(
[
mocker.call(status_code=200, data=response_1_data, schemas=schemas, parent_name="name", config=config),
mocker.call(
status_code=404, data=response_2_data, schemas=schemas_1, parent_name="name", config=config
),
]
)
assert endpoint.responses == [response_1, response_2]
assert endpoint.relative_imports == {
"from dateutil.parser import isoparse",
"from typing import cast",
"import datetime",
"import_3",
}
assert response_schemas == schemas_2
def test_parse_multipart_body(self, mocker):
ref = mocker.MagicMock()
body = oai.RequestBody.construct(
content={
"multipart/form-data":
oai.MediaType.construct(
media_type_schema=oai.Reference.construct(ref=ref))
})
from_ref = mocker.patch(f"{MODULE_NAME}.Reference.from_ref")
from openapi_python_client.parser.openapi import Endpoint
result = Endpoint.parse_multipart_body(body)
from_ref.assert_called_once_with(ref)
assert result == from_ref()
def test__add_parameters_fail_loudly_when_location_not_supported(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
endpoint = self.make_endpoint()
parsed_schemas = mocker.MagicMock()
mocker.patch(f"{MODULE_NAME}.property_from_data", return_value=(mocker.MagicMock(), parsed_schemas))
param = oai.Parameter.construct(
name="test", required=True, param_schema=mocker.MagicMock(), param_in="error_location"
)
schemas = Schemas()
config = MagicMock()
result = Endpoint._add_parameters(
endpoint=endpoint, data=oai.Operation.construct(parameters=[param]), schemas=schemas, config=config
)
assert result == (ParseError(data=param, detail="Parameter must be declared in path or query"), parsed_schemas)
def test__add_parameters_duplicate_properties(self, mocker):
from openapi_python_client.parser.openapi import Endpoint, Schemas
endpoint = self.make_endpoint()
param = oai.Parameter.construct(
name="test", required=True, param_schema=oai.Schema.construct(type="string"), param_in="path"
)
data = oai.Operation.construct(parameters=[param, param])
schemas = Schemas()
config = MagicMock()
result = Endpoint._add_parameters(endpoint=endpoint, data=data, schemas=schemas, config=config)
assert result == (
ParseError(data=data, detail="Could not reconcile duplicate parameters named test_path"),
schemas,
)
