def test_object_count():
"""Test object_count"""
obj1 = o.object(p.identifier('x', 'y1', 'object'))
obj2 = o.object(p.identifier('x', 'y2', 'object'))
obj3 = o.object(p.identifier('x', 'y3', 'object'))
prem = p.premis(child_elements=[obj1, obj2, obj3])
assert o.object_count(prem) == 3
def test_find_object_by_id():
"""Test find_object_by_id"""
object1 = o.object(p.identifier('local', 'id1', 'object'))
object2 = o.object(p.identifier('local', 'id2', 'object'))
object3 = o.object(p.identifier('local', 'id3', 'object'))
xml = p.premis(child_elements=[object1, object2, object3])
obj = o.find_object_by_id(xml, 'id2')
assert p.parse_identifier_type_value(p.parse_identifier(obj)) == ('local',
'id2')
def test_contains_object():
"""Test contains_object"""
obj1 = o.object(p.identifier('x', 'y1', 'object'))
obj2 = o.object(p.identifier('x', 'y2', 'object'))
obj3 = o.object(p.identifier('x', 'y3', 'object'))
prem1 = p.premis(child_elements=[obj1, obj2, obj3])
prem2 = p.premis(child_elements=[obj1, obj2])
assert o.contains_object(obj3, prem1)
assert not o.contains_object(obj3, prem2)
def test_iter_elements():
"""Test iter_elements"""
obj1 = o.object(p.identifier('local', 'id01'), original_name='nimi1')
obj2 = o.object(p.identifier('local', 'id02'), original_name='nimi2')
obj3 = o.object(p.identifier('local', 'id03'), original_name='nimi3')
xml = p.premis(child_elements=[obj1, obj2, obj3])
i = 0
for name in p.iter_elements(xml, 'originalName'):
i = i + 1
assert name.text == 'nimi' + str(i)
assert i == 3
def test_objects_with_type():
"""Test objects_with_type"""
obj1 = o.object(p.identifier('x1', 'y1', 'object'))
obj2 = o.object(p.identifier('x1', 'y2', 'object'))
obj3 = o.object(p.identifier('x2', 'y3', 'object'))
filtered = o.objects_with_type([obj1, obj2, obj3], 'x1')
i = 0
for filt_el in filtered:
i = i + 1
(id_type, _) = p.parse_identifier_type_value(
p.parse_identifier(filt_el, 'object'), 'object')
assert id_type == 'x1'
assert i == 2
def test_iter_objects():
"""Test iter_objects"""
obj1 = o.object(p.identifier('x', 'y1', 'object'))
obj2 = o.object(p.identifier('x', 'y2', 'object'))
obj3 = o.object(p.identifier('x', 'y3', 'object'))
prem = p.premis(child_elements=[obj1, obj2, obj3])
iterator = o.iter_objects(prem)
i = 0
for iter_elem in iterator:
i = i + 1
(_, id_value) = p.parse_identifier_type_value(
p.parse_identifier(iter_elem, 'object'), 'object')
assert id_value == 'y' + six.text_type(i)
assert i == 3
def test_filter_objects():
"""Test filter_objects"""
obj1 = o.object(p.identifier('x', 'y1', 'object'))
obj2 = o.object(p.identifier('x', 'y2', 'object'))
obj3 = o.object(p.identifier('x', 'y3', 'object'))
prem1 = p.premis(child_elements=[obj1, obj2, obj3])
prem2 = p.premis(child_elements=[obj1, obj3])
filtered = o.filter_objects(o.iter_objects(prem1), prem2)
i = 0
for filt_el in filtered:
i = i + 1
(_, id_value) = p.parse_identifier_type_value(
p.parse_identifier(filt_el, 'object'), 'object')
assert id_value == 'y2'
assert i == 1
def test_object_order():
"""Test that elements in premis:object are ordered as intended."""
fixity = o.fixity('xxx', 'yyy')
oc = o.object_characteristics(child_elements=[fixity])
env = o.environment(child_elements=[])
obj1 = o.object(p.identifier('a', 'b'),
original_name='c',
child_elements=[env, oc])
xml1 = ('<premis:object xmlns:premis="info:lc/xmlns/premis-v2" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
'xsi:type="premis:file"><premis:objectIdentifier>'
'<premis:objectIdentifierType>a</premis:objectIdentifierType>'
'<premis:objectIdentifierValue>b</premis:objectIdentifierValue>'
'</premis:objectIdentifier><premis:objectCharacteristics '
'xmlns:premis="info:lc/xmlns/premis-v2"><premis:compositionLevel>'
'0</premis:compositionLevel><premis:fixity>'
'<premis:messageDigestAlgorithm>yyy'
'</premis:messageDigestAlgorithm>'
'<premis:messageDigest>xxx</premis:messageDigest>'
'</premis:fixity></premis:objectCharacteristics>'
'<premis:originalName>c</premis:originalName>'
'<premis:environment/></premis:object>')
assert u.compare_trees(obj1, ET.fromstring(xml1))
assert obj1[0].tag == '{info:lc/xmlns/premis-v2}objectIdentifier'
assert obj1[1].tag == '{info:lc/xmlns/premis-v2}objectCharacteristics'
assert obj1[2].tag == '{info:lc/xmlns/premis-v2}originalName'
assert obj1[3].tag == '{info:lc/xmlns/premis-v2}environment'
def test_environments_with_purpose():
"""Test the environments_with_purpose function. Only one
environment should be returned from the created test data
containing two environments.
"""
env = o.environment(child_elements=[
o.dependency(identifiers=[p.identifier('c', 'd', 'dependency')])
])
env2 = o.environment(
purposes=['a'],
child_elements=[
o.dependency(identifiers=[p.identifier('c', 'd', 'dependency')])
])
obj = o.object(p.identifier('x', 'y', 'object'),
child_elements=[env, env2])
xml = ('<premis:environment xmlns:premis="info:lc/xmlns/premis-v2" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
'<premis:environmentPurpose>a</premis:environmentPurpose>'
'<premis:dependency>'
'<premis:dependencyIdentifier><premis:dependencyIdentifierType>'
'c</premis:dependencyIdentifierType>'
'<premis:dependencyIdentifierValue>'
'd</premis:dependencyIdentifierValue></premis:dependencyIdentifier>'
'</premis:dependency></premis:environment>')
environments = o.iter_environments(obj)
penvs = o.environments_with_purpose(environments, purpose='a')
assert len(list(penvs)) == 1
for penv in penvs:
assert u.compare_trees(penv, ET.fromstring(xml))
def test_parse_format_registry():
"""Test parse_format"""
fd = o.format_registry('xxx', 'yyy')
form = o.format(child_elements=[fd])
oc = o.object_characteristics(child_elements=[form])
obj = o.object(p.identifier('x', 'y', 'object'), child_elements=[oc])
assert o.parse_format_registry(obj) == ('xxx', 'yyy')
def test_parse_format_noversion():
"""Test parse_format"""
fd = o.format_designation('xxx')
form = o.format(child_elements=[fd])
oc = o.object_characteristics(child_elements=[form])
obj = o.object(p.identifier('x', 'y', 'object'), child_elements=[oc])
assert o.parse_format(obj) == ('xxx', None)
def test_parse_identifier():
"""Test parse_identifier"""
obj = o.object(p.identifier('local', 'id01'))
object_id = (
'<premis:objectIdentifier xmlns:premis="info:lc/xmlns/premis-v2" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
'<premis:objectIdentifierType>local</premis:objectIdentifierType>'
'<premis:objectIdentifierValue>id01</premis:objectIdentifierValue>'
'</premis:objectIdentifier>')
assert u.compare_trees(p.parse_identifier(obj), ET.fromstring(object_id))
def test_object():
"""Test premis_premis"""
obj1 = o.object(p.identifier('a', 'b'), original_name='c')
obj2 = o.object(p.identifier('a', 'b'), representation=True)
xml1 = ('<premis:object xmlns:premis="info:lc/xmlns/premis-v2" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
'xsi:type="premis:file"><premis:objectIdentifier>'
'<premis:objectIdentifierType>a</premis:objectIdentifierType>'
'<premis:objectIdentifierValue>b</premis:objectIdentifierValue>'
'</premis:objectIdentifier><premis:originalName>c'
'</premis:originalName></premis:object>')
xml2 = ('<premis:object xmlns:premis="info:lc/xmlns/premis-v2" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
'xsi:type="premis:representation"><premis:objectIdentifier>'
'<premis:objectIdentifierType>a</premis:objectIdentifierType>'
'<premis:objectIdentifierValue>b</premis:objectIdentifierValue>'
'</premis:objectIdentifier></premis:object>')
assert u.compare_trees(obj1, ET.fromstring(xml1))
assert u.compare_trees(obj2, ET.fromstring(xml2))
def test_parse_relationship():
"""Test parse_relationship"""
rel = o.relationship('a', 'b', p.identifier('c', 'd'))
obj = o.object(p.identifier('x', 'y', 'object'), child_elements=[rel])
rel2 = o.parse_relationship(obj)
xml = ('<premis:relationship xmlns:premis="info:lc/xmlns/premis-v2" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
'<premis:relationshipType>a</premis:relationshipType>'
'<premis:relationshipSubType>b</premis:relationshipSubType>'
'<premis:relatedObjectIdentification>'
'<premis:relatedObjectIdentifierType>'
'c</premis:relatedObjectIdentifierType>'
'<premis:relatedObjectIdentifierValue>'
'd</premis:relatedObjectIdentifierValue>'
'</premis:relatedObjectIdentification></premis:relationship>')
assert u.compare_trees(rel2, ET.fromstring(xml))
def test_parse_dependency():
"""Test parse_dependency"""
env = o.environment(child_elements=[
o.dependency(
identifiers=[p.identifier('e', 'f', prefix='dependency')]),
o.dependency(identifiers=[p.identifier('c', 'd', prefix='dependency')])
])
obj = o.object(p.identifier('x', 'y', 'object'), child_elements=[env])
dep = o.parse_dependency(obj)
xml1 = ('<premis:dependency xmlns:premis="info:lc/xmlns/premis-v2" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
'<premis:dependencyIdentifier><premis:dependencyIdentifierType>'
'e</premis:dependencyIdentifierType>'
'<premis:dependencyIdentifierValue>'
'f</premis:dependencyIdentifierValue>'
'</premis:dependencyIdentifier>'
'</premis:dependency>')
xml2 = ('<premis:dependency xmlns:premis="info:lc/xmlns/premis-v2" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
'<premis:dependencyIdentifier><premis:dependencyIdentifierType>'
'c</premis:dependencyIdentifierType>'
'<premis:dependencyIdentifierValue>'
'd</premis:dependencyIdentifierValue>'
'</premis:dependencyIdentifier>'
'</premis:dependency>')
test_list = [xml1, xml2]
i = 0
for iter_depend in dep:
assert u.compare_trees(iter_depend, ET.fromstring(test_list[i]))
i += 1
def test_iter_environments():
"""Test the iter_environments function. Test asserts that the
environment was yielded from the created test data and that its
contents matches the expected premis XML.
"""
env = o.environment(child_elements=[
o.dependency(identifiers=[p.identifier('c', 'd', 'dependency')])
])
obj = o.object(p.identifier('x', 'y', 'object'), child_elements=[env])
xml = ('<premis:environment xmlns:premis="info:lc/xmlns/premis-v2" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
'<premis:dependency>'
'<premis:dependencyIdentifier><premis:dependencyIdentifierType>'
'c</premis:dependencyIdentifierType>'
'<premis:dependencyIdentifierValue>'
'd</premis:dependencyIdentifierValue></premis:dependencyIdentifier>'
'</premis:dependency></premis:environment>')
i = 0
for penv in o.iter_environments(obj):
i = i + 1
assert u.compare_trees(penv, ET.fromstring(xml))
assert i == 1
def test_parse_object_type():
"""Test parse_object_type"""
obj = o.object(p.identifier('x', 'y', 'object'), representation=True)
assert o.parse_object_type(obj).endswith('representation')
def test_iter_environments_empty():
"""Test that non-existing environment results in no elements being
yielded.
"""
obj = o.object(p.identifier('x', 'y', 'object'))
assert not list(o.iter_environments(obj))
def test_parse_fixity():
"""Test parse_fixity"""
fixity = o.fixity('xxx', 'yyy')
oc = o.object_characteristics(child_elements=[fixity])
obj = o.object(p.identifier('x', 'y', 'object'), child_elements=[oc])
assert o.parse_fixity(obj) == ('yyy', 'xxx')
def test_parse_original_name():
"""Test parse_original_name"""
obj = o.object(p.identifier('x', 'y', 'object'), original_name='aaa')
assert o.parse_original_name(obj) == 'aaa'
