def test_generate_schema_from_json():
# given
raw_json = json.dumps(
dict(
name="john doe",
age=51,
height=5.10,
addresses=[],
balance=dict(amount=1000, currency="GBP"),
))
# when
generated_schema = schema_from_json(raw_json).get("schema")
# then
assert generated_schema is not None
assert generated_schema.get("type") == "object"
object_properties = generated_schema.get("properties")
assert object_properties.get("name").get("type") == "string"
assert object_properties.get("age").get("type") == "integer"
assert object_properties.get("height").get("type") == "number"
assert object_properties.get("addresses").get("type") == "array"
assert object_properties.get("balance").get("type") == "object"
balance_properties = object_properties.get("balance").get("properties")
assert balance_properties.get("amount").get("type") == "integer"
assert balance_properties.get("currency").get("type") == "string"
assert "name" in generated_schema.get("required")
assert "age" in generated_schema.get("required")
assert "height" in generated_schema.get("required")
def test_generate_schema_with_no_required_fields():
# given
raw_json = json.dumps(
dict(
name="john doe",
age=51,
height=5.10,
addresses=[],
balance=dict(amount=1000, currency="GBP"),
))
# when
generated_schema = schema_from_json(raw_json,
remove_required=True).get("schema")
# then
assert generated_schema.get("required") is None
assert generated_schema.get("properties").get("balance").get(
"required") is None
def export_api_calls(self, api_spec, api_path, api_calls, servers):
http_relative_uri = self.url_from_last_exchange(api_calls, servers)
# http_relative_uri = extract_uri(api_path, servers)
operations = {}
for api in api_calls:
http_method = api.http_method.lower()
logging.debug(
f"Exporting API Path: {http_method} {api_path}: API calls: {len(api_calls)}"
)
operations[http_method] = operations.get(http_method) or {
"summary": api.title,
"tags": [],
}
if api.tags:
operations[http_method]["tags"].extend(api.tags)
last_exchange = self.app_config.app_data_cache.get_last_exchange(
api.id)
parameters = []
self.add_params(parameters, last_exchange.request.headers,
"header")
self.add_params(parameters, last_exchange.request.query_params,
"query")
if parameters:
operations[http_method]["parameters"] = parameters
# Request object
if last_exchange.request.request_body:
operations[http_method]["requestBody"] = operations[
http_method].get("requestBody", {})
operations[http_method]["requestBody"]["content"] = operations[
http_method]["requestBody"].get("content", {})
request_content_type = last_exchange.request.content_type()
operations[http_method]["requestBody"]["content"][
request_content_type] = schema_from_json(
last_exchange.request.request_body)
# Response object
response_code = last_exchange.response.http_status_code
if response_code:
operations[http_method]["responses"] = {
response_code: {
"description": "Map Status Code to Description Here"
}
}
if last_exchange.response.response_body:
generated_response_schema = schema_from_json(
last_exchange.response.response_body,
remove_required=True)
response_content_type = last_exchange.response.content_type(
)
operations[http_method]["responses"][response_code][
"content"] = {
response_content_type: generated_response_schema
}
# Build spec
api_spec.path(http_relative_uri, operations=operations)
def __generate_fuzzed_payload(self, request_json_body):
if not request_json_body:
return ""
request_schema = schema_from_json(request_json_body)
return json.dumps(jdg.json_from_schema(request_schema.get("schema")))