def test_get_merged_equivalent(self):
sec = Section(name="parent")
mersec = Section(name="merged_section")
merprop_other = Property(name="other_prop", value="other")
merprop = Property(name="prop", value=[1, 2, 3])
# Check None on unset parent.
prop = Property(name="prop")
self.assertIsNone(prop.get_merged_equivalent())
# Check None on parent without merged Section.
prop.parent = sec
self.assertIsNone(prop.get_merged_equivalent())
# Check None on parent with merged Section but no attached Property.
sec.merge(mersec)
self.assertIsNone(prop.get_merged_equivalent())
# Check None on parent with merged Section and unequal Property.
merprop_other.parent = mersec
self.assertIsNone(prop.get_merged_equivalent())
# Check receiving merged equivalent Property.
merprop.parent = mersec
self.assertIsNotNone(prop.get_merged_equivalent())
self.assertEqual(prop.get_merged_equivalent(), merprop)
def setUp(self):
doc = Document()
sec = Section(name="sec1", type="test", parent=doc)
Section(name="sec2", type="test", parent=sec)
Property(name="prop1", values=[1.3], parent=sec)
self.doc = doc
def test_get_merged_equivalent(self):
sec = Section(name="parent")
mersec = Section(name="merged_section")
merprop_other = Property(name="other_prop", value="other")
merprop = Property(name="prop", value=[1, 2, 3])
# Check None on unset parent.
prop = Property(name="prop")
self.assertIsNone(prop.get_merged_equivalent())
# Check None on parent without merged Section.
prop.parent = sec
self.assertIsNone(prop.get_merged_equivalent())
# Check None on parent with merged Section but no attached Property.
sec.merge(mersec)
self.assertIsNone(prop.get_merged_equivalent())
# Check None on parent with merged Section and unequal Property.
merprop_other.parent = mersec
self.assertIsNone(prop.get_merged_equivalent())
# Check receiving merged equivalent Property.
merprop.parent = mersec
self.assertIsNotNone(prop.get_merged_equivalent())
self.assertEqual(prop.get_merged_equivalent(), merprop)
def test_create_section(self):
root = Section("root")
self.assertEqual(len(root.sections), 0)
name = "subsec"
type = "subtype"
oid = "79b613eb-a256-46bf-84f6-207df465b8f7"
subsec = root.create_section(name, type, oid)
self.assertEqual(len(root.sections), 1)
self.assertEqual(subsec.parent, root)
self.assertEqual(root.sections[name], subsec)
self.assertEqual(root.sections[name].type, type)
self.assertEqual(root.sections[name].oid, oid)
name = "othersec"
subsec = root.create_section(name)
self.assertEqual(len(root.sections), 2)
self.assertEqual(subsec.parent, root)
self.assertEqual(root.sections[name], subsec)
self.assertEqual(root.sections[name].type, "undefined")
name = "subsubsec"
subsec = root.sections[0].create_section(name)
self.assertEqual(len(root.sections), 2)
self.assertEqual(subsec.parent, root.sections[0])
self.assertEqual(len(root.sections[0].sections), 1)
self.assertEqual(root.sections[0].sections[0].name, name)
def test_extend(self):
doc = Document()
self.assertListEqual(doc.sections, [])
# Test extend with Section list
doc.extend([Section(name="sec_one"), Section(name="sec_two")])
self.assertEqual(len(doc), 2)
self.assertEqual(len(doc.sections), 2)
self.assertEqual(doc.sections[0].name, "sec_one")
# Test fail on non iterable
with self.assertRaises(TypeError):
doc.extend(1)
self.assertEqual(len(doc.sections), 2)
# Test fail on non Section entry
with self.assertRaises(ValueError):
doc.extend([Document()])
with self.assertRaises(ValueError):
doc.extend([Property(name="prop")])
with self.assertRaises(ValueError):
doc.extend([5])
self.assertEqual(len(doc.sections), 2)
# Test fail on same name entities
with self.assertRaises(KeyError):
doc.extend([Section(name="sec_three"), Section(name="sec_one")])
self.assertEqual(len(doc.sections), 2)
def test_insert(self):
doc = Document()
sec_one = Section(name="sec_one", parent=doc)
sec_two = Section(name="sec_two", parent=doc)
subsec = Section(name="sec_three")
self.assertNotEqual(doc.sections[1].name, subsec.name)
doc.insert(1, subsec)
self.assertEqual(len(doc.sections), 3)
self.assertEqual(doc.sections[1].name, subsec.name)
self.assertEqual(doc.sections[0].name, sec_one.name)
self.assertEqual(doc.sections[2].name, sec_two.name)
self.assertEqual(subsec.parent, doc)
# Test invalid object
with self.assertRaises(ValueError):
doc.insert(1, Document())
with self.assertRaises(ValueError):
doc.insert(1, Property(name="prop_one"))
with self.assertRaises(ValueError):
doc.insert(1, "some info")
self.assertEqual(len(doc), 3)
# Test same name entries
with self.assertRaises(ValueError):
doc.insert(0, subsec)
self.assertEqual(len(doc), 3)
def test_sections_cardinality(self):
"""
Tests the basic assignment rules for Section sections cardinality
on init and re-assignment but does not test sections assignment or
the actual cardinality validation.
"""
doc = Document()
# -- Test set cardinality on Section init
# Test empty init
sec_card_none = Section(name="sec_cardinality_none", type="test", parent=doc)
self.assertIsNone(sec_card_none.sec_cardinality)
# Test single int max init
sec_card_max = Section(name="sec_cardinality_max", sec_cardinality=10, parent=doc)
self.assertEqual(sec_card_max.sec_cardinality, (None, 10))
# Test tuple init
sec_card_min = Section(name="sec_cardinality_min", sec_cardinality=(2, None), parent=doc)
self.assertEqual(sec_card_min.sec_cardinality, (2, None))
# -- Test Section properties cardinality re-assignment
sec = Section(name="sec", sec_cardinality=(None, 10), parent=doc)
self.assertEqual(sec.sec_cardinality, (None, 10))
# Use general method to reduce redundancy
self._test_cardinality_re_assignment(sec, 'sec_cardinality')
def setUp(self):
"""
Set up local temporary terminology files in a temporary folder
"""
tmp_dir = create_test_dir(__file__)
tmp_name = os.path.basename(tmp_dir)
main_name = "%s_main.xml" % tmp_name
main_file_path = os.path.join(tmp_dir, main_name)
main_url = "file://%s" % pathname2url(main_file_path)
include_name = "%s_include.xml" % tmp_name
include_file_path = os.path.join(tmp_dir, include_name)
include_url = "file://%s" % pathname2url(include_file_path)
include_doc = Document()
_ = Section(name="include_sec", type="test", parent=include_doc)
save(include_doc, include_file_path)
main_doc = Document()
_ = Section(name="main_sec", type="test", include=include_url, parent=main_doc)
save(main_doc, main_file_path)
self.main_terminology_url = main_url
self.temp_dir_base = tmp_name
def test_reorder(self):
# Test reorder of document sections
doc = Document()
sec_one = Section(name="sec_one", parent=doc)
sec_two = Section(name="sec_two", parent=doc)
sec_three = Section(name="sec_three", parent=doc)
self.assertEqual(doc.sections[0].name, sec_one.name)
self.assertEqual(doc.sections[2].name, sec_three.name)
sec_three.reorder(0)
self.assertEqual(doc.sections[0].name, sec_three.name)
self.assertEqual(doc.sections[2].name, sec_two.name)
# Test reorder of document sections
sec = Section(name="main")
sec_one = Section(name="sec_one", parent=sec)
sec_two = Section(name="sec_two", parent=sec)
sec_three = Section(name="sec_three", parent=sec)
self.assertEqual(sec.sections[0].name, sec_one.name)
self.assertEqual(sec.sections[2].name, sec_three.name)
sec_three.reorder(0)
self.assertEqual(sec.sections[0].name, sec_three.name)
self.assertEqual(sec.sections[2].name, sec_two.name)
# Test Exception on unconnected section
with self.assertRaises(ValueError):
sec.reorder(0)
def handle_sub_container(helper, node, sec, sub_sec_type):
# We might need to handle the case, when a container holds
# only the content of one xml element and does not contain
# the content and attributes of this xml element as a sole
# list element but as many elements within an OrderedDict.
if isinstance(node[helper.section_name], list):
for (idx, title_node) in enumerate(node[helper.section_name]):
sec_name = "%s_%d" % (helper.section_name, idx + 1)
sub_sec = Section(name=sec_name, type=sub_sec_type, parent=sec)
helper.item_func(helper, title_node, sub_sec)
else:
sub_sec_name = "%s_1" % helper.section_name
sub_sec = Section(name=sub_sec_name, type=sub_sec_type, parent=sec)
helper.item_func(helper, node[helper.section_name], sub_sec)
def test_simple_attributes(self):
sec_name = "sec name"
sec_type = "sec type"
sec_def = "an odml test section"
sec_ref = "from over there"
sec = Section(name=sec_name, type=sec_type, definition=sec_def, reference=sec_ref)
self.assertEqual(sec.name, sec_name)
self.assertEqual(sec.type, sec_type)
self.assertEqual(sec.definition, sec_def)
self.assertEqual(sec.reference, sec_ref)
# Test setting attributes
sec.name = "%s_edit" % sec_name
self.assertEqual(sec.name, "%s_edit" % sec_name)
sec.type = "%s_edit" % sec_type
self.assertEqual(sec.type, "%s_edit" % sec_type)
sec.definition = "%s_edit" % sec_def
self.assertEqual(sec.definition, "%s_edit" % sec_def)
sec.reference = "%s_edit" % sec_ref
self.assertEqual(sec.reference, "%s_edit" % sec_ref)
# Test setting attributes to None when '' is passed.
sec.reference = ""
self.assertIsNone(sec.reference)
sec.definition = ""
self.assertIsNone(sec.definition)
def test_parent(self):
s = Section("Section")
self.assertIsNone(s.parent)
s.parent = None
self.assertIsNone(s.parent)
s.parent = Document()
self.assertIsInstance(s.parent, BaseDocument)
self.assertIsInstance(s.parent._sections[0], BaseSection)
""" Test if child is removed from _sections of a parent after assigning
a new parent to the child """
p = s.parent
s.parent = Section("S")
self.assertEqual(len(p._sections), 0)
s = Section("section_doc", parent=Document())
self.assertIsInstance(s.parent, BaseDocument)
self.assertEqual(len(s.parent._sections), 1)
p = s.parent
s.parent = None
self.assertEqual(len(p._sections), 0)
self.assertEqual(s.parent, None)
s = Section("section_sec", parent=Section("S"))
self.assertIsInstance(s.parent, BaseSection)
self.assertEqual(len(s.parent._sections), 1)
p = s.parent
s.parent = None
self.assertEqual(len(p._sections), 0)
self.assertEqual(s.parent, None)
with self.assertRaises(ValueError):
Section("section_property", parent=Property("P"))
def test_property(self):
"""
Test if a property and its attributes get converted correctly from rdf to odml.
"""
doc = Document()
sec1 = Section(name="sec1", type="test", parent=doc)
prop2 = Property(name="numbers",
definition="any number",
dtype="float",
parent=sec1,
values=[1, 3.4, 67.8, -12],
unit="meter",
uncertainty=0.8,
value_origin="force",
reference="Experiment 1")
rdf_writer = RDFWriter(doc).get_rdf_str()
rdf_reader = RDFReader().from_string(rdf_writer, "turtle")
prop = rdf_reader[0].sections[0].properties["numbers"]
self.assertEqual(prop.name, "numbers")
self.assertEqual(prop.dtype, "float")
self.assertEqual(prop.id, prop2.id)
self.assertEqual(prop.parent, rdf_reader[0].sections[0])
self.assertEqual(len(prop.values), 4)
self.assertEqual(prop.values, [1, 3.4, 67.8, -12])
self.assertEqual(prop.definition, "any number")
self.assertEqual(prop.unit, "meter")
self.assertEqual(prop.uncertainty, "0.8")
self.assertEqual(prop.value_origin, "force")
self.assertEqual(prop.reference, "Experiment 1")
def test_name(self):
# Test id is used when name is not provided
prop = Property()
self.assertIsNotNone(prop.name)
self.assertEqual(prop.name, prop.id)
# Test name is properly set on init
name = "rumpelstilzchen"
prop = Property(name)
self.assertEqual(prop.name, name)
# Test name can be properly set on single and connected Properties
prop = Property()
self.assertNotEqual(prop.name, "prop")
prop.name = "prop"
self.assertEqual(prop.name, "prop")
sec = Section()
prop_a = Property(parent=sec)
self.assertNotEqual(prop_a.name, "prop_a")
prop_a.name = "prop_a"
self.assertEqual(prop_a.name, "prop_a")
# Test property name can be changed with siblings
prop_b = Property(name="prop_b", parent=sec)
self.assertEqual(prop_b.name, "prop_b")
prop_b.name = "prop"
self.assertEqual(prop_b.name, "prop")
# Test property name set will fail on existing sibling with same name
with self.assertRaises(KeyError):
prop_b.name = "prop_a"
self.assertEqual(prop_b.name, "prop")
def test_reorder(self):
sec = Section()
prop_zero = Property(name="prop_zero", parent=sec)
prop_one = Property(name="prop_one", parent=sec)
prop_two = Property(name="prop_two", parent=sec)
prop_three = Property(name="prop_three", parent=sec)
self.assertEqual(sec.properties[0].name, prop_zero.name)
self.assertEqual(sec.properties[2].name, prop_two.name)
prop_two.reorder(0)
self.assertEqual(sec.properties[0].name, prop_two.name)
self.assertEqual(sec.properties[1].name, prop_zero.name)
self.assertEqual(sec.properties[2].name, prop_one.name)
self.assertEqual(sec.properties[3].name, prop_three.name)
prop_two.reorder(2)
self.assertEqual(sec.properties[0].name, prop_zero.name)
self.assertEqual(sec.properties[1].name, prop_one.name)
self.assertEqual(sec.properties[2].name, prop_two.name)
self.assertEqual(sec.properties[3].name, prop_three.name)
# Test Exception on unconnected property
prop = Property(name="main")
with self.assertRaises(ValueError):
prop.reorder(0)
def parse_datacite_dict(doc):
"""
:param doc: python dict containing datacite conform data to
be parsed.
"""
if not doc or "resource" not in doc:
msg = "Could not find root. "
msg += "Please escape any XML namespace using the '-n' command line option."
raise ParserException(msg)
datacite_root = doc["resource"]
if "identifier" not in datacite_root:
raise ParserException("Could not find identifier (DOI) node")
odml_doc = Document()
odml_doc.repository = "https://terminologies.g-node.org/v1.1/terminologies.xml"
odml_doc.date = date.today().isoformat()
root_sec = Section(name="DataCite", type="data_reference", parent=odml_doc)
supported_tags = setup_supported_tags()
for node_tag in datacite_root:
if node_tag in supported_tags:
helper = supported_tags[node_tag]
helper.func(helper, datacite_root[node_tag], root_sec)
else:
print("[Warning] Ignoring unsupported root node '%s'" % node_tag)
return odml_doc
def handle_sec(helper, node, root_sec):
if not node:
return
sec_type = "datacite/%s" % camel_to_snake(helper.section_name)
sec = Section(name=helper.section_name, type=sec_type, parent=root_sec)
handle_props(helper, node, sec)
def handle_container(helper, node, root_sec):
if not node or helper.section_name not in node:
return
sec_cont_type = "datacite/%s" % camel_to_snake(helper.container_name)
sub_sec_type = "datacite/%s" % camel_to_snake(helper.section_name)
sec = Section(name=helper.container_name, type=sec_cont_type, parent=root_sec)
handle_sub_container(helper, node, sec, sub_sec_type)
def test_get_path(self):
doc = Document()
sec = Section(name="parent", parent=doc)
# Check root path for a detached Property.
prop = Property(name="prop")
self.assertEqual("/", prop.get_path())
# Check absolute path of Property in a Document.
prop.parent = sec
self.assertEqual("/%s:%s" % (sec.name, prop.name), prop.get_path())
def handle_geo_entry(helper_list, node, sec, sub_sec_name, sub_sec_type):
sub_sec = Section(name=sub_sec_name, type=sub_sec_type, parent=sec)
for entry in node:
if entry in helper_list:
try:
Property(name=entry, dtype=DType.float,
values=node[entry], parent=sub_sec)
except ValueError:
print("[Warning] Skipping invalid '%s' value '%s'" %
(entry, node[entry]))
def test_parent(self):
p = Property("property_section", parent=Section("S"))
self.assertIsInstance(p.parent, BaseSection)
self.assertEqual(len(p.parent._props), 1)
""" Test if child is removed from _props of a parent after assigning
a new parent to the child """
prop_parent = p.parent
p.parent = Section("S1")
self.assertEqual(len(prop_parent._props), 0)
self.assertIsInstance(p.parent, BaseSection)
self.assertIsInstance(p.parent._props[0], BaseProperty)
prop_parent = p.parent
p.parent = None
self.assertIsNone(p.parent)
self.assertEqual(len(prop_parent._props), 0)
with self.assertRaises(ValueError):
Property("property_prop", parent=Property("P"))
with self.assertRaises(ValueError):
Property("property_doc", parent=Document())
def test_append(self):
doc = Document()
self.assertListEqual(doc.sections, [])
# Test append Section
sec = Section(name="sec_one")
doc.append(sec)
self.assertEqual(len(doc.sections), 1)
self.assertEqual(sec.parent, doc)
# Test fail on Section list or tuple append
with self.assertRaises(ValueError):
doc.append([Section(name="sec_two"), Section(name="sec_three")])
with self.assertRaises(ValueError):
doc.append((Section(name="sec_two"), Section(name="sec_three")))
self.assertEqual(len(doc.sections), 1)
# Test fail on unsupported value
with self.assertRaises(ValueError):
doc.append(Document())
with self.assertRaises(ValueError):
doc.append("Section")
with self.assertRaises(ValueError):
doc.append(Property(name="prop"))
# Test fail on same name entities
with self.assertRaises(KeyError):
doc.append(Section(name="sec_one"))
self.assertEqual(len(doc.sections), 1)
def test_create_property(self):
root = Section("root")
self.assertEqual(len(root.properties), 0)
name = "prop"
oid = "79b613eb-a256-46bf-84f6-207df465b8f7"
prop = root.create_property(name, oid=oid)
self.assertEqual(len(root.properties), 1)
self.assertEqual(prop.parent, root)
self.assertEqual(root.properties[name].oid, oid)
name = "test_values"
values = ["a", "b"]
prop = root.create_property(name, value=values)
self.assertEqual(len(root.properties), 2)
self.assertEqual(root.properties[name].values, values)
name = "test_dtype"
dtype = "str"
prop = root.create_property(name, dtype=dtype)
self.assertEqual(len(root.properties), 3)
self.assertEqual(root.properties[name].dtype, dtype)
name = "test_dtype_fail"
dtype = "I do not exist"
prop = root.create_property(name, dtype=dtype)
self.assertIsNone(prop.dtype)
def test_name(self):
# Test id is used when name is not provided
s = Section()
self.assertIsNotNone(s.name)
self.assertEqual(s.name, s.id)
# Test name is properly set on init
name = "rumpelstilzchen"
s = Section(name)
self.assertEqual(s.name, name)
name = "rumpelstilzchen"
s = Section(name=name)
self.assertEqual(s.name, name)
# Test name can be properly set on single and connected Sections
sec = Section()
self.assertNotEqual(sec.name, "sec")
sec.name = "sec"
self.assertEqual(sec.name, "sec")
subsec_a = Section(parent=sec)
self.assertNotEqual(subsec_a.name, "subsec_a")
subsec_a.name = "subsec_a"
self.assertEqual(subsec_a.name, "subsec_a")
# Test subsection name can be changed with siblings
subsec_b = Section(name="subsec_b", parent=sec)
self.assertEqual(subsec_b.name, "subsec_b")
subsec_b.name = "subsec"
self.assertEqual(subsec_b.name, "subsec")
# Test subsection name set will fail on existing sibling with same name
with self.assertRaises(KeyError):
subsec_b.name = "subsec_a"
self.assertEqual(subsec_b.name, "subsec")
# Test section name set will fail on existing same name document sibling
doc = Document()
sec_a = Section(name="a", parent=doc)
sec_b = Section(name="b", parent=doc)
with self.assertRaises(KeyError):
sec_b.name = "a"
def test_section(self):
"""
Test if a section and its attributes get converted correctly from rdf to odml.
"""
doc = Document()
sec1 = Section(name="sec1",
type="test",
parent=doc,
definition="Interesting stuff.",
reference="The Journal")
Section(name="sec2", type="test", parent=sec1)
rdf_writer = RDFWriter(doc).get_rdf_str()
rdf_reader = RDFReader().from_string(rdf_writer, "turtle")
self.assertEqual(rdf_reader[0].sections[0].name, "sec1")
self.assertEqual(rdf_reader[0].sections[0].type, "test")
self.assertEqual(rdf_reader[0].sections[0].id, sec1.id)
self.assertEqual(rdf_reader[0].sections[0].definition,
"Interesting stuff.")
self.assertEqual(rdf_reader[0].sections[0].reference, "The Journal")
self.assertEqual(rdf_reader[0].sections[0].parent, rdf_reader[0])
self.assertEqual(len(rdf_reader[0].sections[0].sections), 1)
def test_id(self):
s = Section(name="S")
self.assertIsNotNone(s.id)
s = Section("S", oid="79b613eb-a256-46bf-84f6-207df465b8f7")
self.assertEqual(s.id, "79b613eb-a256-46bf-84f6-207df465b8f7")
s = Section("S", oid="id")
self.assertNotEqual(s.id, "id")
# Make sure id cannot be reset programmatically.
with self.assertRaises(AttributeError):
s.id = "someId"
def test_new_id(self):
sec = Section(name="sec")
old_id = sec.id
# Test assign new generated id.
sec.new_id()
self.assertNotEqual(old_id, sec.id)
# Test assign new custom id.
old_id = sec.id
sec.new_id("79b613eb-a256-46bf-84f6-207df465b8f7")
self.assertNotEqual(old_id, sec.id)
self.assertEqual("79b613eb-a256-46bf-84f6-207df465b8f7", sec.id)
# Test invalid custom id exception.
with self.assertRaises(ValueError):
sec.new_id("crash and burn")
def test_clone(self):
sec = Section(name="parent")
# Check different id.
prop = Property(name="original")
clone_prop = prop.clone()
self.assertNotEqual(prop.id, clone_prop.id)
# Check parent removal in clone.
prop.parent = sec
clone_prop = prop.clone()
self.assertIsNotNone(prop.parent)
self.assertIsNone(clone_prop.parent)
# Check keep_id
prop = Property(name="keepid")
clone_prop = prop.clone(True)
self.assertEqual(prop.id, clone_prop.id)
def test_set_values_cardinality(self):
doc = Document()
sec = Section(name="sec", type="sec_type", parent=doc)
prop = Property(name="prop", val_cardinality=1, parent=sec)
# Test Property values cardinality min assignment
prop.set_values_cardinality(1)
self.assertEqual(prop.val_cardinality, (1, None))
# Test Property values cardinality keyword min assignment
prop.set_values_cardinality(min_val=2)
self.assertEqual(prop.val_cardinality, (2, None))
# Test Property values cardinality max assignment
prop.set_values_cardinality(None, 1)
self.assertEqual(prop.val_cardinality, (None, 1))
# Test Property values cardinality keyword max assignment
prop.set_values_cardinality(max_val=2)
self.assertEqual(prop.val_cardinality, (None, 2))
# Test Property values cardinality min max assignment
prop.set_values_cardinality(1, 2)
self.assertEqual(prop.val_cardinality, (1, 2))
# Test Property values cardinality keyword min max assignment
prop.set_values_cardinality(min_val=2, max_val=5)
self.assertEqual(prop.val_cardinality, (2, 5))
# Test Property values cardinality empty reset
prop.set_values_cardinality()
self.assertIsNone(prop.val_cardinality)
# Test Property values cardinality keyword empty reset
prop.set_values_cardinality(1)
self.assertIsNotNone(prop.val_cardinality)
prop.set_values_cardinality(min_val=None, max_val=None)
self.assertIsNone(prop.val_cardinality)
def handle_geo_locations(_, node, sec):
sub_type_base = "datacite/geo_location"
point_list = ["pointLongitude", "pointLatitude"]
box_list = ["westBoundLongitude", "eastBoundLongitude",
"southBoundLatitude", "northBoundLatitude"]
for elem in node:
if elem == "geoLocationPlace":
Property(name=elem, values=node[elem], parent=sec)
elif elem == "geoLocationPoint":
sec_type = "%s/%s" % (sub_type_base, camel_to_snake(elem))
handle_geo_entry(point_list, node[elem], sec, elem, sec_type)
elif elem == "geoLocationBox":
sec_type = "%s/%s" % (sub_type_base, camel_to_snake(elem))
handle_geo_entry(box_list, node[elem], sec, elem, sec_type)
elif elem == "geoLocationPolygon":
sub_type = "%s/%s" % (sub_type_base, camel_to_snake(elem))
sub_sec = Section(name=elem, type=sub_type, parent=sec)
for (idx, point) in enumerate(node[elem]["polygonPoint"]):
point_name = "polygonPoint_%d" % (idx + 1)
sec_type = "%s/%s" % (sub_type_base, camel_to_snake("polygonPoint"))
handle_geo_entry(point_list, point, sub_sec, point_name, sec_type)
def test_clone_keep_id(self):
# Check id kept in clone.
sec = Section(name="original")
clone_sec = sec.clone(keep_id=True)
self.assertEqual(sec, clone_sec)
self.assertEqual(sec.id, clone_sec.id)
# Check cloned child Sections keep their ids.
Section(name="sec_one", parent=sec)
Section(name="sec_two", parent=sec)
clone_sec = sec.clone(keep_id=True)
self.assertListEqual(sec.sections, clone_sec.sections)
self.assertEqual(sec.sections["sec_one"], clone_sec.sections["sec_one"])
self.assertEqual(sec.sections["sec_one"].id, clone_sec.sections["sec_one"].id)
# Check cloned child Properties keep their ids.
Property(name="prop_one", parent=sec)
Property(name="prop_two", parent=sec)
clone_sec = sec.clone(keep_id=True)
self.assertListEqual(sec.properties, clone_sec.properties)
self.assertEqual(sec.properties["prop_one"], clone_sec.properties["prop_one"])
self.assertEqual(sec.properties["prop_one"].id,
clone_sec.properties["prop_one"].id)
def test_clone(self):
# Check parent removal in clone.
psec = Section(name="parent")
sec = Section(name="original", parent=psec)
clone_sec = sec.clone()
self.assertEqual(sec.parent, psec)
self.assertIsNone(clone_sec.parent)
# Check new id in clone.
sec = Section(name="original")
clone_sec = sec.clone()
self.assertEqual(sec, clone_sec)
self.assertNotEqual(sec.id, clone_sec.id)
# Check child Sections and Properties are cloned and have new ids.
Section(name="sec_one", parent=sec)
Section(name="sec_two", parent=sec)
Property(name="prop_one", parent=sec)
Property(name="prop_two", parent=sec)
clone_sec = sec.clone()
# Check sections
self.assertListEqual(sec.sections, clone_sec.sections)
self.assertEqual(sec.sections["sec_one"], clone_sec.sections["sec_one"])
self.assertNotEqual(sec.sections["sec_one"].id, clone_sec.sections["sec_one"].id)
# Check properties
self.assertListEqual(sec.properties, clone_sec.properties)
self.assertEqual(sec.properties["prop_one"], clone_sec.properties["prop_one"])
self.assertNotEqual(sec.properties["prop_one"].id,
clone_sec.properties["prop_one"].id)
# Check child Sections and Properties are not cloned.
clone_sec = sec.clone(children=False)
self.assertListEqual(clone_sec.sections, [])
self.assertListEqual(clone_sec.properties, [])
def setUp(self):
self.root_section = Section("Type test", "test")
self.root_section.append(Section("sub_1", "sub_1"))
self.root_section.append(Section("sub_2", "sub_2"))
self.root_section.append(Section("sub_2_b", "sub_2"))
self.root_section.append(Section("sub_3", "sub_2/sub_3"))
class TestFindSections(unittest.TestCase):
def setUp(self):
self.root_section = Section("Type test", "test")
self.root_section.append(Section("sub_1", "sub_1"))
self.root_section.append(Section("sub_2", "sub_2"))
self.root_section.append(Section("sub_2_b", "sub_2"))
self.root_section.append(Section("sub_3", "sub_2/sub_3"))
def test_find_by_name(self):
ret = self.root_section.find("sub_1")
self.assertTrue(ret.name == "sub_1")
ret = self.root_section.find("unknown_type")
self.assertIsNone(ret)
def test_find_by_type(self):
ret = self.root_section.find(type="sub_1")
self.assertTrue(ret is not None and ret.type == "sub_1")
ret = self.root_section.find(type="sub_2", findAll=True)
self.assertTrue(len(ret) == 2)
ret = self.root_section.find(key=None,
type="sub_2",
findAll=True,
include_subtype=True)
self.assertTrue(len(ret) == 3)
def test_find_by_name_and_type(self):
ret = self.root_section.find(key="sub_1", type="sub_1")
self.assertTrue(ret.name == "sub_1")
ret = self.root_section.find(key="sub_1", type="sub_2")
self.assertIsNone(ret)
def test_path(self):
sec = Section(name="center")
self.assertEqual(sec.get_path(), "/")
subsec = Section(name="leaf", parent=sec)
self.assertEqual(subsec.get_path(), "/leaf")
doc = Document()
sec.parent = doc
self.assertEqual(sec.get_path(), "/center")
self.assertEqual(subsec.get_path(), "/center/leaf")
top = Section(name="top", parent=doc)
sec.parent = top
self.assertEqual(sec.get_path(), "/top/center")
self.assertEqual(subsec.get_path(), "/top/center/leaf")
subsec.parent = None
self.assertEqual(subsec.get_path(), "/")
class TestFindSections(unittest.TestCase):
def setUp(self):
self.root_section = Section("Type test", "test")
self.root_section.append(Section("sub_1", "sub_1"))
self.root_section.append(Section("sub_2", "sub_2"))
self.root_section.append(Section("sub_2_b", "sub_2"))
self.root_section.append(Section("sub_3", "sub_2/sub_3"))
def test_find_by_name(self):
ret = self.root_section.find("sub_1")
self.assertTrue(ret.name == "sub_1")
ret = self.root_section.find("unknown_type")
self.assertIsNone(ret)
def test_find_by_type(self):
ret = self.root_section.find(type="sub_1")
self.assertTrue(ret is not None and ret.type == "sub_1")
ret = self.root_section.find(type="sub_2", findAll=True)
self.assertTrue(len(ret) == 2)
ret = self.root_section.find(key=None, type="sub_2", findAll=True,
include_subtype=True)
self.assertTrue(len(ret) == 3)
def test_find_by_name_and_type(self):
ret = self.root_section.find(key="sub_1", type="sub_1")
self.assertTrue(ret.name == "sub_1")
ret = self.root_section.find(key="sub_1", type="sub_2")
self.assertIsNone(ret)
def test_comparison(self):
sec_name = "sec name"
sec_type = "sec type"
sec_def = "an odml test section"
sec_ref = "from over there"
sec_a = Section(name=sec_name, type=sec_type,
definition=sec_def, reference=sec_ref)
sec_b = Section(name=sec_name, type=sec_type,
definition=sec_def, reference=sec_ref)
self.assertEqual(sec_a, sec_b)
sec_b.name = "newSecName"
self.assertNotEqual(sec_a, sec_b)
sec_b.name = sec_name
# Test section equality with subsections
# Test equality with subsection of different entities
# with same content and same children order
subsec_aa = Section(name="subsecA", type=sec_type,
definition=sec_def, reference=sec_ref)
subsec_ab = Section(name="subsecB", type=sec_type,
definition=sec_def, reference=sec_ref)
subsec_ba = Section(name="subsecA", type=sec_type,
definition=sec_def, reference=sec_ref)
subsec_bb = Section(name="subsecB", type=sec_type,
definition=sec_def, reference=sec_ref)
sec_a.extend([subsec_aa, subsec_ab])
sec_b.extend([subsec_ba, subsec_bb])
self.assertEqual(sec_a, sec_b)
self.assertEqual(sec_a.sections, sec_b.sections)
sec_b.sections[0].name = "newSubsecA"
self.assertNotEqual(sec_a, sec_b)
self.assertNotEqual(sec_a.sections, sec_b.sections)
sec_b.sections[0].name = "subsecA"
# Test inequality with different number of children
sec_b.remove(sec_b.sections[1])
self.assertNotEqual(sec_a, sec_b)
self.assertNotEqual(sec_a.sections, sec_b.sections)
# Test equality with subsection of different entities
# with same content and different children order
sec_b.remove(sec_b.sections[0])
sec_b.extend([subsec_bb, subsec_ba])
self.assertEqual(sec_a, sec_b)
self.assertEqual(sec_a.sections, sec_b.sections)
sec_b.sections[0].name = "newSubsecB"
self.assertNotEqual(sec_a, sec_b)
self.assertNotEqual(sec_a.sections, sec_b.sections)
sec_b.sections[0].name = "subsecB"
# Test section equality with properties
# Test equality with properties of different entities
# with same content and same children order
prop_aa = Property(name="propA", definition="propDef")
prop_ab = Property(name="propB", definition="propDef")
prop_ba = Property(name="propA", definition="propDef")
prop_bb = Property(name="propB", definition="propDef")
sec_a.extend([prop_aa, prop_ab])
sec_b.extend([prop_ba, prop_bb])
self.assertEqual(sec_a, sec_b)
self.assertEqual(sec_a.properties, sec_b.properties)
sec_b.properties[0].name = "newPropA"
self.assertNotEqual(sec_a, sec_b)
self.assertNotEqual(sec_a.properties, sec_b.properties)
sec_b.properties[0].name = "propA"
# Test inequality with different number of children
sec_b.remove(sec_b.properties[1])
self.assertNotEqual(sec_a, sec_b)
self.assertNotEqual(sec_a.properties, sec_b.properties)
# Test equality with properties of different entities
# with same content and different children order
sec_b.remove(sec_b.properties[0])
sec_b.extend([prop_bb, prop_ba])
self.assertEqual(sec_a, sec_b)
self.assertEqual(sec_a.properties, sec_b.properties)
sec_b.properties[0].name = "newPropB"
self.assertNotEqual(sec_a, sec_b)
self.assertNotEqual(sec_a.properties, sec_b.properties)
def test_merge(self):
# -- Root level Section merge tests
source = Section(name="source", definition="def", reference="ref")
destination = Section(name="destination")
destination.merge(source)
self.assertEqual(destination.definition, source.definition)
self.assertEqual(destination.reference, source.reference)
# -- First child level Section merge tests
s_sec_one = Section(name="lvl", type="one", definition="def", parent=source)
s_sec_two = Section(name="other", type="one", parent=source)
d_sec_one = Section(name="lvl", type="one", parent=destination)
self.assertEqual(len(destination), 1)
self.assertIsNone(destination.sections["lvl"].definition)
self.assertIsNone(destination.sections["lvl"].reference)
destination.merge(source)
self.assertEqual(len(destination), 2)
self.assertEqual(destination.sections["lvl"].definition, s_sec_one.definition)
self.assertEqual(destination.sections["lvl"].reference, s_sec_one.reference)
self.assertEqual(destination.sections["other"], s_sec_two)
# -- Root level Property merge tests
source = Section(name="source")
destination = Section(name="destination")
s_prop_one = Property(name="prop_one", unit="Hz", parent=source)
s_prop_two = Property(name="prop_two", parent=source)
d_prop_one = Property(name="prop_one", parent=destination)
self.assertEqual(len(destination.properties), 1)
self.assertIsNone(destination.properties["prop_one"].unit)
destination.merge(source)
self.assertEqual(len(destination.properties), 2)
self.assertEqual(destination.properties["prop_one"].unit, s_prop_one.unit)
self.assertEqual(destination.properties["prop_two"], s_prop_two)
# -- First child level Property merge tests
source = Section(name="source")
destination = Section(name="destination")
s_sec_one = Section(name="lvl", type="one", definition="def", parent=source)
s_prop_one = Property(name="prop_one", unit="Hz", parent=s_sec_one)
s_prop_two = Property(name="prop_two", parent=s_sec_one)
d_sec_one = Section(name="lvl", type="one", parent=destination)
d_prop_one = Property(name="prop_one", parent=d_sec_one)
self.assertEqual(len(destination.properties), 0)
self.assertEqual(len(destination.sections["lvl"].properties), 1)
self.assertIsNone(destination.sections["lvl"].properties["prop_one"].unit)
destination.merge(source)
self.assertEqual(len(destination.properties), 0)
self.assertEqual(len(destination.sections["lvl"].properties), 2)
self.assertEqual(destination.sections["lvl"].properties["prop_one"].unit,
s_prop_one.unit)
self.assertEqual(destination.sections["lvl"].properties["prop_two"],
s_prop_two)
# -- Test nothing merged on second child level ValueError
source = Section(name="source", definition="def", reference="ref")
destination = Section(name="destination")
s_sec_one = Section(name="lvl", type="one", definition="def", parent=source)
s_sec_two = Section(name="other", type="one", parent=source)
d_sec_one = Section(name="lvl", type="one", parent=destination)
s_subprop_one = Property(name="prop", value=[1, 2, 3], parent=s_sec_one)
d_subprop_one = Property(name="prop", value=["four", "five"], parent=d_sec_one)
self.assertEqual(len(destination.sections), 1)
self.assertEqual(len(destination.sections["lvl"].properties), 1)
self.assertIsNone(destination.definition)
self.assertIsNone(destination.sections["lvl"].definition)
self.assertEqual(destination.sections["lvl"].properties[0].values,
d_subprop_one.values)
with self.assertRaises(ValueError):
destination.merge(source)
self.assertEqual(len(destination.sections), 1)
self.assertEqual(len(destination.sections["lvl"].properties), 1)
self.assertIsNone(destination.definition)
self.assertIsNone(destination.sections["lvl"].definition)
self.assertEqual(destination.sections["lvl"].properties[0].values,
d_subprop_one.values)
def test_merge_check(self):
# -- Root level Section checks
# Test empty Section check
source = Section(name="source")
destination = Section(name="destination")
destination.merge_check(source, True)
# Test definition check
source = Section(name="source", definition="def")
destination = Section(name="destination", definition="def")
destination.merge_check(source, True)
source.definition = "other def"
with self.assertRaises(ValueError):
destination.merge_check(source, True)
# Test reference check
source = Section(name="source", reference="ref")
destination = Section(name="destination", reference="ref")
destination.merge_check(source, True)
source.reference = "other ref"
with self.assertRaises(ValueError):
destination.merge_check(source, True)
# -- First child level Section checks
source = Section(name="source")
destination = Section(name="destination")
s_sec_one = Section(name="lvl", type="one",
reference="ref", definition="def", parent=source)
s_sec_two = Section(name="unrelated", type="one",
reference="one", definition="one", parent=source)
d_sec_one = Section(name="lvl", type="one",
reference="ref", definition="def", parent=destination)
d_sec_two = Section(name="unrelated", type="two",
reference="two", definition="two", parent=destination)
# Test Section child level definition check
destination.merge_check(source, True)
s_sec_one.definition = "other def"
with self.assertRaises(ValueError):
destination.merge_check(source, True)
# Test Section child level reference check
s_sec_one.definition = "def"
s_sec_one.reference = "other ref"
with self.assertRaises(ValueError):
destination.merge_check(source, True)
# -- Second child level Section checks
source = Section(name="source")
destination = Section(name="destination")
s_sec_one = Section(name="lvl", type="one",
reference="ref", definition="def", parent=source)
s_subsec_one = Section(name="lvl", type="two",
reference="ref2", definition="def2", parent=s_sec_one)
s_sec_two = Section(name="unrelated", type="one",
reference="one", definition="one", parent=source)
s_subsec_two = Section(name="lvl", type="two",
reference="none1", definition="none1", parent=s_sec_two)
d_sec_one = Section(name="lvl", type="one",
reference="ref", definition="def", parent=destination)
d_subsec_one = Section(name="lvl", type="two",
reference="ref2", definition="def2", parent=d_sec_one)
d_sec_two = Section(name="unrelated", type="two",
reference="two", definition="two", parent=destination)
d_subsec_two = Section(name="lvl", type="two",
reference="none2", definition="none2", parent=d_sec_two)
# Test Section 2nd child level definition check
# Check no definition/reference ValueError between s_subsec_two and d_subsec_one
# since their parents will not be merged.
destination.merge_check(source, True)
# Raise a definition ValueError between s_subsec_one and d_subsec_one
# since their parents will be merged.
s_subsec_one.definition = "other def"
with self.assertRaises(ValueError):
destination.merge_check(source, True)
# Test Section 2nd child level reference check
s_subsec_one.definition = "def2"
# Raise a reference ValueError between s_subsec_one and d_subsec_one
# since their parents will be merged.
s_subsec_one.reference = "other ref"
with self.assertRaises(ValueError):
destination.merge_check(source, True)
# -- Root level Property checks
# All Property checks will only test unit failure in the Section merge context.
# Other failures are covered by the specific Property merge check tests.
source = Section(name="source")
destination = Section(name="destination")
s_prop = Property(name="prop", parent=source)
d_prop = Property(name="prop", parent=destination)
destination.merge_check(source, True)
s_prop.unit = "Hz"
d_prop.unit = "s"
with self.assertRaises(ValueError):
destination.merge_check(source, True)
# -- First child level Property checks
source = Section(name="source")
destination = Section(name="destination")
s_prop_one = Property(name="lvl one", unit="Hz", parent=source)
s_prop_two = Property(name="unrelated one", unit="one", parent=source)
d_prop_one = Property(name="lvl one", unit="Hz", parent=destination)
d_prop_two = Property(name="unrelated two", unit="two", parent=destination)
# Test Property child level check
destination.merge_check(source, True)
# Test raise ValueError between s_prop_one and d_prop_one
s_prop_one.unit = "other unit"
with self.assertRaises(ValueError):
destination.merge_check(source, True)
# -- Second child level Property checks
source = Section(name="source")
destination = Section(name="destination")
s_sec_one = Section(name="lvl", type="one", parent=source)
s_subprop_one = Property(name="lvl one", unit="Hz", parent=s_sec_one)
s_sec_two = Section(name="unrelated", type="one", parent=source)
s_subprop_two = Property(name="unrelated one", unit="one", parent=s_sec_two)
d_sec_one = Section(name="lvl", type="one", parent=destination)
d_subprop_one = Property(name="lvl one", unit="Hz", parent=d_sec_one)
d_sec_two = Section(name="unrelated", type="two", parent=destination)
d_subprop_two = Property(name="unrelated one", unit="two", parent=d_sec_two)
# Test Property 2nd child level definition check
# Check no unit ValueError between s_subprop_two and d_subprop_one
# since their parents will not be merged.
destination.merge_check(source, True)
# Raise a unit ValueError between s_subprop_one and d_subprop_one
# since their parents will be merged.
s_subprop_one.unit = "other unit"
with self.assertRaises(ValueError):
destination.merge_check(source, True)
def test_contains(self):
sec = Section(name="root")
subsec = Section(name="subsec", type="test")
prop = Property(name="prop")
# Test not contains on empty child-lists.
self.assertIsNone(sec.contains(subsec))
self.assertIsNone(sec.contains(prop))
# Test contains of Section and Property
subsec.parent = sec
simisec = Section(name="subsec", type="test")
self.assertEqual(sec.contains(simisec).name, subsec.name)
prop.parent = sec
simiprop = Property(name="prop")
self.assertEqual(sec.contains(simiprop).name, prop.name)
# Test not contains on mismatching Section name/type and Property name
self.assertIsNone(sec.contains(Section(name="subsec", type="typetest")))
self.assertIsNone(sec.contains(Section(name="typesec", type="test")))
self.assertIsNone(sec.contains(Property(name="prop_two")))
# Test fail on non-Section/Property objects
with self.assertRaises(ValueError):
sec.contains(Document())
with self.assertRaises(ValueError):
sec.contains("some info")
def setUp(self):
"""
doc -- <section foo> -- <section subfoo>
\
-- <section bar> -- <section subbar>
"""
doc = Document("author")
foo = Section("foo", "footype")
doc.append(foo)
foo.append(Property("strprop", "somestring"))
foo.append(Property("txtprop", "some\ntext"))
subfoo = Section("subfoo", "footype")
foo.append(subfoo)
subfoo.append(Property("strprop", "somestring"))
subfoo.append(Property("txtprop", "some\ntext"))
bar = Section("bar", "bartype")
foo.append(bar)
bar.append(Property("strprop", "otherstring"))
bar.append(Property("txtprop", "other\ntext"))
subbar = Section("subbar", "bartype")
bar.append(subbar)
subbar.append(Property("strprop", "otherstring"))
subbar.append(Property("txtprop", "other\ntext"))
self.doc = doc
def test_read_write(self):
doc = Document("author")
sec = Section("name", "type")
doc.append(sec)
sec.append(Property("strprop", "somestring"))
sec.append(Property("txtprop", "some\ntext"))
sec.append(Property("intprop", 200))
sec.append(Property("floatprop", 2.00))
sec.append(Property("datetimeprop", dt.now()))
sec.append(Property("dateprop", dt.now().date()))
sec.append(Property("timeprop", dt.now().time()))
sec.append(Property("boolprop", True))
str_doc = unicode(XMLWriter(doc))
new_doc = XMLReader().fromString(str_doc)
new_sec = new_doc.sections[0]
v = new_sec.properties["strprop"].value
assert(v.dtype == "string")
assert(type(v.data) == unicode)
v = new_sec.properties["txtprop"].value
assert(v.dtype == "text")
assert(type(v.data) == unicode)
v = new_sec.properties["intprop"].value
assert(v.dtype == "int")
assert(type(v.data) == int)
v = new_sec.properties["floatprop"].value
assert(v.dtype == "float")
assert(type(v.data) == float)
v = new_sec.properties["datetimeprop"].value
assert(v.dtype == "datetime")
assert(type(v.data) == dt)
v = new_sec.properties["dateprop"].value
assert(v.dtype == "date")
assert(type(v.data) == date)
v = new_sec.properties["timeprop"].value
assert(v.dtype == "time")
assert(type(v.data) == time)
v = new_sec.properties["boolprop"].value
assert(v.dtype == "boolean")
assert(type(v.data) == bool)
def test_children(self):
sec = Section(name="sec")
# Test set sections
subsec = Section(name="subsec", parent=sec)
newsec = Section(name="newsec")
self.assertEqual(subsec.parent, sec)
self.assertEqual(sec.sections[0], subsec)
self.assertEqual(len(sec.sections), 1)
self.assertIsNone(newsec.parent)
sec.sections[0] = newsec
self.assertEqual(newsec.parent, sec)
self.assertEqual(sec.sections[0], newsec)
self.assertEqual(len(sec.sections), 1)
self.assertIsNone(subsec.parent)
# Test parent cleanup
root = Section(name="root")
sec.parent = root
subsec.parent = newsec
self.assertEqual(len(newsec.sections), 1)
self.assertEqual(newsec.sections[0], subsec)
self.assertEqual(subsec.parent, newsec)
self.assertEqual(len(root.sections), 1)
self.assertEqual(root.sections[0], sec)
subsec.parent = root
self.assertEqual(len(newsec.sections), 0)
self.assertEqual(subsec.parent, root)
self.assertEqual(len(root.sections), 2)
self.assertEqual(root.sections[1], subsec)
# Test set section fails
with self.assertRaises(ValueError):
sec.sections[0] = Document()
with self.assertRaises(ValueError):
sec.sections[0] = Property("fail")
with self.assertRaises(ValueError):
sec.sections[0] = "subsec"
# Test set properties
prop = Property(name="prop", parent=sec)
newprop = Property(name="newprop")
self.assertEqual(prop.parent, sec)
self.assertEqual(sec.properties[0], prop)
self.assertEqual(len(sec.properties), 1)
self.assertIsNone(newprop.parent)
sec.properties[0] = newprop
self.assertEqual(newprop.parent, sec)
self.assertEqual(sec.properties[0], newprop)
self.assertEqual(len(sec.properties), 1)
self.assertIsNone(prop.parent)
# Test set property fails
with self.assertRaises(ValueError):
sec.properties[0] = Document()
with self.assertRaises(ValueError):
sec.properties[0] = newsec
with self.assertRaises(ValueError):
sec.properties[0] = "prop"
# same tests with props alias
prop = Property(name="prop2", parent=sec)
newprop = Property(name="newprop2")
self.assertEqual(prop.parent, sec)
self.assertEqual(sec.props[1], prop)
self.assertEqual(len(sec.props), 2)
self.assertIsNone(newprop.parent)
sec.props[1] = newprop
self.assertEqual(newprop.parent, sec)
self.assertEqual(sec.props[1], newprop)
self.assertEqual(len(sec.props), 2)
self.assertIsNone(prop.parent)
# Test set property fails
with self.assertRaises(ValueError):
sec.props[1] = Document()
with self.assertRaises(ValueError):
sec.props[1] = newsec
with self.assertRaises(ValueError):
sec.props[1] = "prop2"
def test_extend(self):
sec = Section(name="main")
self.assertListEqual(sec.sections, [])
self.assertListEqual(sec.properties, [])
# Test extend with Section list
sec.extend([Section(name="sec1"), Section(name="sec2")])
self.assertEqual(len(sec), 2)
self.assertEqual(len(sec.sections), 2)
self.assertEqual(sec.sections[0].name, "sec1")
# Test extend with Property list
sec.extend((Property(name="prop1"), Property(name="prop2")))
self.assertEqual(len(sec), 4)
self.assertEqual(len(sec.properties), 2)
self.assertEqual(sec.properties[0].name, "prop1")
# Test extend with mixed list
sec.extend([Section(name="sec3"), Property(name="prop3")])
self.assertEqual(len(sec), 6)
self.assertEqual(len(sec.sections), 3)
self.assertEqual(len(sec.properties), 3)
# Test fail on non iterable
with self.assertRaises(TypeError):
sec.extend(1)
# Test fail on non Section/Property list entry
with self.assertRaises(ValueError):
sec.extend([Property(name="prop4"), 5])
# Test fail on same name entities
with self.assertRaises(KeyError):
sec.extend([Property(name="new"), Property(name="prop3")])
self.assertEqual(len(sec.properties), 3)
with self.assertRaises(KeyError):
sec.extend([Section(name="new"), Section(name="sec3")])
self.assertEqual(len(sec.sections), 3)
def test_append(self):
main = Section(name="main")
self.assertListEqual(main.sections, [])
self.assertListEqual(main.properties, [])
# Test append Section
sec = Section(name="sec1")
main.append(sec)
self.assertEqual(len(main.sections), 1)
self.assertEqual(sec.parent, main)
# Test fail on Section list or tuple append
with self.assertRaises(ValueError):
main.append([Section(name="sec2"), Section(name="sec3")])
with self.assertRaises(ValueError):
main.append((Section(name="sec2"), Section(name="sec3")))
self.assertEqual(len(main.sections), 1)
# Test append Property
prop = Property(name="prop")
main.append(prop)
self.assertEqual(len(main.properties), 1)
self.assertEqual(prop.parent, main)
# Test fail on Property list or tuple append
with self.assertRaises(ValueError):
main.append([Property(name="prop2"), Property(name="prop3")])
with self.assertRaises(ValueError):
main.append((Property(name="prop2"), Property(name="prop3")))
self.assertEqual(len(main.properties), 1)
# Test fail on unsupported value
with self.assertRaises(ValueError):
main.append(Document())
with self.assertRaises(ValueError):
main.append("Section")
# Test fail on same name entities
with self.assertRaises(KeyError):
main.append(Section(name="sec1"))
self.assertEqual(len(main.sections), 1)
with self.assertRaises(KeyError):
main.append(Property(name="prop"))
self.assertEqual(len(main.properties), 1)
def test_remove(self):
sec = Section(name="remsec")
ssec_one = Section(name="subsec_one", parent=sec)
ssec_two = Section(name="subsec_two", parent=sec)
self.assertEqual(len(sec.sections), 2)
self.assertIsNotNone(ssec_one.parent)
sec.remove(ssec_one)
self.assertEqual(len(sec.sections), 1)
self.assertEqual(sec.sections[0].name, ssec_two.name)
self.assertIsNone(ssec_one.parent)
with self.assertRaises(ValueError):
sec.remove(ssec_one)
self.assertEqual(len(sec.sections), 1)
prop_one = Property(name="prop_one", parent=sec)
prop_two = Property(name="prop_two", parent=sec)
self.assertEqual(len(sec.properties), 2)
self.assertIsNotNone(prop_one.parent)
sec.remove(prop_one)
self.assertEqual(len(sec.properties), 1)
self.assertEqual(sec.properties[0].name, prop_two.name)
self.assertIsNone(prop_one.parent)
with self.assertRaises(ValueError):
sec.remove(prop_one)
self.assertEqual(len(sec.properties), 1)
with self.assertRaises(ValueError):
sec.remove("prop_two")
def test_insert(self):
sec = Section(name="root")
_ = Section(name="subsec_one", parent=sec)
_ = Section(name="subsec_two", parent=sec)
subsec = Section(name="subsec_three")
self.assertNotEqual(sec.sections[1].name, subsec.name)
sec.insert(1, subsec)
self.assertEqual(len(sec.sections), 3)
self.assertEqual(sec.sections[1].name, subsec.name)
self.assertEqual(subsec.parent.name, sec.name)
_ = Property(name="prop_one", parent=sec)
_ = Property(name="prop_two", parent=sec)
prop = Property(name="prop_three")
self.assertNotEqual(sec.properties[1].name, prop.name)
sec.insert(1, prop)
self.assertEqual(len(sec.properties), 3)
self.assertEqual(sec.properties[1].name, prop.name)
self.assertEqual(prop.parent.name, sec.name)
# Test invalid object
with self.assertRaises(ValueError):
sec.insert(1, Document())
with self.assertRaises(ValueError):
sec.insert(1, "some info")
self.assertEqual(len(sec), 6)
# Test same name entries
with self.assertRaises(ValueError):
sec.insert(0, subsec)
with self.assertRaises(ValueError):
sec.insert(0, prop)
self.assertEqual(len(sec), 6)
def test_comparison(self):
doc_auth = "author"
doc_ver = "ver1.0"
doc_a = Document(author=doc_auth, version=doc_ver)
doc_b = Document(author=doc_auth, version=doc_ver)
self.assertEqual(doc_a, doc_b)
doc_b.author = "someone else"
self.assertNotEqual(doc_a, doc_b)
doc_b.author = doc_auth
# Test section equality with subsections
# Test equality with subsection of different entities
# with same content and same children order
sec_type = "sec type"
sec_def = "an odml test section"
sec_ref = "from over there"
subsec_aa = Section(name="subsecA",
type=sec_type,
definition=sec_def,
reference=sec_ref)
subsec_ab = Section(name="subsecB",
type=sec_type,
definition=sec_def,
reference=sec_ref)
subsec_ba = Section(name="subsecA",
type=sec_type,
definition=sec_def,
reference=sec_ref)
subsec_bb = Section(name="subsecB",
type=sec_type,
definition=sec_def,
reference=sec_ref)
doc_a.extend([subsec_aa, subsec_ab])
doc_b.extend([subsec_ba, subsec_bb])
self.assertEqual(doc_a, doc_b)
self.assertEqual(doc_a.sections, doc_b.sections)
doc_b.sections[0].name = "newSubsecA"
self.assertNotEqual(doc_a, doc_b)
self.assertNotEqual(doc_a.sections, doc_b.sections)
doc_b.sections[0].name = "subsecA"
# Test inequality with different number of children
doc_b.remove(doc_b.sections[1])
self.assertNotEqual(doc_a, doc_b)
self.assertNotEqual(doc_a.sections, doc_b.sections)
# Test equality with subsection of different entities
# with same content and different children order
doc_b.remove(doc_b.sections[0])
doc_b.extend([subsec_bb, subsec_ba])
self.assertEqual(doc_a, doc_b)
self.assertEqual(doc_a.sections, doc_b.sections)
doc_b.sections[0].name = "newSubsecB"
self.assertNotEqual(doc_a, doc_b)
self.assertNotEqual(doc_a.sections, doc_b.sections)
doc_b.sections[0].name = "subsecB"
# Test section equality with properties
# Test equality with properties of different entities
# with same content and same children order
prop_aa = Property(name="propA", definition="propDef")
prop_ab = Property(name="propB", definition="propDef")
prop_ba = Property(name="propA", definition="propDef")
prop_bb = Property(name="propB", definition="propDef")
doc_a.sections["subsecA"].extend([prop_aa, prop_ab])
doc_b.sections["subsecA"].extend([prop_ba, prop_bb])
self.assertEqual(doc_a, doc_b)
doc_b.sections["subsecA"].properties[0].name = "newPropA"
self.assertNotEqual(doc_a, doc_b)
doc_b.sections["subsecA"].properties[0].name = "propA"
# Test inequality with different number of children
doc_b.sections["subsecA"].remove(
doc_b.sections["subsecA"].properties[1])
self.assertNotEqual(doc_a, doc_b)
# Test equality with properties of different entities
# with same content and different children order
doc_b.sections["subsecA"].remove(
doc_b.sections["subsecA"].properties[0])
doc_b.sections["subsecA"].extend([prop_bb, prop_ba])
self.assertEqual(doc_a, doc_b)
doc_b.sections["subsecA"].properties[0].name = "newPropB"
self.assertNotEqual(doc_a, doc_b)
def setUp(self):
self.root_section = Section("Type test", "test")
self.root_section.append(Section("sub_1", "sub_1"))
self.root_section.append(Section("sub_2", "sub_2"))
self.root_section.append(Section("sub_2_b", "sub_2"))
self.root_section.append(Section("sub_3", "sub_2/sub_3"))