def coerce_value(value, value_schema):
value_type = get(value_schema, 'type')
if not value_type or value is None:
return value
try:
if value_type == 'integer' or (value_type == 'number'
and '.' not in value):
return int(value)
elif value_type == 'number' and '.' in value:
return float(value)
elif value_type == 'boolean':
return value not in ['0', 'false', 'FALSE', 'f']
elif value_type == 'string' and get(value_schema,
'format') == 'date-time':
return parse_date(value)
else:
return value
except:
return value
def parameters_schema(parameters, source):
properties = {
p['name']: p.get('schema')
for p in parameters
if p.get('schema') and not get(p, 'x-meta.namePattern')
}
if not properties:
return None
pattern_properties = {
get(p, 'x-meta.namePattern'): p.get('schema')
for p in parameters if get(p, 'x-meta.namePattern')
}
required = [p['name'] for p in parameters if p.get('required') == True]
additional_properties = True if source == 'header' else False
return {
'type': 'object',
'properties': properties,
'patternProperties': pattern_properties,
'required': required,
'additionalProperties': additional_properties
}
def parse_filter(json_schema, query):
pattern = re.compile(filter_param_pattern(json_schema))
result = {}
for k, v in query.items():
match = re.match(pattern, k)
if match:
(name, op) = match.groups()
value_schema = util.get(json_schema, f'properties.{name}')
result[name] = {
'value': coerce_value(v, value_schema),
'op': (op or 'eq')
}
return result
def list(request):
limit = int(util.get(request, 'query.limit', 100))
offset = int(util.get(request, 'query.offset', 0))
sort = util.get(request, 'query.sort') or '-updated_at'
if not is_valid_sort(json_schema, sort):
return invalid_response(
'Invalid sort parameter, must be on the format column1,column2,column3... For descending sort, use -column1'
)
filter = parse_filter(json_schema, request.get('query', {}))
count = db.count(table_name, filter)
docs = [
remove_none(doc)
for doc in db.find(table_name, limit, offset, sort, filter)
]
body = {
'count': count,
'limit': limit,
'offset': offset,
'sort': sort,
'filter': filter,
'data': docs
}
return {'body': body}
def is_writable(property):
return get(property, 'x-meta.writable') != False
def coerce_values(values, schema):
return {
k: coerce_value(v, get(schema, f'properties.{k}'))
for k, v in values.items()
}
def test_crud():
# Get swagger spec
response = requests.get(f'{BASE_URL}/v1/swagger.json')
assert response.status_code == 200
swagger = response.json()
assert validate_schema(swagger, swagger_meta_schema) == None
get_schema = get(
swagger,
'paths./v1/urls/{id}.get.responses.200.content.application/json.schema'
)
list_schema = get(
swagger,
'paths./v1/urls.get.responses.200.content.application/json.schema')
doc = get_valid_doc()
# Create with invalid schema
invalid_doc = {**doc, 'foo': 1}
response = requests.post(list_url, json=invalid_doc)
assert response.status_code == 400
assert get(response.json(), 'error.message')
# Successful create
response = requests.post(list_url, json=doc)
print(response.json())
assert response.status_code == 200
assert validate_schema(response.json(), get_schema) == None
assert response.json()['url'] == doc['url']
assert response.json()['id']
assert response.json()['created_at']
doc['id'] = response.json()['id']
get_url = f'{list_url}/{doc["id"]}'
# Verify create with get
response = requests.get(get_url)
assert response.status_code == 200
assert validate_schema(response.json(), get_schema) == None
assert response.json()['id'] == doc['id']
assert response.json()['url'] == doc['url']
# Get 404
missing_id = 12345 if DATABASE == 'pg' else '5f299b3e9cd7d821d2b898c1'
get_url_404 = f'{list_url}/{missing_id}'
response = requests.get(get_url_404)
assert response.status_code == 404
# Get invalid id
response = requests.get(f'{list_url}/fooobar')
assert response.status_code == 400
assert get(response.json(), 'error.message')
if DATABASE == 'pg':
# Create with url that already exists
response = requests.post(list_url, json={'url': doc['url']})
print(response.json())
assert response.status_code == 400
assert get(response.json(), 'error.message')
# List
response = requests.get(list_url)
assert response.status_code == 200
assert validate_schema(response.json(), list_schema) == None
list_doc = first(response.json()['data'], lambda d: d['id'] == doc['id'])
assert list_doc['url'] == doc['url']
new_url = f'https://www.facebook.com?uuid={uuid_hex()}'
# Update 404
response = requests.put(get_url_404, json={'url': new_url})
assert response.status_code == 404
# Update with invalid schema
response = requests.put(get_url, json={'url': 123})
assert response.status_code == 400
assert get(response.json(), 'error.message')
# Successful update
response = requests.put(get_url, json={'url': new_url})
assert response.status_code == 200
assert validate_schema(response.json(), get_schema) == None
# Verify update with get
response = requests.get(get_url)
assert response.status_code == 200
assert validate_schema(response.json(), get_schema) == None
assert response.json()['url'] == new_url
assert response.json()['updated_at']
# Delete 404
response = requests.delete(get_url_404)
assert response.status_code == 404
# Successful delete
response = requests.delete(get_url)
assert response.status_code == 200
assert validate_schema(response.json(), get_schema) == None
# Verify delete with get 404
response = requests.get(get_url)
assert response.status_code == 404
def test_get():
assert get(None, ['foo']) == None
assert get({'foo': 1}, None) == None
assert get(None, None) == None
assert get({'foo': 1}, []) == {'foo': 1}
assert get({'foo': 1}, ['foo']) == 1
assert get({'foo': 1}, ['bar']) == None
assert get({'foo': 1}, ['bar'], 'the default') == 'the default'
assert get({'foo': {'bar': 'hello'}}, ['foo', 'bar']) == 'hello'
assert get({'foo': {'bar': 'hello'}}, 'foo.bar') == 'hello'
assert get(DictLike(**{'foo': {'bar': 'hello'}}), 'foo.bar') == 'hello'
assert get(NotDictLike(**{'foo': {'bar': 'hello'}}), 'foo.bar') == None
assert get({'foo': [{'bar': 'hello'}]}, 'foo.0.bar') == 'hello'
assert get({'foo': [{'bar': 'hello'}]}, 'foo.1') == None
assert get({'foo': [{'bar': 'hello'}]}, 'foo.1.bar') == None
assert get(['foo', 'bar'], '1') == 'bar'
assert get(['foo', 'bar'], '2') == None
