You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
259 lines
9.9 KiB
259 lines
9.9 KiB
from check_index import *
|
|
|
|
def check_reply(q):
|
|
assert is_dict(q)
|
|
assert sorted(q.keys()) == [
|
|
"client-client-member",
|
|
"client-empty-array",
|
|
"client-empty-object",
|
|
"client-json-bad-root",
|
|
"client-json-empty",
|
|
"client-json-extra",
|
|
"client-not-file",
|
|
"client-request-array-negative-major-version",
|
|
"client-request-array-negative-minor-version",
|
|
"client-request-array-negative-version",
|
|
"client-request-array-no-major-version",
|
|
"client-request-array-no-supported-version",
|
|
"client-request-array-no-supported-version-among",
|
|
"client-request-array-version-1",
|
|
"client-request-array-version-1-1",
|
|
"client-request-array-version-2",
|
|
"client-request-negative-major-version",
|
|
"client-request-negative-minor-version",
|
|
"client-request-negative-version",
|
|
"client-request-no-major-version",
|
|
"client-request-no-version",
|
|
"client-request-version-1",
|
|
"client-request-version-1-1",
|
|
"client-request-version-2",
|
|
"client-requests-bad",
|
|
"client-requests-empty",
|
|
"client-requests-not-kinded",
|
|
"client-requests-not-objects",
|
|
"client-requests-unknown",
|
|
]
|
|
expected = [
|
|
(check_query_client_member, "client-client-member"),
|
|
(check_query_empty_array, "client-empty-array"),
|
|
(check_query_empty_object, "client-empty-object"),
|
|
(check_query_json_bad_root, "client-json-bad-root"),
|
|
(check_query_json_empty, "client-json-empty"),
|
|
(check_query_json_extra, "client-json-extra"),
|
|
(check_query_not_file, "client-not-file"),
|
|
(check_query_requests_bad, "client-requests-bad"),
|
|
(check_query_requests_empty, "client-requests-empty"),
|
|
(check_query_requests_not_kinded, "client-requests-not-kinded"),
|
|
(check_query_requests_not_objects, "client-requests-not-objects"),
|
|
(check_query_requests_unknown, "client-requests-unknown"),
|
|
]
|
|
for (f, k) in expected:
|
|
assert is_dict(q[k])
|
|
assert sorted(q[k].keys()) == ["query.json"]
|
|
f(q[k]["query.json"])
|
|
expected = [
|
|
(check_query_response_array_negative_major_version, "client-request-array-negative-major-version"),
|
|
(check_query_response_array_negative_minor_version, "client-request-array-negative-minor-version"),
|
|
(check_query_response_array_negative_version, "client-request-array-negative-version"),
|
|
(check_query_response_array_no_major_version, "client-request-array-no-major-version"),
|
|
(check_query_response_array_no_supported_version, "client-request-array-no-supported-version"),
|
|
(check_query_response_array_no_supported_version_among, "client-request-array-no-supported-version-among"),
|
|
(check_query_response_array_version_1, "client-request-array-version-1"),
|
|
(check_query_response_array_version_1_1, "client-request-array-version-1-1"),
|
|
(check_query_response_array_version_2, "client-request-array-version-2"),
|
|
(check_query_response_negative_major_version, "client-request-negative-major-version"),
|
|
(check_query_response_negative_minor_version, "client-request-negative-minor-version"),
|
|
(check_query_response_negative_version, "client-request-negative-version"),
|
|
(check_query_response_no_major_version, "client-request-no-major-version"),
|
|
(check_query_response_no_version, "client-request-no-version"),
|
|
(check_query_response_version_1, "client-request-version-1"),
|
|
(check_query_response_version_1_1, "client-request-version-1-1"),
|
|
(check_query_response_version_2, "client-request-version-2"),
|
|
]
|
|
for (f, k) in expected:
|
|
assert is_dict(q[k])
|
|
assert sorted(q[k].keys()) == ["query.json"]
|
|
assert is_dict(q[k]["query.json"])
|
|
assert sorted(q[k]["query.json"].keys()) == ["requests", "responses"]
|
|
r = q[k]["query.json"]["requests"]
|
|
assert is_list(r)
|
|
assert len(r) == 1
|
|
assert is_dict(r[0])
|
|
assert r[0]["kind"] == "__test"
|
|
r = q[k]["query.json"]["responses"]
|
|
assert is_list(r)
|
|
assert len(r) == 1
|
|
assert is_dict(r[0])
|
|
f(r[0])
|
|
|
|
def check_query_client_member(q):
|
|
assert is_dict(q)
|
|
assert sorted(q.keys()) == ["client", "responses"]
|
|
assert is_dict(q["client"])
|
|
assert sorted(q["client"].keys()) == []
|
|
check_error(q["responses"], "'requests' member missing")
|
|
|
|
def check_query_empty_array(q):
|
|
check_error(q, "query root is not an object")
|
|
|
|
def check_query_empty_object(q):
|
|
assert is_dict(q)
|
|
assert sorted(q.keys()) == ["responses"]
|
|
check_error(q["responses"], "'requests' member missing")
|
|
|
|
def check_query_json_bad_root(q):
|
|
check_error_re(q, "A valid JSON document must be either an array or an object value")
|
|
|
|
def check_query_json_empty(q):
|
|
check_error_re(q, "value, object or array expected")
|
|
|
|
def check_query_json_extra(q):
|
|
check_error_re(q, "Extra non-whitespace after JSON value")
|
|
|
|
def check_query_not_file(q):
|
|
check_error_re(q, "failed to read from file")
|
|
|
|
def check_query_requests_bad(q):
|
|
assert is_dict(q)
|
|
assert sorted(q.keys()) == ["requests", "responses"]
|
|
r = q["requests"]
|
|
assert is_dict(r)
|
|
assert sorted(r.keys()) == []
|
|
check_error(q["responses"], "'requests' member is not an array")
|
|
|
|
def check_query_requests_empty(q):
|
|
assert is_dict(q)
|
|
assert sorted(q.keys()) == ["requests", "responses"]
|
|
r = q["requests"]
|
|
assert is_list(r)
|
|
assert len(r) == 0
|
|
r = q["responses"]
|
|
assert is_list(r)
|
|
assert len(r) == 0
|
|
|
|
def check_query_requests_not_kinded(q):
|
|
assert is_dict(q)
|
|
assert sorted(q.keys()) == ["requests", "responses"]
|
|
r = q["requests"]
|
|
assert is_list(r)
|
|
assert len(r) == 4
|
|
assert is_dict(r[0])
|
|
assert sorted(r[0].keys()) == []
|
|
assert is_dict(r[1])
|
|
assert sorted(r[1].keys()) == ["kind"]
|
|
assert is_dict(r[1]["kind"])
|
|
assert is_dict(r[2])
|
|
assert sorted(r[2].keys()) == ["kind"]
|
|
assert is_list(r[2]["kind"])
|
|
assert is_dict(r[3])
|
|
assert sorted(r[3].keys()) == ["kind"]
|
|
assert is_int(r[3]["kind"])
|
|
r = q["responses"]
|
|
assert is_list(r)
|
|
assert len(r) == 4
|
|
check_error(r[0], "'kind' member missing")
|
|
check_error(r[1], "'kind' member is not a string")
|
|
check_error(r[2], "'kind' member is not a string")
|
|
check_error(r[3], "'kind' member is not a string")
|
|
|
|
def check_query_requests_not_objects(q):
|
|
assert is_dict(q)
|
|
assert sorted(q.keys()) == ["requests", "responses"]
|
|
r = q["requests"]
|
|
assert is_list(r)
|
|
assert len(r) == 3
|
|
assert is_int(r[0])
|
|
assert is_string(r[1])
|
|
assert is_list(r[2])
|
|
r = q["responses"]
|
|
assert is_list(r)
|
|
assert len(r) == 3
|
|
check_error(r[0], "request is not an object")
|
|
check_error(r[1], "request is not an object")
|
|
check_error(r[2], "request is not an object")
|
|
|
|
def check_query_requests_unknown(q):
|
|
assert is_dict(q)
|
|
assert sorted(q.keys()) == ["requests", "responses"]
|
|
r = q["requests"]
|
|
assert is_list(r)
|
|
assert len(r) == 3
|
|
assert is_dict(r[0])
|
|
assert sorted(r[0].keys()) == ["kind"]
|
|
assert r[0]["kind"] == "unknownC"
|
|
assert is_dict(r[1])
|
|
assert sorted(r[1].keys()) == ["kind"]
|
|
assert r[1]["kind"] == "unknownB"
|
|
assert is_dict(r[2])
|
|
assert sorted(r[2].keys()) == ["kind"]
|
|
assert r[2]["kind"] == "unknownA"
|
|
r = q["responses"]
|
|
assert is_list(r)
|
|
assert len(r) == 3
|
|
check_error(r[0], "unknown request kind 'unknownC'")
|
|
check_error(r[1], "unknown request kind 'unknownB'")
|
|
check_error(r[2], "unknown request kind 'unknownA'")
|
|
|
|
def check_query_response_array_negative_major_version(r):
|
|
check_error(r, "'version' object 'major' member is not a non-negative integer")
|
|
|
|
def check_query_response_array_negative_minor_version(r):
|
|
check_error(r, "'version' object 'minor' member is not a non-negative integer")
|
|
|
|
def check_query_response_array_negative_version(r):
|
|
check_error(r, "'version' array entry is not a non-negative integer or object")
|
|
|
|
def check_query_response_array_no_major_version(r):
|
|
check_error(r, "'version' object 'major' member missing")
|
|
|
|
def check_query_response_array_no_supported_version(r):
|
|
check_error(r, "no supported version specified")
|
|
|
|
def check_query_response_array_no_supported_version_among(r):
|
|
check_error(r, "no supported version specified among: 4.0 3.0")
|
|
|
|
def check_query_response_array_version_1(r):
|
|
check_index__test(r, 1, 3)
|
|
|
|
def check_query_response_array_version_1_1(r):
|
|
check_index__test(r, 1, 3) # always uses latest minor version
|
|
|
|
def check_query_response_array_version_2(r):
|
|
check_index__test(r, 2, 0)
|
|
|
|
def check_query_response_negative_major_version(r):
|
|
check_error(r, "'version' object 'major' member is not a non-negative integer")
|
|
|
|
def check_query_response_negative_minor_version(r):
|
|
check_error(r, "'version' object 'minor' member is not a non-negative integer")
|
|
|
|
def check_query_response_negative_version(r):
|
|
check_error(r, "'version' member is not a non-negative integer, object, or array")
|
|
|
|
def check_query_response_no_major_version(r):
|
|
check_error(r, "'version' object 'major' member missing")
|
|
|
|
def check_query_response_no_version(r):
|
|
check_error(r, "'version' member missing")
|
|
|
|
def check_query_response_version_1(r):
|
|
check_index__test(r, 1, 3)
|
|
|
|
def check_query_response_version_1_1(r):
|
|
check_index__test(r, 1, 3) # always uses latest minor version
|
|
|
|
def check_query_response_version_2(r):
|
|
check_index__test(r, 2, 0)
|
|
|
|
def check_objects(o):
|
|
assert is_list(o)
|
|
assert len(o) == 2
|
|
check_index__test(o[0], 1, 3)
|
|
check_index__test(o[1], 2, 0)
|
|
|
|
assert is_dict(index)
|
|
assert sorted(index.keys()) == ["cmake", "objects", "reply"]
|
|
check_cmake(index["cmake"])
|
|
check_reply(index["reply"])
|
|
check_objects(index["objects"])
|