def test4get_match_element_with_optional_key(self):
"""Validate optional keys with the optional_key_prefix."""
json_model_element = JsonModelElement(self.id_, self.key_parser_dict)
data = self.single_line_with_optional_key_json
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(
match_context.match_string)).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
json_model_element = JsonModelElement(self.id_,
self.empty_key_parser_dict)
data = b"{}"
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(data)).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
def test5get_match_element_with_allow_all(self):
"""Test a simplified key_parser_dict with ALLOW_ALL."""
json_model_element = JsonModelElement(self.id_, self.key_parser_dict_allow_all)
data = self.single_line_json
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(
data, match_element, match_context, self.id_, self.path, str(value).encode(), value, match_element.children)
data = self.multi_line_json
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(
data, match_element, match_context, self.id_, self.path, str(value).encode(), value, match_element.children)
data = self.everything_new_line_json
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(
data, match_element, match_context, self.id_, self.path, str(value).encode(), value, match_element.children)
def test6get_match_element_null_value(self):
"""Test if null values are parsed to "null"."""
key_parser_dict = {
"works": DummyFirstMatchModelElement("id", [
DummyFixedDataModelElement("abc", b"abc"), DummyFixedDataModelElement("123", b"123")]),
"null": DummyFirstMatchModelElement("wordlist", [
DummyFixedDataModelElement("allowed", b"allowed value"), DummyFixedDataModelElement("problem", b"null")])}
data1 = b"""{
"works": "abc",
"null": "allowed value"
}"""
data2 = b"""{
"works": "123",
"null": null
}"""
data3 = b"""{"a": {"b": "c"}}"""
data4 = b"""{"a": null}"""
json_model_element = JsonModelElement(self.id_, key_parser_dict)
data = data1
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(
data, match_element, match_context, self.id_, self.path, str(value).encode(), value, match_element.children)
data = data2
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(
data, match_element, match_context, self.id_, self.path, str(value).encode(), value, match_element.children)
key_parser_dict = {"a": {"b": DummyFixedDataModelElement("c", b"c")}}
json_model_element = JsonModelElement(self.id_, key_parser_dict)
data = data3
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(
data, match_element, match_context, self.id_, self.path, str(value).encode(), value, match_element.children)
data = data4
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
def test11get_match_element_allow_all_fields(self):
"""Parse matching substring from MatchContext using the allow_all_fields parameter."""
json_model_element = JsonModelElement(
self.id_,
self.key_parser_dict_allow_all_fields,
allow_all_fields=True)
data = self.single_line_json
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(
match_context.match_string)).encode()
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
json_model_element = JsonModelElement(
self.id_,
self.key_parser_dict_allow_all_fields,
allow_all_fields=False)
data = self.single_line_json
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
def test7get_match_element_with_umlaut(self):
"""Test if ä ö ü are used correctly."""
key_parser_dict = {"works": DummyFixedDataModelElement("abc", "a ä ü ö z".encode("utf-8"))}
data = """{
"works": "a ä ü ö z"
}""".encode("utf-8")
json_model_element = JsonModelElement(self.id_, key_parser_dict)
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(
data, match_element, match_context, self.id_, self.path, str(value).encode(), value, match_element.children)
def test3get_match_element_valid_match(self):
"""Try all values and check if the desired results are produced."""
allowed_chars = [
b"0", b"1", b"2", b"3", b"4", b"5", b"6", b"7", b"8", b"9", b"a",
b"b", b"c", b"d", b"e", b"f"
]
char1 = b"\x00"
char2 = b"\x00"
hex_string_model_element = HexStringModelElement(self.id_)
while ord(char2) < ord(b"\x7F"):
data = char2 + char1
match_context = DummyMatchContext(data)
match_element = hex_string_model_element.get_match_element(
self.path, match_context)
if char2 in allowed_chars:
if char1 in allowed_chars:
match_context.match_string = bytes.fromhex(data.decode(
)) # match_context.match_string check has to be skipped.
match_context.match_data = data[len(
match_context.match_string
):] # match_context.match_data has to be rewritten.
self.compare_match_results(data, match_element,
match_context, self.id_,
self.path,
bytes.fromhex(data.decode()),
data, None)
self.assertEqual(match_element.get_match_object(), data)
else:
match_context.match_string = bytes.fromhex(
"0" + char2.decode()
) # match_context.match_string check has to be skipped.
self.compare_match_results(
data, match_element,
match_context, self.id_, self.path,
bytes.fromhex("0" + char2.decode()), char2, None)
self.assertEqual(match_element.get_match_object(), char2)
else:
self.compare_no_match_results(data, match_element,
match_context)
if ord(char1) == 0x7f:
char1 = b"\x00"
char2 = bytes(chr(ord(char2) + 1), "utf-8")
else:
char1 = bytes(chr(ord(char1) + 1), "utf-8")
allowed_chars = [
b"0", b"1", b"2", b"3", b"4", b"5", b"6", b"7", b"8", b"9", b"A",
b"B", b"C", b"D", b"E", b"F"
]
char1 = b"\x00"
char2 = b"\x00"
hex_string_model_element = HexStringModelElement(self.id_, True)
while ord(char2) < ord(b"\x7F"):
data = char2 + char1
match_context = DummyMatchContext(data)
match_element = hex_string_model_element.get_match_element(
self.path, match_context)
if char2 in allowed_chars:
if char1 in allowed_chars:
self.assertEqual(match_element.get_match_object(), data)
else:
self.assertEqual(match_element.get_match_object(), char2)
else:
self.compare_no_match_results(data, match_element,
match_context)
if ord(char1) == 0x7f:
char1 = b"\x00"
char2 = bytes(chr(ord(char2) + 1), "utf-8")
else:
char1 = bytes(chr(ord(char1) + 1), "utf-8")
def test10get_match_element_float_exponents(self):
"""
Parse float values with exponents.
The principle of only testing dummy classes can not be applied here, as the functionality between the JsonModelElement and
DecimalFloatValueModelElement must be tested directly.
"""
json_model_element = JsonModelElement(
self.id_, {
"a":
DecimalFloatValueModelElement(
self.id_,
exponent_type=DecimalFloatValueModelElement.
EXP_TYPE_OPTIONAL),
"b":
DecimalFloatValueModelElement(
self.id_,
exponent_type=DecimalFloatValueModelElement.
EXP_TYPE_OPTIONAL)
})
def format_float(val):
"""
This function formats the float-value and parses the sign and the exponent
"""
exp = None
if "e" in val:
exp = "e"
elif "E" in val:
exp = "E"
if "+" in val:
sign = "+"
else:
sign = "-"
if exp is not None:
pos_point = val.find(exp)
if "." in val:
pos_point = val.find(".")
if len(val) - val.find(sign) <= 2:
result = format(float(val),
"1.%dE" % (val.find(exp) - pos_point))[:-2]
result += format(float(val),
"1.%dE" % (val.find(exp) - pos_point))[-1]
return result
return format(float(val),
"1.%dE" % (val.find(exp) - pos_point))
return float(val)
data = b'{"a": 111.1, "b": 111.1}'
value = json.loads(data, parse_float=format_float)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = b'{"a": 1E-01, "b": 111.1}'
value = json.loads(data, parse_float=format_float)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = b'{"a": 111.1, "b": 1E-1}'
value = json.loads(data, parse_float=format_float)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = b'{"a": 1E-1, "b": 1E-1}'
value = json.loads(data, parse_float=format_float)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
def test9get_match_element_empty_array_empty_object_null(self):
"""Test if the keywords EMPTY_ARRAY, EMPTY_OBJECT, EMPTY_STRING and None (null) work properly."""
key_parser_dict = {
"menu": {
"id": "EMPTY_OBJECT",
"value": "EMPTY_ARRAY",
"popup": {
"menuitem": [{
"value":
DummyFixedDataModelElement("null", b"null"),
"onclick":
DummyFirstMatchModelElement("buttonOnclick", [
DummyFixedDataModelElement("create_new_doc",
b"CreateNewDoc()"),
DummyFixedDataModelElement("open_doc",
b"OpenDoc()"),
DummyFixedDataModelElement("close_doc",
b"CloseDoc()")
]),
"optional_key_clickable":
DummyFirstMatchModelElement("clickable", [
DummyFixedDataModelElement("true", b"true"),
DummyFixedDataModelElement("false", b"false")
])
}]
}
},
"a": "EMPTY_ARRAY",
"b": "EMPTY_OBJECT",
"c": "EMPTY_STRING"
}
json_model_element = JsonModelElement(self.id_, key_parser_dict)
data = b'{"menu": {"id": {}, "value": [], "popup": {"menuitem": [{"value": null, "onclick": "CreateNewDoc()"}, {"value": null, ' \
b'"onclick": "OpenDoc()"}, {"value": null, "onclick": "CloseDoc()"}]}}, "a": [], "b": {}, "c": ""}'
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(
match_context.match_string)).encode()
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = b'{"menu": {"id": {\n}, "value": [\n], "popup": {"menuitem": [{"value": null, "onclick": "CreateNewDoc()"}, {"value": ' \
b'null, "onclick": "OpenDoc()"}, {"value": null, "onclick": "CloseDoc()"}]}}, "a": [], "b": {}, "c": ""}'
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(
match_context.match_string)).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
JsonModelElement(self.id_, {"a": "EMPTY_ARRAY"})
JsonModelElement(self.id_, {"a": "EMPTY_OBJECT"})
JsonModelElement(self.id_, {"a": "EMPTY_STRING"})
data = b'{"menu": {"id": {}, "value": [], "popup": {"menuitem": [{"value": null, "onclick": "CreateNewDoc()"}, {"value": null, ' \
b'"onclick": "OpenDoc()"}, {"value": null, "onclick": "CloseDoc()"}]}}, "a": ["a"], "b": {}, "c": ""}'
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
data = b'{"menu": {"id": {}, "value": [], "popup": {"menuitem": [{"value": null, "onclick": "CreateNewDoc()"}, {"value": null, ' \
b'"onclick": "OpenDoc()"}, {"value": null, "onclick": "CloseDoc()"}]}}, "a": [], "b": {"a": "a"}, "c": ""}'
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
data = b'{"menu": {"id": {}, "value": [], "popup": {"menuitem": [{"value": null, "onclick": "CreateNewDoc()"}, {"value": null, ' \
b'"onclick": "OpenDoc()"}, {"value": null, "onclick": "CloseDoc()"}]}}, "a": [], "b": {}, "c": "ab"}'
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
data = b'{"menu": {"id": {}, "value": [], "popup": {"menuitem": []}}, "a": [], "b": {}, "c": ""}'
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
def test8get_match_element_same_value_as_key(self):
"""Test if object with the same key-value pairs are parsed correctly."""
key_parser_dict = {
"abc":
DummyFirstMatchModelElement("first", [
DummyFixedDataModelElement("abc", b"abc"),
DummyFixedDataModelElement("abc", b"ab"),
DummyFixedDataModelElement("abc", b"bc"),
DummyFixedDataModelElement("abc", b"ba"),
DummyFixedDataModelElement("abc", b"b"),
DummyFixedDataModelElement("abc", b"d")
])
}
data = b"""{"abc":"abc"}"""
json_model_element = JsonModelElement(self.id_, key_parser_dict)
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = b"""{"abc":"ab"}"""
json_model_element = JsonModelElement(self.id_, key_parser_dict)
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = b"""{"abc":"bc"}"""
json_model_element = JsonModelElement(self.id_, key_parser_dict)
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = b"""{"abc":"b"}"""
json_model_element = JsonModelElement(self.id_, key_parser_dict)
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = b"""{"abc":"d"}"""
json_model_element = JsonModelElement(self.id_, key_parser_dict)
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = b"""{"abc":"ba"}"""
json_model_element = JsonModelElement(self.id_, key_parser_dict)
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
def test3get_match_element_valid_match(self):
"""Parse matching substring from MatchContext and check if the MatchContext was updated with all characters."""
json_model_element = JsonModelElement(self.id_, self.key_parser_dict)
data = self.single_line_json
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(
match_context.match_string)).encode()
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = self.multi_line_json
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(
match_context.match_string)).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = self.everything_new_line_json
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(
match_context.match_string)).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
# Test if keys differently ordered than in the key_parser_dict are parsed properly.
data = self.single_line_different_order_with_optional_key_json
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(
match_context.match_string)).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
data = self.single_line_empty_array
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(
match_context.match_string)).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
json_model_element = JsonModelElement(self.id_,
self.key_parser_dict_allow_all)
data = self.single_line_different_order_with_optional_key_json
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
json_model_element = JsonModelElement(self.id_,
self.key_parser_dict_array)
data = self.single_line_json_array
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
json_model_element = JsonModelElement(self.id_,
self.key_parser_dict_escaped)
data = self.single_line_escaped_json.decode("unicode-escape").encode()
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(value).encode()
match_context.match_data = data[len(match_context.match_string):]
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)
json_model_element = JsonModelElement(
self.id_, self.key_parser_dict_array_of_arrays)
data = self.array_of_arrays
value = json.loads(data)
match_context = DummyMatchContext(data)
match_element = json_model_element.get_match_element(
self.path, match_context)
match_context.match_string = str(json.loads(
match_context.match_string)).encode()
self.compare_match_results(data, match_element, match_context,
self.id_, self.path,
str(value).encode(), value,
match_element.children)