def delete_flavor_test(app, flavor_id):
accept = XML_MIMETYPE
response = app.delete("/v1/flavors/{0}".format(flavor_id), headers={"accept": accept}, follow_redirects=True)
assert response.status_code == 204
response = app.delete("/v1/flavors/{0}".format(flavor_id), headers={"accept": accept}, follow_redirects=True)
assert response.status_code == 404
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_exception_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
accept = JSON_MIMETYPE
response = app.delete("/v1/flavors/{0}".format(flavor_id), headers={"accept": accept}, follow_redirects=True)
assert response.status_code == 404
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_exception_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
def unregister_infrastucture_test(app):
accept = XML_MIMETYPE
response = app.delete("/v1/infrastructures/Isengard", headers={"accept": accept}, follow_redirects=True)
assert response.status_code == 404
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_exception_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
accept = JSON_MIMETYPE
response = app.delete("/v1/infrastructures/Isengard", headers={"accept": accept}, follow_redirects=True)
assert response.status_code == 404
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_exception_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
response = app.delete("/v1/infrastructures/Mordor", headers={"accept": accept}, follow_redirects=True)
assert response.status_code == 204
def list_all_flavors_json_test(app, flavor_id=None):
accept = JSON_MIMETYPE
response = app.get("/v1/flavors", headers={"accept": accept}, follow_redirects=True)
assert response.status_code == 200
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_flavor_collection_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
if flavor_id:
exists = False
flavors = json.loads(response_body)
for flavor in flavors["flavors"]:
if flavor_id in flavor["id"]:
exists = True
isinstalled = "Mordor" in flavor["nodes"]
break
assert exists
assert isinstalled
def install_flavor_json_test(app):
content_type = JSON_MIMETYPE
accept = JSON_MIMETYPE
fake_flavor_id = _create_fake_infrastructure_and_flavor()
request_body = util.load_json_example_as_string("flavor_installation_request.json")
response = app.put(
"/v1/flavors/{0}".format(fake_flavor_id),
data=request_body,
content_type=content_type,
headers={"accept": accept},
follow_redirects=True,
)
assert response.status_code == 200
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_flavor_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
return fake_flavor_id
def validate_xml_flavor_publication_payload(self):
payload = util.load_xml_example_as_string("flavor_publication_request.xml")
payload = util.remove_xml_header(payload)
payload = util.remove_non_usable_characters(payload)
factory = factory_selector.get_factory(util.XML_MIMETYPE)
validator = factory.create_flavor_modification_request_validator()
_validate_payload(payload, validator, XMLSyntaxError)
def validate_xml_infrastructure_payload(self):
payload = util.load_xml_example_as_string("infrastructure_response.xml")
payload = util.remove_xml_header(payload)
payload = util.remove_non_usable_characters(payload)
factory = factory_selector.get_factory(util.XML_MIMETYPE)
validator = factory.create_infrastructure_validator()
_validate_payload(payload, validator, XMLSyntaxError)
def publish_flavor_json_test(app, flavor_id):
content_type = JSON_MIMETYPE
accept = JSON_MIMETYPE
request_body = util.load_json_example_as_string("flavor_publication_bad_request.json")
response = app.put(
"/v1/flavors/{0}".format(flavor_id),
data=request_body,
content_type=content_type,
headers={"accept": accept},
follow_redirects=True,
)
assert response.status_code == 400
request_body = util.load_json_example_as_string("flavor_publication_request.json")
response = app.put(
"/v1/flavors/idontexist".format(flavor_id),
data=request_body,
content_type=content_type,
headers={"accept": accept},
follow_redirects=True,
)
assert response.status_code == 404
response = app.put(
"/v1/flavors/{0}".format(flavor_id),
data=request_body,
content_type=content_type,
headers={"accept": accept},
follow_redirects=True,
)
assert response.status_code == 200
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_flavor_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
request_body = util.load_json_example_as_string("flavor_unpublication_request.json")
response = app.put(
"/v1/flavors/{0}".format(flavor_id),
data=request_body,
content_type=content_type,
headers={"accept": accept},
follow_redirects=True,
)
assert response.status_code == 409
def validate_empty_xml_flavor_collection_payload(self):
payload = '<?xml version="1.0" encoding="UTF-8"?>'
payload += "<flavors/>"
payload = util.remove_xml_header(payload)
payload = util.remove_non_usable_characters(payload)
factory = factory_selector.get_factory(util.XML_MIMETYPE)
validator = factory.create_flavor_collection_validator()
_validate_payload(payload, validator, XMLSyntaxError)
def register_infrastructure():
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_infrastructure_request_validator()
validator.validate(body)
infrastructure = Infrastructure.deserialize(content_type, body)
manager = FlavorSynchronizer()
manager.register_infrastructure(infrastructure)
response_body = infrastructure.serialize(request.accept_mimetypes)
return Response(response_body, status=201, mimetype=request.accept_mimetypes[0][0])
def create_flavor():
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_flavor_request_validator()
validator.validate(body)
flavor = Flavor.deserialize(content_type, body)
manager = FlavorSynchronizer()
created_flavor = manager.create_flavor(flavor)
response_body = created_flavor.serialize(request.accept_mimetypes)
return Response(response_body, status=201, mimetype=request.accept_mimetypes[0][0])
def register_new_infrastucture_json_test(app):
content_type = JSON_MIMETYPE
accept = JSON_MIMETYPE
request_body = util.load_json_example_as_string("infrastructure_bad_request.json")
response = app.post(
"/v1/infrastructures",
data=request_body,
content_type=content_type,
headers={"accept": accept},
follow_redirects=True,
)
assert response.status_code == 400
request_body = util.load_json_example_as_string("infrastructure_request.json")
response = app.post(
"/v1/infrastructures",
data=request_body,
content_type=content_type,
headers={"accept": accept},
follow_redirects=True,
)
assert response.status_code == 201
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_infrastructure_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
response = app.post(
"/v1/infrastructures",
data=request_body,
content_type=content_type,
headers={"accept": accept},
follow_redirects=True,
)
assert response.status_code == 409
def publish_or_promote_flavor(flavor_id):
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_flavor_modification_request_validator()
validator.validate(body)
modified_flavor = Flavor.deserialize(content_type, request.data)
manager = FlavorSynchronizer()
if not modified_flavor.nodes:
modified_flavor = manager.publish_or_promote_flavor(flavor_id, modified_flavor)
else:
modified_flavor = manager.add_node_to_flavor(flavor_id, modified_flavor)
response_body = modified_flavor.serialize(request.accept_mimetypes)
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def create_json_ivalidator_test():
factory = factory_selector.get_factory(util.JSON_MIMETYPE)
validator = factory.create_flavor_collection_validator()
assert type(validator) is JSONValidator
validator = factory.create_flavor_modification_request_validator()
assert type(validator) is JSONValidator
validator = factory.create_flavor_request_validator()
assert type(validator) is JSONValidator
validator = factory.create_flavor_validator()
assert type(validator) is JSONValidator
validator = factory.create_infrastructure_request_validator()
assert type(validator) is JSONValidator
validator = factory.create_infrastructure_validator()
assert type(validator) is JSONValidator
def list_all_flavors_xml_test(app, flavor_id=None):
accept = XML_MIMETYPE
response = app.get("/v1/flavors", headers={"accept": accept}, follow_redirects=True)
assert response.status_code == 200
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_flavor_collection_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
if flavor_id:
flavors = objectify.fromstring(response_body)
n_ocurrences = len(flavors.xpath("flavor[@id='{0}']".format(flavor_id)))
assert n_ocurrences == 1
assert flavors.xpath("flavor[@id='{0}']/node='Mordor'".format(flavor_id))
def create_wrong_mimetype_ivalidator_test():
factory = factory_selector.get_factory(util.WRONG_MIMETYPE)
try:
factory.create_flavor_collection_validator()
assert False
except UnsupportedMediaTypeError as e:
assert True
try:
factory.create_flavor_modification_request_validator()
assert False
except UnsupportedMediaTypeError as e:
assert True
try:
factory.create_flavor_request_validator()
assert False
except UnsupportedMediaTypeError as e:
assert True
try:
factory.create_flavor_validator()
assert False
except UnsupportedMediaTypeError as e:
assert True
try:
factory.create_infrastructure_request_validator()
assert False
except UnsupportedMediaTypeError as e:
assert True
try:
factory.create_infrastructure_validator()
assert False
except UnsupportedMediaTypeError as e:
assert True
def modify_promotedflavor(flavor_id):
#TODO To be decided how to update promoted flavors.
#Only the users with the appropiate roles could manage the promoted flavors.
authorization()
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_flavor_modification_request_validator()
validator.validate(body)
modified_flavor = Flavor.deserialize(content_type, request.data)
manager = FlavorSynchronizer()
if not modified_flavor.nodes:
modified_flavor = manager.publish_or_promote_flavor(flavor_id, modified_flavor)
else:
return Response("The method specified in the Request-Line is not allowed for the node list of infrastructures.", status=405)
response_body = modified_flavor.serialize(request.accept_mimetypes)
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def create_region_flavor(region_name):
if not manager.is_node_included(region_name):
return _create_not_found_region_response(region_name)
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_flavor_request_validator()
validator.validate(body)
flavor = Flavor.deserialize(content_type, body)
flavor.promoted = False
flavor.public = False
manager = FlavorSynchronizer()
created_flavor = manager.create_region_flavor(region_name, flavor)
response_body = created_flavor.serialize(request.accept_mimetypes)
return Response(response_body, status=201, mimetype=request.accept_mimetypes[0][0])
def create_new_flavor_xml_test(app):
content_type = XML_MIMETYPE
accept = XML_MIMETYPE
request_body = util.load_xml_example_as_string("flavor_creation_bad_request.xml")
response = app.post(
"/v1/flavors", data=request_body, content_type=content_type, headers={"accept": accept}, follow_redirects=True
)
assert response.status_code == 400
request_body = util.load_xml_example_as_string("flavor_creation_request.xml")
response = app.post(
"/v1/flavors", data=request_body, content_type=content_type, headers={"accept": accept}, follow_redirects=True
)
assert response.status_code == 201
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_flavor_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
response = app.post(
"/v1/flavors", data=request_body, content_type=content_type, headers={"accept": accept}, follow_redirects=True
)
assert response.status_code == 409
xml = objectify.fromstring(response_body)
return xml.values()[0]
def create_new_flavor_json_test(app):
content_type = JSON_MIMETYPE
accept = JSON_MIMETYPE
request_body = util.load_json_example_as_string("flavor_creation_bad_request.json")
response = app.post(
"/v1/flavors", data=request_body, content_type=content_type, headers={"accept": accept}, follow_redirects=True
)
assert response.status_code == 400
request_body = util.load_json_example_as_string("flavor_creation_request.json")
response = app.post(
"/v1/flavors", data=request_body, content_type=content_type, headers={"accept": accept}, follow_redirects=True
)
assert response.status_code == 201
response_body = response.data.decode("utf-8")
validator_factory = factory_selector.get_factory(accept)
validator = validator_factory.create_flavor_validator()
try:
validator.validate(response_body)
assert True
except ValidationError:
assert False
response = app.post(
"/v1/flavors", data=request_body, content_type=content_type, headers={"accept": accept}, follow_redirects=True
)
assert response.status_code == 409
flavor = json.loads(response_body)
return flavor["flavor"]["id"]
def create_promotedflavor():
#Only the users with the appropiate roles could manage the promoted flavors.
authorization()
#if the user has the correct roles, they can manage the promoted flavors
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_flavor_request_validator()
validator.validate(body)
flavor = Flavor.deserialize(content_type, body)
flavor.promoted = True
flavor.public = True
manager = FlavorSynchronizer()
created_flavor = manager.create_promoted_flavor(flavor)
print ("request.accept_mimetypes")
print (request.accept_mimetypes)
response_body = created_flavor.serialize(request.accept_mimetypes)
return Response(response_body, status=201, mimetype=request.accept_mimetypes[0][0])
def create_json_validator_factory_test():
factory = factory_selector.get_factory(util.JSON_MIMETYPE)
assert type(factory) is JSONValidatorFactory
def create_xml_validator_factory_test():
factory = factory_selector.get_factory(util.XML_MIMETYPE)
assert type(factory) is XMLValidatorFactory
def validate_json_infrastructure_payload(self):
payload = util.load_json_example_as_string("infrastructure_response.json")
factory = factory_selector.get_factory(util.JSON_MIMETYPE)
validator = factory.create_infrastructure_validator()
_validate_payload(payload, validator, ValidationError)
def validate_json_flavor_publication_payload(self):
payload = util.load_json_example_as_string("flavor_publication_request.json")
factory = factory_selector.get_factory(util.JSON_MIMETYPE)
validator = factory.create_flavor_modification_request_validator()
_validate_payload(payload, validator, ValidationError)
def create_wrong_mimetype_validator_factory_test():
factory = factory_selector.get_factory(util.WRONG_MIMETYPE)
assert type(factory) is ValidatorFactory
def validate_empty_json_flavor_collection_payload(self):
payload = '{"flavors":[]}'
factory = factory_selector.get_factory(util.JSON_MIMETYPE)
validator = factory.create_flavor_collection_validator()
_validate_payload(payload, validator, ValidationError)
def validate_json_flavor_collection_payload(self):
payload = util.load_json_example_as_string("flavor_collection_response.json")
factory = factory_selector.get_factory(util.JSON_MIMETYPE)
validator = factory.create_flavor_collection_validator()
_validate_payload(payload, validator, ValidationError)
