Tests/RunCMake/FileAPI/ClientStateful-check.py

   1 from check_index import *
   2
   3 def check_reply(q):
   4     assert is_dict(q)
   5     assert sorted(q.keys()) == [
   6         "client-client-member",
   7         "client-empty-array",
   8         "client-empty-object",
   9         "client-json-bad-root",
  10         "client-json-empty",
  11         "client-json-extra",
  12         "client-not-file",
  13         "client-request-array-negative-major-version",
  14         "client-request-array-negative-minor-version",
  15         "client-request-array-negative-version",
  16         "client-request-array-no-major-version",
  17         "client-request-array-no-supported-version",
  18         "client-request-array-no-supported-version-among",
  19         "client-request-array-version-1",
  20         "client-request-array-version-1-1",
  21         "client-request-array-version-2",
  22         "client-request-negative-major-version",
  23         "client-request-negative-minor-version",
  24         "client-request-negative-version",
  25         "client-request-no-major-version",
  26         "client-request-no-version",
  27         "client-request-version-1",
  28         "client-request-version-1-1",
  29         "client-request-version-2",
  30         "client-requests-bad",
  31         "client-requests-empty",
  32         "client-requests-not-kinded",
  33         "client-requests-not-objects",
  34         "client-requests-unknown",
  35     ]
  36     expected = [
  37         (check_query_client_member, "client-client-member"),
  38         (check_query_empty_array, "client-empty-array"),
  39         (check_query_empty_object, "client-empty-object"),
  40         (check_query_json_bad_root, "client-json-bad-root"),
  41         (check_query_json_empty, "client-json-empty"),
  42         (check_query_json_extra, "client-json-extra"),
  43         (check_query_not_file, "client-not-file"),
  44         (check_query_requests_bad, "client-requests-bad"),
  45         (check_query_requests_empty, "client-requests-empty"),
  46         (check_query_requests_not_kinded, "client-requests-not-kinded"),
  47         (check_query_requests_not_objects, "client-requests-not-objects"),
  48         (check_query_requests_unknown, "client-requests-unknown"),
  49     ]
  50     for (f, k) in expected:
  51         assert is_dict(q[k])
  52         assert sorted(q[k].keys()) == ["query.json"]
  53         f(q[k]["query.json"])
  54     expected = [
  55         (check_query_response_array_negative_major_version,     "client-request-array-negative-major-version"),
  56         (check_query_response_array_negative_minor_version,     "client-request-array-negative-minor-version"),
  57         (check_query_response_array_negative_version,           "client-request-array-negative-version"),
  58         (check_query_response_array_no_major_version,           "client-request-array-no-major-version"),
  59         (check_query_response_array_no_supported_version,       "client-request-array-no-supported-version"),
  60         (check_query_response_array_no_supported_version_among, "client-request-array-no-supported-version-among"),
  61         (check_query_response_array_version_1,                  "client-request-array-version-1"),
  62         (check_query_response_array_version_1_1,                "client-request-array-version-1-1"),
  63         (check_query_response_array_version_2,                  "client-request-array-version-2"),
  64         (check_query_response_negative_major_version,           "client-request-negative-major-version"),
  65         (check_query_response_negative_minor_version,           "client-request-negative-minor-version"),
  66         (check_query_response_negative_version,                 "client-request-negative-version"),
  67         (check_query_response_no_major_version,                 "client-request-no-major-version"),
  68         (check_query_response_no_version,                       "client-request-no-version"),
  69         (check_query_response_version_1,                        "client-request-version-1"),
  70         (check_query_response_version_1_1,                      "client-request-version-1-1"),
  71         (check_query_response_version_2,                        "client-request-version-2"),
  72     ]
  73     for (f, k) in expected:
  74         assert is_dict(q[k])
  75         assert sorted(q[k].keys()) == ["query.json"]
  76         assert is_dict(q[k]["query.json"])
  77         assert sorted(q[k]["query.json"].keys()) == ["requests", "responses"]
  78         r = q[k]["query.json"]["requests"]
  79         assert is_list(r)
  80         assert len(r) == 1
  81         assert is_dict(r[0])
  82         assert r[0]["kind"] == "__test"
  83         r = q[k]["query.json"]["responses"]
  84         assert is_list(r)
  85         assert len(r) == 1
  86         assert is_dict(r[0])
  87         f(r[0])
  88
  89 def check_query_client_member(q):
  90     assert is_dict(q)
  91     assert sorted(q.keys()) == ["client", "responses"]
  92     assert is_dict(q["client"])
  93     assert sorted(q["client"].keys()) == []
  94     check_error(q["responses"], "'requests' member missing")
  95
  96 def check_query_empty_array(q):
  97     check_error(q, "query root is not an object")
  98
  99 def check_query_empty_object(q):
 100     assert is_dict(q)
 101     assert sorted(q.keys()) == ["responses"]
 102     check_error(q["responses"], "'requests' member missing")
 103
 104 def check_query_json_bad_root(q):
 105     check_error_re(q, "A valid JSON document must be either an array or an object value")
 106
 107 def check_query_json_empty(q):
 108     check_error_re(q, "value, object or array expected")
 109
 110 def check_query_json_extra(q):
 111     check_error_re(q, "Extra non-whitespace after JSON value")
 112
 113 def check_query_not_file(q):
 114     check_error_re(q, "failed to read from file")
 115
 116 def check_query_requests_bad(q):
 117     assert is_dict(q)
 118     assert sorted(q.keys()) == ["requests", "responses"]
 119     r = q["requests"]
 120     assert is_dict(r)
 121     assert sorted(r.keys()) == []
 122     check_error(q["responses"], "'requests' member is not an array")
 123
 124 def check_query_requests_empty(q):
 125     assert is_dict(q)
 126     assert sorted(q.keys()) == ["requests", "responses"]
 127     r = q["requests"]
 128     assert is_list(r)
 129     assert len(r) == 0
 130     r = q["responses"]
 131     assert is_list(r)
 132     assert len(r) == 0
 133
 134 def check_query_requests_not_kinded(q):
 135     assert is_dict(q)
 136     assert sorted(q.keys()) == ["requests", "responses"]
 137     r = q["requests"]
 138     assert is_list(r)
 139     assert len(r) == 4
 140     assert is_dict(r[0])
 141     assert sorted(r[0].keys()) == []
 142     assert is_dict(r[1])
 143     assert sorted(r[1].keys()) == ["kind"]
 144     assert is_dict(r[1]["kind"])
 145     assert is_dict(r[2])
 146     assert sorted(r[2].keys()) == ["kind"]
 147     assert is_list(r[2]["kind"])
 148     assert is_dict(r[3])
 149     assert sorted(r[3].keys()) == ["kind"]
 150     assert is_int(r[3]["kind"])
 151     r = q["responses"]
 152     assert is_list(r)
 153     assert len(r) == 4
 154     check_error(r[0], "'kind' member missing")
 155     check_error(r[1], "'kind' member is not a string")
 156     check_error(r[2], "'kind' member is not a string")
 157     check_error(r[3], "'kind' member is not a string")
 158
 159 def check_query_requests_not_objects(q):
 160     assert is_dict(q)
 161     assert sorted(q.keys()) == ["requests", "responses"]
 162     r = q["requests"]
 163     assert is_list(r)
 164     assert len(r) == 3
 165     assert is_int(r[0])
 166     assert is_string(r[1])
 167     assert is_list(r[2])
 168     r = q["responses"]
 169     assert is_list(r)
 170     assert len(r) == 3
 171     check_error(r[0], "request is not an object")
 172     check_error(r[1], "request is not an object")
 173     check_error(r[2], "request is not an object")
 174
 175 def check_query_requests_unknown(q):
 176     assert is_dict(q)
 177     assert sorted(q.keys()) == ["requests", "responses"]
 178     r = q["requests"]
 179     assert is_list(r)
 180     assert len(r) == 3
 181     assert is_dict(r[0])
 182     assert sorted(r[0].keys()) == ["kind"]
 183     assert r[0]["kind"] == "unknownC"
 184     assert is_dict(r[1])
 185     assert sorted(r[1].keys()) == ["kind"]
 186     assert r[1]["kind"] == "unknownB"
 187     assert is_dict(r[2])
 188     assert sorted(r[2].keys()) == ["kind"]
 189     assert r[2]["kind"] == "unknownA"
 190     r = q["responses"]
 191     assert is_list(r)
 192     assert len(r) == 3
 193     check_error(r[0], "unknown request kind 'unknownC'")
 194     check_error(r[1], "unknown request kind 'unknownB'")
 195     check_error(r[2], "unknown request kind 'unknownA'")
 196
 197 def check_query_response_array_negative_major_version(r):
 198     check_error(r, "'version' object 'major' member is not a non-negative integer")
 199
 200 def check_query_response_array_negative_minor_version(r):
 201     check_error(r, "'version' object 'minor' member is not a non-negative integer")
 202
 203 def check_query_response_array_negative_version(r):
 204     check_error(r, "'version' array entry is not a non-negative integer or object")
 205
 206 def check_query_response_array_no_major_version(r):
 207     check_error(r, "'version' object 'major' member missing")
 208
 209 def check_query_response_array_no_supported_version(r):
 210     check_error(r, "no supported version specified")
 211
 212 def check_query_response_array_no_supported_version_among(r):
 213     check_error(r, "no supported version specified among: 4.0 3.0")
 214
 215 def check_query_response_array_version_1(r):
 216     check_index__test(r, 1, 3)
 217
 218 def check_query_response_array_version_1_1(r):
 219     check_index__test(r, 1, 3) # always uses latest minor version
 220
 221 def check_query_response_array_version_2(r):
 222     check_index__test(r, 2, 0)
 223
 224 def check_query_response_negative_major_version(r):
 225     check_error(r, "'version' object 'major' member is not a non-negative integer")
 226
 227 def check_query_response_negative_minor_version(r):
 228     check_error(r, "'version' object 'minor' member is not a non-negative integer")
 229
 230 def check_query_response_negative_version(r):
 231     check_error(r, "'version' member is not a non-negative integer, object, or array")
 232
 233 def check_query_response_no_major_version(r):
 234     check_error(r, "'version' object 'major' member missing")
 235
 236 def check_query_response_no_version(r):
 237     check_error(r, "'version' member missing")
 238
 239 def check_query_response_version_1(r):
 240     check_index__test(r, 1, 3)
 241
 242 def check_query_response_version_1_1(r):
 243     check_index__test(r, 1, 3) # always uses latest minor version
 244
 245 def check_query_response_version_2(r):
 246     check_index__test(r, 2, 0)
 247
 248 def check_objects(o):
 249     assert is_list(o)
 250     assert len(o) == 2
 251     check_index__test(o[0], 1, 3)
 252     check_index__test(o[1], 2, 0)
 253
 254 assert is_dict(index)
 255 assert sorted(index.keys()) == ["cmake", "objects", "reply"]
 256 check_cmake(index["cmake"])
 257 check_reply(index["reply"])
 258 check_objects(index["objects"])