def test_avu_to_json_invalid_boolean_exception(self):
"""
Test if basic json file is correctly transformed to avu and back to json
"""
data = [{'a': 'k2', 'u': 'root_0_b', 'v': 'Boolean'}]
with self.assertRaises(Exception):
jsonavu.avu2json(data, "root")
def test_simple_avu_to_json_float(self):
"""
Test if simple avu is correctly transformed to json using integer as type
"""
data = [{'a': 'k1', 'u': 'root_0_n', 'v': '5.0'}]
json_output = jsonavu.avu2json(data, "root")
self.assertEqual('{"k1": 5.0}', json.dumps(json_output))
def test_simple_avu_to_json_nested_array(self):
"""
Test if simple avu is correctly transformed to json using object as type
"""
data = [{
'a': u'k2',
'u': 'root_0_s#0#0',
'v': u'v4'
}, {
'a': u'k2',
'u': 'root_0_s#0#1',
'v': u'v5'
}, {
'a': u'k2',
'u': 'root_0_s#1#0',
'v': u'v6'
}, {
'a': u'k2',
'u': 'root_0_s#1#1',
'v': u'v7'
}, {
'a': u'k1',
'u': 'root_0_s',
'v': u'v1'
}]
json_output = jsonavu.avu2json(data, "root")
self.assertEqual('{"k1": "v1", "k2": [["v4", "v5"], ["v6", "v7"]]}',
json.dumps(json_output, sort_keys=True))
def test_simple_avu_to_json_string(self):
"""
Test if simple avu is correctly transformed to json using string as type
"""
data = [{'a': 'k1', 'u': 'root_0_s', 'v': 'v1'}]
json_output = jsonavu.avu2json(data, "root")
self.assertEqual('{"k1": "v1"}', json.dumps(json_output))
def test_simple_avu_to_json_null(self):
"""
Test if simple avu is correctly transformed to json using null as type
"""
data = [{'a': 'k1', 'u': 'root_0_z', 'v': '.'}]
json_output = jsonavu.avu2json(data, "root")
self.assertEqual('{"k1": null}', json.dumps(json_output))
def test_simple_bidirectional(self):
"""
Test if simple json is correctly transformed to avu and back to json
"""
data = json.loads('{"k1": "v1"}')
avu = jsonavu.json2avu(data, "root")
json_output = jsonavu.avu2json(avu, "root")
self.assertEqual('{"k1": "v1"}', json.dumps(json_output))
def test_json_empty_arrays_file_bidirectional(self):
"""
Test if empty array and empty object json file is correctly transformed to avu and back to json
"""
data = json.loads(self.test_data_empty_arrays_json)
avu = jsonavu.json2avu(data, "root")
json_output = jsonavu.avu2json(avu, "root")
self.assertCountEqual(json.dumps(data, sort_keys=True),
json.dumps(json_output, sort_keys=True))
def test_unicode_bidirectional(self):
"""
Test if unicode json is correctly transformed to avu and back to json
"""
data = json.loads('{"k1": "µm"}')
avu = jsonavu.json2avu(data, "root")
json_output = jsonavu.avu2json(avu, "root")
self.assertEqual('{"k1": "µm"}',
json.dumps(json_output, ensure_ascii=False))
def test_avu_to_json_incorrect_unit_pattern(self):
"""
Test if avu with an element with incorrect pattern is ignored
"""
data = [{
'a': 'k1',
'u': 'root_0_s',
'v': 'v1'
}, {
'a': 'k2',
'u': 'this_is_a_test',
'v': 'Boolean'
}]
json_output = jsonavu.avu2json(data, "root")
self.assertEqual('{"k1": "v1"}', json.dumps(json_output))
def test_avu_to_json_illegal_type(self):
"""
Test if avu with an element with illegal type is ignored
"""
data = [{
'a': 'k1',
'u': 'root_0_s',
'v': 'v1'
}, {
'a': 'k2',
'u': 'root_0_q',
'v': 'Boolean'
}]
json_output = jsonavu.avu2json(data, "root")
self.assertEqual('{"k1": "v1"}', json.dumps(json_output))
def test_simple_avu_to_json_boolean(self):
"""
Test if simple avu is correctly transformed to json using boolean as type
"""
data = [{
'a': u'k2',
'u': 'root_0_b',
'v': 'False'
}, {
'a': u'k1',
'u': 'root_0_b',
'v': 'True'
}]
json_output = jsonavu.avu2json(data, "root")
self.assertEqual('{"k1": true, "k2": false}',
json.dumps(json_output, sort_keys=True))
def test_simple_avu_to_json_empty_object(self):
"""
Test if simple avu is correctly transformed to json using empty object
"""
data = [{
'a': u'k1',
'u': 'root_0_s',
'v': u'v1'
}, {
'a': u'emptyObj',
'u': 'root_0_o1',
'v': u'o1'
}]
json_output = jsonavu.avu2json(data, "root")
self.assertEqual('{"emptyObj": {}, "k1": "v1"}',
json.dumps(json_output, sort_keys=True))
def test_simple_avu_to_json_empty_array(self):
"""
Test if simple avu is correctly transformed to json using empty array
"""
data = [{
'a': u'k1',
'u': 'root_0_s',
'v': u'v1'
}, {
'a': u'emptyArr',
'u': 'root_0_a',
'v': u'.'
}]
json_output = jsonavu.avu2json(data, "root")
self.assertEqual('{"emptyArr": [], "k1": "v1"}',
json.dumps(json_output, sort_keys=True))
def test_simple_avu_to_json_object(self):
"""
Test if simple avu is correctly transformed to json using object as type
"""
data = [{
'a': u'k2',
'u': 'root_0_o1',
'v': 'o1'
}, {
'a': u'k3',
'u': 'root_1_z',
'v': '.'
}, {
'a': u'k4',
'u': 'root_1_s',
'v': u'v3'
}]
json_output = jsonavu.avu2json(data, "root")
self.assertEqual('{"k2": {"k3": null, "k4": "v3"}}',
json.dumps(json_output))
def getJsonFromObj(rule_args, callback, rei):
"""
This function return a JSON string from AVU's set to an object
:param rule_args:
Argument 0: The object name (/nlmumc/P000000003, /nlmumc/projects/metadata.xml, [email protected], demoResc)
Argument 1: The object type
-d for data object
-R for resource
-C for collection
-u for user
Argument 2: The JSON root according to https://github.com/MaastrichtUniversity/irods_avu_json.
Argument 3: The JSON string
:param callback:
:param rei:
:return: JSON string is returned in rule_args[3]
"""
object_name = rule_args[0]
object_type = rule_args[1]
json_root = rule_args[2]
# Get all AVUs
fields = getFieldsForType(callback, object_type, object_name)
rows = genquery.row_iterator([fields['a'], fields['v'], fields['u']], fields['WHERE'], genquery.AS_DICT, callback)
avus = []
for row in rows:
avus.append({
"a": row[fields['a']],
"v": row[fields['v']],
"u": row[fields['u']]
})
# Convert AVUs to JSON
parsed_data = jsonavu.avu2json(avus, json_root)
result = json.dumps(parsed_data)
rule_args[3] = result
#!/usr/bin/python3
import json
import sys
import jsonavu
with open(sys.argv[1]) as f:
data = json.load(f)
avu = jsonavu.json2avu(data, "root")
print("Source:")
print(json.dumps(data, indent=4))
# Find out max V length and use that for formatting
max_a_len = len(max(avu, key=lambda k: len(str(k["a"])))["a"])
max_v_len = len(max(avu, key=lambda k: len(str(k["v"])))["v"])
out_format = "%" + str(max_a_len + 5) + "s %" + str(max_v_len + 5) + "s %15s"
print("AVUs:")
print(out_format % ("A", "V", "U"))
for i in avu:
print(out_format % (i["a"], i["v"], i["u"]))
print("JSON:")
data_back = jsonavu.avu2json(avu, "root")
print(json.dumps(data_back, indent=4))
