def test_parse_failed_unknown_error(
core_manager,
rules_manager_endpoint,
server_rule_factory,
server_rule_prototype,
application_client,
):
"""Check that error is returned if RuleError is raised on attempt to parse data.
1. Register rule type with parser that raises RuleError.
2. Make a POST request to create a rule.
3. Check that response contains an error.
4. Check the error.
5. Check that rule has not been created.
"""
def _parser(*args, **kwargs):
raise RuleError()
serializer = lambda rule_type, rule: rule_type
server_rule_factory.register_rule(rule_type="RuleError",
parser=_parser,
serializer=serializer)
rule = server_rule_prototype.create_new(rule_type="RuleError")
serialized_rule = server_rule_factory.serialize_rule(rule=rule)
http_response = application_client.post(rules_manager_endpoint,
json=serialized_rule)
assert http_response.status_code == 500, "Wrong status code"
expected_error = APIError("Exception has been raised during rule creation")
assert http_response.json == build_response(
error=expected_error), "Wrong response"
assert not core_manager.get_rules_order(), "Rule has been created"
def test_request_data_error(
core_manager,
response_endpoint,
server_rule_prototype,
application_client,
data,
):
"""Check that error is returned if a request does not contain JSON data.
1. Create a rule.
2. Make a POST request to set response without JSON data.
3. Check that response contains an error.
4. Check the error.
5. Check that response has not been set.
"""
rule_id = core_manager.add_rule(server_rule_prototype)
http_response = application_client.post(
response_endpoint.format(rule_id=rule_id),
data=data,
)
assert http_response.status_code == 400, "Wrong status code"
expected_error = APIError("Failed to parse JSON data from the request")
assert http_response.json == build_response(
error=expected_error), "Wrong response"
with pytest.raises(KeyError):
core_manager.get_response(rule_id=rule_id)
def test_parse_failed_parse_error(
core_manager,
rules_manager_endpoint,
server_rule_factory,
application_client,
):
"""Check that error is returned if RuleParseError is raised on attempt to parse data.
1. Make a POST request without rule type in the data.
2. Check that response contains an error.
3. Check the error.
4. Check that rule has not been created.
"""
rule_data = {}
http_response = application_client.post(rules_manager_endpoint,
json=rule_data)
assert http_response.status_code == 400, "Wrong status code"
parent_error = None
try:
server_rule_factory.parse_rule(data=rule_data)
except RuleParseError as error:
parent_error = error
message = "Failed to create a rule for specified parameters. Error: '{0}'".format(
parent_error)
assert http_response.json == build_response(
error=APIError(message)), "Wrong response"
assert not core_manager.get_rules_order(), "Rule has been created"
def test_serialization_failed_unknown_error(
core_manager,
rules_manager_endpoint,
server_rule_factory,
server_rule_prototype,
application_client,
):
"""Check that error is returned if RuleError is raised on attempt to serialize a rule.
1. Register rule type with serializer that raises RuleError.
2. Make a POST request to create a rule.
3. Check that response contains an error.
4. Check the error.
5. Check that rule has not been created.
"""
parser = lambda rule_type, rule_data: server_rule_prototype
def _serializer(*args, **kwargs):
raise RuleError()
server_rule_factory.register_rule(rule_type="RuleError",
parser=parser,
serializer=_serializer)
rule_data = {"rule_type": "RuleError", "parameters": {}}
http_response = application_client.post(rules_manager_endpoint,
json=rule_data)
assert http_response.status_code == 500, "Wrong status code"
expected_error = APIError("Rule may be created, but can't be serialized")
assert http_response.json == build_response(
error=expected_error), "Wrong response"
assert not core_manager.get_rules_order(), "Rule has been created"
def test_set_response_non_existent_rule(
core_manager,
response_endpoint,
server_response_factory,
server_rule_prototype,
registered_response_prototype,
application_client,
):
# pylint: disable=too-many-arguments
"""Check that error is returned on attempt to set response for a non-existent rule.
1. Create a rule.
2. Make a POST request to set a response for a not-existent rule.
3. Check that response contains an error.
4. Check the error.
"""
core_manager.add_rule(server_rule_prototype)
serialized_response = server_response_factory.serialize_response(
registered_response_prototype)
http_response = application_client.post(
response_endpoint.format(rule_id="FakeID"),
json=serialized_response,
)
assert http_response.status_code == 400, "Wrong status code"
expected_error = APIError(
"Failed to create a response: Rule does not exist")
assert http_response.json == build_response(
error=expected_error), "Wrong response"
def post(self, rule_id):
"""Create a new response for the rule."""
logger = logging.getLogger(__name__)
request_data = request.get_json(silent=True)
if request_data is None:
message = "Failed to parse JSON data from the request"
logger.error(message)
return build_response(error=APIError(message)), 400
logger.debug("Try to create new response for the rule with ID %s",
rule_id)
try:
response = self._response_factory.parse_response(data=request_data)
except ResponseParseError as error:
message = "Failed to create a response for specified parameters. Error: '{0}'".format(
error, )
logger.exception(message)
return build_response(error=APIError(message)), 400
except ResponseError as error:
message = "Exception has been raised during response creation"
logger.exception(message)
return build_response(error=APIError(message)), 500
try:
response_data = self._response_factory.serialize_response(response)
except ResponseError:
message = "Response can't be serialized"
return build_response(error=APIError(message)), 500
try:
self._manager.set_response(rule_id=rule_id, response=response)
except KeyError:
message = "Failed to create a response: Rule does not exist"
logger.exception(message)
return build_response(error=APIError(message)), 400
logger.debug(
"Response has been successfully created for the rule with ID %s",
rule_id)
logger.info(
"Successfully handled request to set a response for the rule with ID %s",
rule_id,
)
return build_response(data=response_data)
def test_api_error_description():
"""Check description attribute of the API error.
1. Create API error.
2. Check error description.
"""
error = APIError("description")
assert error.description == "description", "Wrong description"
def test_error_without_data():
"""Check status and fields of a failed response.
1. Build a response with error, but without data.
2. Check the status.
3. Check data fields.
"""
error = APIError("Test")
response = build_response(error=error, data=None)
assert response["status"] == ResponseStatus.FAILURE.name, "Wrong status"
assert response["error"][
"description"] == error.description, "Wrong error data"
assert "data" not in response, "Data have been set"
def get(self, rule_id):
"""Get rule by its ID."""
logger = logging.getLogger(__name__)
logger.debug("Try to get rule %s", rule_id)
try:
rule = self._manager.get_rule(rule_id=rule_id)
except KeyError:
message = "Failed to find rule with ID '{0}'".format(rule_id)
logger.error(message)
return build_response(error=APIError(message)), 404
try:
rule_data = self._rule_factory.serialize_rule(rule)
except RuleError:
message = "Exception has been raised during serialization of the rule"
logger.exception(message)
return build_response(error=APIError(message)), 500
logger.info("Rule %s has been successfully obtained", rule_id)
response_data = {"rule_id": rule_id}
response_data.update(rule_data)
return build_response(data=response_data)
def post(self):
"""Create a new rule."""
logger = logging.getLogger(__name__)
request_data = request.get_json(silent=True)
if request_data is None:
message = "Failed to parse JSON data from the request"
logger.error(message)
return build_response(error=APIError(message)), 400
logger.debug("Try to create new rule")
try:
rule = self._rule_factory.parse_rule(data=request_data)
except RuleParseError as error:
message = "Failed to create a rule for specified parameters. Error: '{0}'".format(
error)
logger.exception(message)
return build_response(error=APIError(message)), 400
except RuleError as error:
message = "Exception has been raised during rule creation"
logger.exception(message)
return build_response(error=APIError(message)), 500
rule_id = self._manager.add_rule(rule)
logger.debug("Rule has been successfully created")
try:
rule_data = self._rule_factory.serialize_rule(rule)
except RuleError:
self._manager.remove_rule(rule_id=rule_id)
logger.debug(
"Rule has been removed because of a serialization error")
message = "Rule may be created, but can't be serialized"
return build_response(error=APIError(message)), 500
logger.info("Successfully handled request to create a rule")
response_data = {"rule_id": rule_id}
response_data.update(rule_data)
return build_response(data=response_data)
def test_error_with_data():
"""Check status and fields of a failed response.
1. Build a response without error.
2. Check the status.
3. Check data fields.
"""
data = {}
error = APIError("Test")
response = build_response(error=error, data=data)
assert response["status"] == ResponseStatus.FAILURE.name, "Wrong status"
assert response["error"][
"description"] == error.description, "Wrong error data"
assert response.get("data") == data, "Data have not been set"
def get(self, rule_id):
"""Get response by rule ID."""
logger = logging.getLogger(__name__)
logger.debug("Try to get the response for the rule with ID '%s'",
rule_id)
try:
response = self._manager.get_response(rule_id=rule_id)
except KeyError:
message = "Failed to get response for the rule '{0}'".format(
rule_id)
logger.exception(message)
return build_response(error=APIError(message)), 404
try:
response_data = self._response_factory.serialize_response(response)
except ResponseError:
message = "Response can't be serialized"
logger.exception(message)
return build_response(error=APIError(message)), 500
logger.info(
"Response for the rule with ID %s has been successfully obtained",
rule_id)
return build_response(data=response_data)
def test_parse_failed_unknown_error(
core_manager,
response_endpoint,
server_response_factory,
server_rule_prototype,
server_response_prototype,
application_client,
):
# pylint: disable=too-many-arguments
"""Check that error is returned if ResponseError is raised on attempt to parse data.
1. Create a rule.
2. Register response type with parser that raises ResponseError.
3. Make a POST request to set a response.
4. Check that response contains an error.
5. Check the error.
6. Check that response has not been set.
"""
rule_id = core_manager.add_rule(server_rule_prototype)
def _parser(*args, **kwargs):
raise ResponseError()
serializer = lambda response_type, response: response_type
response = server_response_prototype.create_new(response_type="RuleError")
server_response_factory.register_response(
response_type=response.response_type,
parser=_parser,
serializer=serializer,
)
serialized_response = server_response_factory.serialize_response(
response=response)
http_response = application_client.post(
response_endpoint.format(rule_id=rule_id),
json=serialized_response,
)
assert http_response.status_code == 500, "Wrong status code"
expected_error = APIError(
"Exception has been raised during response creation")
assert http_response.json == build_response(
error=expected_error), "Wrong response"
with pytest.raises(KeyError):
core_manager.get_response(rule_id=rule_id)
def test_set_response_serialization_failed(
core_manager,
response_endpoint,
server_response_factory,
server_rule_prototype,
server_response_prototype,
application_client,
):
# pylint: disable=too-many-arguments
"""Check that error is returned if ResponseError is raised on attempt to serialize a rule.
1. Create a rule.
2. Register response type with serializer that raises ResponseError.
3. Make a POST request to set a response.
4. Check that response contains an error.
5. Check the error.
6. Check that response has not been set.
"""
rule_id = core_manager.add_rule(server_rule_prototype)
parser = lambda response_type, response_data: server_response_prototype
def _serializer(*args, **kwargs):
raise ResponseError()
server_response_factory.register_response(
response_type="ResponseError",
parser=parser,
serializer=_serializer,
)
response_data = {"response_type": "ResponseError", "parameters": {}}
http_response = application_client.post(
response_endpoint.format(rule_id=rule_id),
json=response_data,
)
assert http_response.status_code == 500, "Wrong status code"
expected_error = APIError("Response can't be serialized")
assert http_response.json == build_response(
error=expected_error), "Wrong response"
with pytest.raises(KeyError):
core_manager.get_response(rule_id=rule_id)
def test_request_data_error(core_manager, rules_manager_endpoint,
application_client, data):
"""Check that error is returned if a request does not contain JSON data.
1. Make a POST request without JSON data.
2. Check that response contains an error.
3. Check the error.
4. Check that rule has not been created.
"""
http_response = application_client.post(rules_manager_endpoint, data=data)
assert http_response.status_code == 400, "Wrong status code"
expected_error = APIError("Failed to parse JSON data from the request")
assert http_response.json == build_response(
error=expected_error), "Wrong response"
assert not core_manager.get_rules_order(), "Rule has been created"
def test_get_response_serialization_failed(
core_manager,
response_endpoint,
server_response_factory,
server_rule_prototype,
server_response_prototype,
application_client,
):
# pylint: disable=too-many-arguments
"""Check that error is returned if ResponseError is raised on attempt to serialize a rule.
1. Create a rule.
2. Register response type with serializer that raises ResponseError.
3. Set response for the rule.
4. Make a GET request to get a response.
5. Check that response contains an error.
6. Check the error.
"""
rule_id = core_manager.add_rule(server_rule_prototype)
response = server_response_prototype.create_new(
response_type="ResponseError")
core_manager.set_response(rule_id=rule_id, response=response)
parser = lambda response_type, response_data: server_response_prototype
def _serializer(*args, **kwargs):
raise ResponseError()
server_response_factory.register_response(
response_type=response.response_type,
parser=parser,
serializer=_serializer,
)
http_response = application_client.get(
response_endpoint.format(rule_id=rule_id))
assert http_response.status_code == 500, "Wrong status code"
expected_error = APIError("Response can't be serialized")
assert http_response.json == build_response(
error=expected_error), "Wrong response"
def _send_request(self, url, method="GET", json=None):
"""Make a request.
:param url: url to make a request.
:param method: request method.
:param json: json payload for the request.
:returns: parsed json response.
:raises: :class:`APIError <looseserver.common.api.APIError>` if response
contains error from API.
"""
absolute_url = self._build_url(relative_url=url)
response = self._application_client.open(absolute_url,
method=method,
json=json)
if response.status_code >= 400:
description = response.json["error"]["description"]
raise APIError(description)
return response.json.get("data")
def test_get_non_existent_rule(
core_manager,
rule_endpoint,
registered_rule_prototype,
application_client,
):
"""Check that error is returned if rule does not exist.
1. Create a rule.
2. Make a GET request to get a non-existent rule.
3. Check that response contains an error.
4. Check the error.
"""
core_manager.add_rule(rule=registered_rule_prototype)
http_response = application_client.get(
rule_endpoint.format(rule_id="FakeID"))
assert http_response.status_code == 404, "Wrong status code"
expected_error = APIError("Failed to find rule with ID 'FakeID'")
assert http_response.json == build_response(
error=expected_error), "Wrong response"
def test_parse_failed_parse_error(
core_manager,
response_endpoint,
server_response_factory,
server_rule_prototype,
application_client,
):
"""Check that error is returned if ResponseParseError is raised on attempt to parse data.
1. Create a rule.
2. Make a POST request to set resonse without response type in the data.
3. Check that response contains an error.
4. Check the error.
5. Check that response has not been set.
"""
rule_id = core_manager.add_rule(server_rule_prototype)
response_data = {}
http_response = application_client.post(
response_endpoint.format(rule_id=rule_id),
json=response_data,
)
assert http_response.status_code == 400, "Wrong status code"
parent_error = None
try:
server_response_factory.parse_response(data=response_data)
except ResponseParseError as error:
parent_error = error
message = "Failed to create a response for specified parameters. Error: '{0}'".format(
parent_error, )
assert http_response.json == build_response(
error=APIError(message)), "Wrong response"
with pytest.raises(KeyError):
core_manager.get_response(rule_id=rule_id)
def test_get_response_non_existent_rule(
core_manager,
response_endpoint,
server_rule_prototype,
application_client,
):
"""Check that error is returned on attempt to get response for a non-existent rule.
1. Create a rule.
2. Make a GET request to get a response for a not-existent rule.
3. Check that response contains an error.
4. Check the error.
"""
core_manager.add_rule(server_rule_prototype)
http_response = application_client.get(
response_endpoint.format(rule_id="FakeID"))
assert http_response.status_code == 404, "Wrong status code"
message = "Failed to get response for the rule 'FakeID'"
assert http_response.json == build_response(
error=APIError(message)), "Wrong response"
def test_serialization_failed_unknown_error(
core_manager,
rule_endpoint,
server_rule_factory,
server_rule_prototype,
application_client,
):
"""Check that error is returned if RuleError is raised on attempt to serialize a rule.
1. Register rule type with serializer that raises RuleError.
2. Create a rule.
3. Make a GET request to the rule.
4. Check that response contains an error.
5. Check the error.
"""
parser = lambda rule_type, rule_data: server_rule_prototype
def _serializer(*args, **kwargs):
raise RuleError()
rule = server_rule_prototype.create_new(rule_type="RuleError")
server_rule_factory.register_rule(
rule_type=rule.rule_type,
parser=parser,
serializer=_serializer,
)
rule_id = core_manager.add_rule(rule=rule)
http_response = application_client.get(
rule_endpoint.format(rule_id=rule_id))
assert http_response.status_code == 500, "Wrong status code"
message = "Exception has been raised during serialization of the rule"
assert http_response.json == build_response(
error=APIError(message)), "Wrong response"
