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, )