def test_array_of_enums(self):
"""Test case for array_of_enums
Array of Enums # noqa: E501
"""
from petstore_api.model import array_of_enums, string_enum
endpoint = self.api.array_of_enums
assert endpoint.openapi_types['array_of_enums'] == (
array_of_enums.ArrayOfEnums, )
assert endpoint.settings['response_type'] == (
array_of_enums.ArrayOfEnums, )
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_method:
value = [string_enum.StringEnum("placed")]
body = array_of_enums.ArrayOfEnums(value)
value_simple = ["placed"]
mock_method.return_value = self.mock_response(value_simple)
response = endpoint(array_of_enums=body)
self.assert_request_called_with(
mock_method,
'http://petstore.swagger.io:80/v2/fake/refs/array-of-enums',
body=value_simple)
assert isinstance(response, array_of_enums.ArrayOfEnums)
assert response.value == value
def test_enum_test(self):
""" deserialize dict(str, Enum_Test) """
data = {
'enum_test': {
"enum_string": "UPPER",
"enum_string_required": "lower",
"enum_integer": 1,
"enum_number": 1.1,
"stringEnum": "placed"
}
}
response = MockResponse(data=json.dumps(data))
deserialized = self.deserialize(response, ({
str: (enum_test.EnumTest, )
}, ), True)
self.assertTrue(isinstance(deserialized, dict))
self.assertTrue(
isinstance(deserialized['enum_test'], enum_test.EnumTest))
value = (string_enum.StringEnum.allowed_values[('value', )]["PLACED"])
string_enum_val = string_enum.StringEnum(value)
sample_instance = enum_test.EnumTest(enum_string="UPPER",
enum_string_required="lower",
enum_integer=1,
enum_number=1.1,
string_enum=string_enum_val)
self.assertEqual(deserialized['enum_test'], sample_instance)
def test_string_enum(self):
"""Test case for string_enum
"""
from petstore_api.model import string_enum
endpoint = self.api.string_enum_endpoint
assert endpoint.openapi_types['body'] == (string_enum.StringEnum, )
assert endpoint.settings['response_type'] == (string_enum.StringEnum, )
# serialization + deserialization works
from petstore_api.rest import RESTClientObject, RESTResponse
with patch.object(RESTClientObject, 'request') as mock_method:
value = "placed"
body = string_enum.StringEnum(value)
mock_method.return_value = self.mock_response(value)
response = self.api.string_enum(body=body)
self.assert_request_called_with(
mock_method,
'http://petstore.swagger.io:80/v2/fake/refs/enum',
body=value,
)
assert isinstance(response, string_enum.StringEnum)
assert response.value == value
def test_enum_test(self):
""" serialize dict(str, Enum_Test) """
value = (
string_enum.StringEnum.allowed_values[('value',)]["PLACED"])
string_enum_val = string_enum.StringEnum(value)
source = enum_test.EnumTest(
enum_string="UPPER",
enum_string_required="lower",
enum_integer=1,
enum_number=1.1,
string_enum=string_enum_val
)
result = {
'enum_test': {
"enum_string": "UPPER",
"enum_string_required": "lower",
"enum_integer": 1,
"enum_number": 1.1,
"stringEnum": "placed"
}
}
serialized = self.serialize({"enum_test": source})
self.assertEqual(result, serialized)
def test_array_of_enums(self):
data = ["placed", None]
response = MockResponse(data=json.dumps(data))
deserialized = self.api_client.deserialize(
response, (array_of_enums.ArrayOfEnums, ), True)
assert isinstance(deserialized, array_of_enums.ArrayOfEnums)
assert array_of_enums.ArrayOfEnums(
[string_enum.StringEnum(v) for v in data]) == deserialized
def test_array_of_enums(self):
from petstore_api.model.array_of_enums import ArrayOfEnums
from petstore_api.api.fake_api_endpoints.array_of_enums import _response_for_200
from petstore_api.model import string_enum
data = ["placed", None]
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
assert isinstance(deserialized.body, ArrayOfEnums)
expected_results = ArrayOfEnums(
[string_enum.StringEnum(v) for v in data])
assert expected_results == deserialized.body
def test_string_enum(self):
from petstore_api.model import string_enum
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
value = "placed"
body = string_enum.StringEnum(value)
mock_request.return_value = self.__response(
self.__json_bytes(value))
api_response = self.api.string_enum(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/enum',
body=self.__json_bytes(value))
assert isinstance(api_response.body, string_enum.StringEnum)
assert api_response.body == value
def test_array_of_enums(self):
from petstore_api.model import array_of_enums, string_enum
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
value = [string_enum.StringEnum("placed")]
body = array_of_enums.ArrayOfEnums(value)
value_simple = ["placed"]
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.array_of_enums(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/array-of-enums',
body=self.__json_bytes(value_simple))
assert isinstance(api_response.body, array_of_enums.ArrayOfEnums)
assert api_response.body == body
