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__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__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_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_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,
)
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_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__add_parameters_duplicate_properties_different_location(self):
from openapi_python_client.parser.openapi import Endpoint, Schemas
endpoint = self.make_endpoint()
path_param = oai.Parameter.construct(
name="test", required=True, param_schema=oai.Schema.construct(type="string"), param_in="path"
)
query_param = oai.Parameter.construct(
name="test", required=True, param_schema=oai.Schema.construct(type="string"), param_in="query"
)
schemas = Schemas()
config = MagicMock()
result = Endpoint._add_parameters(
endpoint=endpoint,
data=oai.Operation.construct(parameters=[path_param, query_param]),
schemas=schemas,
config=config,
)[0]
assert isinstance(result, Endpoint)
assert result.path_parameters[0].python_name == "test_path"
assert result.path_parameters[0].name == "test"
assert result.query_parameters[0].python_name == "test_query"
assert result.query_parameters[0].name == "test"
def test__add_parameters_happy(self, mocker):
from openapi_python_client.parser.openapi import Endpoint
from openapi_python_client.parser.properties import Property
endpoint = Endpoint(
path="path",
method="method",
description=None,
name="name",
requires_security=False,
tag="tag",
relative_imports={"import_3"},
)
path_prop = mocker.MagicMock(autospec=Property)
path_prop_import = mocker.MagicMock()
path_prop.get_imports = mocker.MagicMock(
return_value={path_prop_import})
query_prop = mocker.MagicMock(autospec=Property)
query_prop_import = mocker.MagicMock()
query_prop.get_imports = mocker.MagicMock(
return_value={query_prop_import})
header_prop = mocker.MagicMock(autospec=Property)
header_prop_import = mocker.MagicMock()
header_prop.get_imports = mocker.MagicMock(
return_value={header_prop_import})
schemas_1 = mocker.MagicMock()
schemas_2 = mocker.MagicMock()
schemas_3 = mocker.MagicMock()
property_from_data = mocker.patch(
f"{MODULE_NAME}.property_from_data",
side_effect=[(path_prop, schemas_1), (query_prop, schemas_2),
(header_prop, schemas_3)],
)
path_schema = mocker.MagicMock()
query_schema = mocker.MagicMock()
header_schema = mocker.MagicMock()
data = oai.Operation.construct(parameters=[
oai.Parameter.construct(name="path_prop_name",
required=True,
param_schema=path_schema,
param_in="path"),
oai.Parameter.construct(name="query_prop_name",
required=False,
param_schema=query_schema,
param_in="query"),
oai.Parameter.construct(name="header_prop_name",
required=False,
param_schema=header_schema,
param_in="header"),
oai.Reference.construct(), # Should be ignored
oai.Parameter.construct(), # Should be ignored
])
initial_schemas = mocker.MagicMock()
(endpoint, schemas) = Endpoint._add_parameters(endpoint=endpoint,
data=data,
schemas=initial_schemas)
property_from_data.assert_has_calls([
mocker.call(name="path_prop_name",
required=True,
data=path_schema,
schemas=initial_schemas,
parent_name="name"),
mocker.call(name="query_prop_name",
required=False,
data=query_schema,
schemas=schemas_1,
parent_name="name"),
mocker.call(name="header_prop_name",
required=False,
data=header_schema,
schemas=schemas_2,
parent_name="name"),
])
path_prop.get_imports.assert_called_once_with(prefix="...")
query_prop.get_imports.assert_called_once_with(prefix="...")
header_prop.get_imports.assert_called_once_with(prefix="...")
assert endpoint.relative_imports == {
"import_3", path_prop_import, query_prop_import, header_prop_import
}
assert endpoint.path_parameters == [path_prop]
assert endpoint.query_parameters == [query_prop]
assert endpoint.header_parameters == [header_prop]
assert schemas == schemas_3
