3 files changed, 841 insertions, 0 deletions
diff --git a/test/schema/__init__.py b/test/schema/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/schema/__init__.py
diff --git a/test/schema/test_schema.py b/test/schema/test_schema.py
new file mode 100644
index 0000000..2dc26e8
--- /dev/null
+++ b/test/schema/test_schema.py
@@ -0,0 +1,616 @@
+"""
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import operator
+import unittest
+
+# bsfs imports
+from bsfs.namespace import ns
+from bsfs.schema import types
+from bsfs.utils import errors
+
+# objects to test
+from bsfs.schema.schema import Schema
+
+
+## code ##
+
+class TestSchema(unittest.TestCase):
+
+    def setUp(self):
+        self.schema_str = '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+            bsfs:Tag rdfs:subClassOf bsfs:Node .
+            bsfs:Image rdfs:subClassOf bsfs:Entity .
+            bsfs:Unused rdfs:subClassOf bsfs:Node .
+
+            xsd:string rdfs:subClassOf bsfs:Literal .
+            xsd:integer rdfs:subClassOf bsfs:Literal .
+            xsd:boolean rdfs:subClassOf bsfs:Literal .
+
+            bse:tag rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Tag ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            bse:group rdfs:subClassOf bse:tag ;
+                rdfs:domain bsfs:Image ;
+                rdfs:range bsfs:Tag ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            bse:comment rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Node ;
+                rdfs:range xsd:string ;
+                bsfs:unique "true"^^xsd:boolean .
+
+            '''
+        # nodes
+        self.n_root = types.Node(ns.bsfs.Node, None)
+        self.n_ent = types.Node(ns.bsfs.Entity, types.Node(ns.bsfs.Node, None))
+        self.n_img = types.Node(ns.bsfs.Image, types.Node(ns.bsfs.Entity, types.Node(ns.bsfs.Node, None)))
+        self.n_tag = types.Node(ns.bsfs.Tag, types.Node(ns.bsfs.Node, None))
+        self.n_unused = types.Node(ns.bsfs.Unused, types.Node(ns.bsfs.Node, None))
+        self.nodes = [self.n_root, self.n_ent, self.n_img, self.n_tag, self.n_unused]
+
+        # literals
+        self.l_root = types.Literal(ns.bsfs.Literal, None)
+        self.l_string = types.Literal(ns.xsd.string, types.Literal(ns.bsfs.Literal, None))
+        self.l_integer = types.Literal(ns.xsd.integer, types.Literal(ns.bsfs.Literal, None))
+        self.l_unused = types.Literal(ns.xsd.boolean, types.Literal(ns.bsfs.Literal, None))
+        self.literals = [self.l_root, self.l_string, self.l_integer, self.l_unused]
+
+        # predicates
+        self.p_root = types.Predicate(ns.bsfs.Predicate, None, types.Node(ns.bsfs.Node, None), None, False)
+        self.p_tag = self.p_root.get_child(ns.bse.tag, self.n_ent, self.n_tag, False)
+        self.p_group = self.p_tag.get_child(ns.bse.group, self.n_img, self.n_tag, False)
+        self.p_comment = self.p_root.get_child(ns.bse.comment, self.n_root, self.l_string, True)
+        self.predicates = [self.p_root, self.p_tag, self.p_group, self.p_comment]
+
+    def test_construction(self):
+        # nodes and literals are optional
+        schema = Schema(self.predicates)
+        self.assertSetEqual(set(schema.nodes()), {self.n_root, self.n_ent, self.n_img, self.n_tag})
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string})
+        self.assertSetEqual(set(schema.predicates()), set(self.predicates))
+
+        # predicates, nodes, and literals are respected
+        schema = Schema(self.predicates, self.nodes, self.literals)
+        self.assertSetEqual(set(schema.nodes()), set(self.nodes))
+        self.assertSetEqual(set(schema.literals()), set(self.literals))
+        self.assertSetEqual(set(schema.predicates()), set(self.predicates))
+
+        # nodes are complete (w/o unused)
+        schema = Schema(self.predicates, None, self.literals)
+        self.assertSetEqual(set(schema.nodes()), {self.n_root, self.n_ent, self.n_img, self.n_tag})
+        schema = Schema(self.predicates, [], self.literals)
+        self.assertSetEqual(set(schema.nodes()), {self.n_root, self.n_ent, self.n_img, self.n_tag})
+        schema = Schema(self.predicates, [self.n_img, self.n_tag], self.literals)
+        self.assertSetEqual(set(schema.nodes()), {self.n_root, self.n_ent, self.n_img, self.n_tag})
+        schema = Schema(self.predicates, [self.n_unused], self.literals)
+        self.assertSetEqual(set(schema.nodes()), set(self.nodes))
+
+        # literals are complete
+        schema = Schema(self.predicates, self.nodes, None)
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string})
+        schema = Schema(self.predicates, self.nodes, [])
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string})
+        schema = Schema(self.predicates, self.nodes, [self.l_string])
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string})
+        schema = Schema(self.predicates, self.nodes, [self.l_integer])
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string, self.l_integer})
+        schema = Schema(self.predicates, self.nodes, [self.l_integer, self.l_unused])
+        self.assertSetEqual(set(schema.literals()), set(self.literals))
+
+        # predicates are complete
+        schema = Schema([], self.nodes, self.literals)
+        self.assertSetEqual(set(schema.predicates()), set())
+        schema = Schema([self.p_group], self.nodes, self.literals)
+        self.assertSetEqual(set(schema.predicates()), {self.p_root, self.p_tag, self.p_group})
+        schema = Schema([self.p_group, self.p_comment], self.nodes, self.literals)
+        self.assertSetEqual(set(schema.predicates()), set(self.predicates))
+
+        # node uris must be unique
+        self.assertRaises(errors.ConsistencyError, Schema, self.predicates,
+            self.nodes + [types.Node(ns.bsfs.Entity, None)], self.literals)
+        self.assertRaises(errors.ConsistencyError, Schema, self.predicates,
+            self.nodes + [types.Node(ns.bsfs.Entity, types.Node(ns.bsfs.Foo, None))], self.literals)
+        self.assertRaises(errors.ConsistencyError, Schema, self.predicates,
+            self.nodes + [types.Node(ns.bsfs.Entity, self.n_img)], self.literals)
+        self.assertRaises(errors.ConsistencyError, Schema, self.predicates,
+            [types.Node(ns.bsfs.Entity, self.n_img)], self.literals)
+
+        # literal uris must be unique
+        self.assertRaises(errors.ConsistencyError, Schema, self.predicates, self.nodes,
+            self.literals + [types.Literal(ns.xsd.string, None)])
+        self.assertRaises(errors.ConsistencyError, Schema, self.predicates, self.nodes,
+            self.literals + [types.Literal(ns.xsd.string, types.Literal(ns.bsfs.Foo, None))])
+        self.assertRaises(errors.ConsistencyError, Schema, self.predicates, self.nodes,
+            self.literals + [types.Literal(ns.xsd.string, self.l_integer)])
+        self.assertRaises(errors.ConsistencyError, Schema, self.predicates, self.nodes,
+            [types.Literal(ns.xsd.string, self.l_integer)])
+
+        # predicate uris must be unique
+        self.assertRaises(errors.ConsistencyError, Schema,
+            self.predicates + [types.Predicate(ns.bse.tag, self.p_root, self.n_root, self.n_tag, False)])
+        self.assertRaises(errors.ConsistencyError, Schema,
+            self.predicates + [types.Predicate(ns.bse.tag, self.p_root, self.n_ent, self.n_img, False)])
+        self.assertRaises(errors.ConsistencyError, Schema,
+            self.predicates + [types.Predicate(ns.bse.tag, self.p_root, self.n_ent, self.n_tag, True)])
+        self.assertRaises(errors.ConsistencyError, Schema,
+            self.predicates + [types.Predicate(ns.bse.tag, None, self.n_ent, self.n_tag, False)])
+
+        # uris must be unique across nodes, literals, and predicates
+        self.assertRaises(errors.ConsistencyError, Schema,
+            {}, {types.Node(ns.bsfs.Foo, None)}, {types.Node(ns.bsfs.Foo, None)})
+        self.assertRaises(errors.ConsistencyError, Schema,
+            {types.Predicate(ns.bsfs.Foo, None, types.Node(ns.bsfs.Node, None), None, False)}, {}, {types.Node(ns.bsfs.Foo, None)})
+        self.assertRaises(errors.ConsistencyError, Schema,
+            {types.Predicate(ns.bsfs.Foo, None, types.Node(ns.bsfs.Node, None), None, False)}, {types.Node(ns.bsfs.Foo, None)}, {})
+        self.assertRaises(errors.ConsistencyError, Schema,
+            {types.Predicate(ns.bsfs.Foo, None, types.Node(ns.bsfs.Node, None), None, False)}, {types.Node(ns.bsfs.Foo, None)}, {types.Node(ns.bsfs.Foo, None)})
+
+    def test_str(self):
+        self.assertEqual(str(Schema([])), 'Schema()')
+        self.assertEqual(str(Schema([], [], [])), 'Schema()')
+        self.assertEqual(str(Schema(self.predicates, self.nodes, self.literals)), 'Schema()')
+        self.assertEqual(repr(Schema([])), 'Schema([], [], [])')
+        self.assertEqual(repr(Schema([], [], [])), 'Schema([], [], [])')
+        n = [ns.bsfs.Entity, ns.bsfs.Image, ns.bsfs.Node, ns.bsfs.Tag, ns.bsfs.Unused]
+        l = [ns.bsfs.Literal, ns.xsd.boolean, ns.xsd.integer, ns.xsd.string]
+        p = [ns.bse.comment, ns.bse.group, ns.bse.tag, ns.bsfs.Predicate]
+        self.assertEqual(repr(Schema(self.predicates, self.nodes, self.literals)), f'Schema({n}, {l}, {p})')
+
+    def test_equality(self):
+        schema = Schema(self.predicates, self.nodes, self.literals)
+        # instance is equal to itself
+        self.assertEqual(schema, schema)
+        self.assertEqual(hash(schema), hash(schema))
+        # instance is equal to a clone
+        self.assertEqual(schema, Schema(self.predicates, self.nodes, self.literals))
+        self.assertEqual(hash(schema), hash(Schema(self.predicates, self.nodes, self.literals)))
+        # equality respects nodes
+        self.assertNotEqual(schema,
+            Schema(self.predicates, [self.n_root, self.n_ent, self.n_img, self.n_tag], self.literals))
+        self.assertNotEqual(hash(schema),
+            hash(Schema(self.predicates, [self.n_root, self.n_ent, self.n_img, self.n_tag], self.literals)))
+        self.assertNotEqual(schema,
+            Schema(self.predicates, self.nodes + [types.Node(ns.bsfs.Document, self.n_ent)], self.literals))
+        self.assertNotEqual(hash(schema),
+            hash(Schema(self.predicates, self.nodes + [types.Node(ns.bsfs.Document, self.n_ent)], self.literals)))
+        # equality respects literals
+        self.assertNotEqual(schema,
+            Schema(self.predicates, self.nodes, [self.l_root, self.l_string, self.l_integer]))
+        self.assertNotEqual(hash(schema),
+            hash(Schema(self.predicates, self.nodes, [self.l_root, self.l_string, self.l_integer])))
+        self.assertNotEqual(schema,
+            Schema(self.predicates, self.nodes, self.literals + [types.Literal(ns.xsd.number, self.l_root)]))
+        self.assertNotEqual(hash(schema),
+            hash(Schema(self.predicates, self.nodes, self.literals + [types.Literal(ns.xsd.number, self.l_root)])))
+        # equality respects predicates
+        self.assertNotEqual(schema,
+            Schema([self.p_group, self.p_tag, self.p_root], self.nodes, self.literals))
+        self.assertNotEqual(hash(schema),
+            hash(Schema([self.p_group, self.p_tag, self.p_root], self.nodes, self.literals)))
+        self.assertNotEqual(schema,
+            Schema(self.predicates + [self.p_root.get_child(ns.bse.filesize, self.n_ent, self.l_integer)], self.nodes, self.literals))
+        self.assertNotEqual(hash(schema),
+            hash(Schema(self.predicates + [self.p_root.get_child(ns.bse.filesize, self.n_ent, self.l_integer)], self.nodes, self.literals)))
+
+    def test_diff(self):
+        # difference can be empty
+        diff = Schema({self.p_tag}).diff(Schema({self.p_group}))
+        self.assertSetEqual(set(diff.nodes), set())
+        self.assertSetEqual(set(diff.literals), set())
+        self.assertSetEqual(set(diff.predicates), set())
+
+        # difference contains predicates from the LHS
+        diff = Schema({self.p_group}).diff(Schema({self.p_tag}))
+        self.assertSetEqual(set(diff.nodes), {self.n_img})
+        self.assertSetEqual(set(diff.literals), set())
+        self.assertSetEqual(set(diff.predicates), {self.p_group})
+
+        # difference does not contain predicates from the RHS
+        diff = Schema({self.p_tag, self.p_comment}).diff(Schema({self.p_group}))
+        self.assertSetEqual(set(diff.nodes), set())
+        self.assertSetEqual(set(diff.literals), {self.l_root, self.l_string})
+        self.assertSetEqual(set(diff.predicates), {self.p_comment})
+
+        # difference considers extra nodes and literals
+        diff = Schema({self.p_tag}, {self.n_unused}, {self.l_unused}).diff(Schema({self.p_tag}))
+        self.assertSetEqual(set(diff.nodes), {self.n_unused})
+        self.assertSetEqual(set(diff.literals), {self.l_root, self.l_unused})
+        self.assertSetEqual(set(diff.predicates), set())
+
+        # difference considers inconsistent types
+        diff = Schema({self.p_tag}, {self.n_unused}, {self.l_unused}).diff(
+            Schema({self.p_tag}, {types.Node(ns.bsfs.Unused, None)}, {types.Literal(ns.xsd.boolean, None)}))
+        self.assertSetEqual(set(diff.nodes), {self.n_unused})
+        self.assertSetEqual(set(diff.literals), {self.l_root, self.l_unused})
+        self.assertSetEqual(set(diff.predicates), set())
+
+        # __sub__ is an alias for diff
+        diff = Schema({self.p_comment}, {self.n_unused}, {self.l_unused}) - Schema({self.p_group})
+        self.assertSetEqual(set(diff.nodes), {self.n_unused})
+        self.assertSetEqual(set(diff.literals), {self.l_root, self.l_string, self.l_unused})
+        self.assertSetEqual(set(diff.predicates), {self.p_comment})
+        # __sub__ only accepts Schema instances
+        class Foo(): pass
+        self.assertRaises(TypeError, operator.sub, Schema({self.p_comment}, {self.n_unused}, {self.l_unused}), 1234)
+        self.assertRaises(TypeError, operator.sub, Schema({self.p_comment}, {self.n_unused}, {self.l_unused}), 'hello world')
+        self.assertRaises(TypeError, operator.sub, Schema({self.p_comment}, {self.n_unused}, {self.l_unused}), Foo())
+
+    def test_consistent_with(self):
+        # argument must be a schema
+        class Foo(): pass
+        self.assertRaises(TypeError, Schema([]).consistent_with, 1234)
+        self.assertRaises(TypeError, Schema([]).consistent_with, 'hello world')
+        self.assertRaises(TypeError, Schema([]).consistent_with, Foo())
+
+        # node consistency
+        self.assertTrue(Schema([], {self.n_ent, self.n_tag, self.n_unused}).consistent_with(
+            Schema(self.predicates)))
+        self.assertFalse(Schema([], {types.Node(ns.bsfs.Entity, None)}).consistent_with(
+            Schema(self.predicates)))
+        # order doesn't matter
+        self.assertTrue(Schema(self.predicates).consistent_with(
+            Schema([], {self.n_ent, self.n_tag, self.n_unused})))
+
+        # literal consistency
+        self.assertTrue(Schema([], [], {self.l_string, self.l_unused}).consistent_with(
+            Schema(self.predicates)))
+        self.assertFalse(Schema([], [], {types.Literal(ns.xsd.string, None)}).consistent_with(
+            Schema(self.predicates)))
+        # order doesn't matter
+        self.assertTrue(Schema(self.predicates).consistent_with(
+            Schema([], [], {self.l_string, self.l_unused})))
+
+        # predicate consistency
+        self.assertTrue(Schema({self.p_tag}).consistent_with(
+            Schema(self.predicates)))
+        self.assertFalse(Schema({types.Predicate(ns.bse.tag, None, self.n_root, self.n_root, False)}).consistent_with(
+            Schema(self.predicates)))
+        # order doesn't matter
+        self.assertTrue(Schema(self.predicates).consistent_with(
+            Schema({self.p_tag})))
+
+        # global consistency
+        self.assertFalse(Schema({types.Predicate(ns.bsfs.Entity, None, self.n_root, self.n_root, False)}).consistent_with(
+            Schema(self.predicates)))
+        self.assertFalse(Schema([], {types.Node(ns.xsd.string, None)}).consistent_with(
+            Schema(self.predicates)))
+        self.assertFalse(Schema([], [], {types.Literal(ns.bsfs.Entity, None)}).consistent_with(
+            Schema(self.predicates)))
+
+
+    def test_union(self):
+        # must provide at least one schema
+        self.assertRaises(TypeError, Schema.Union)
+
+        # can pass schemas as list
+        self.assertEqual(Schema.Union([Schema({self.p_tag})]), Schema({self.p_tag}))
+        self.assertEqual(Schema.Union([Schema({self.p_tag}), Schema({self.p_comment})]),
+            Schema({self.p_tag, self.p_comment}))
+
+        # can pass schemas as arguments
+        self.assertEqual(Schema.Union(Schema({self.p_tag})), Schema({self.p_tag}))
+        self.assertEqual(Schema.Union(Schema({self.p_tag}), Schema({self.p_comment})),
+            Schema({self.p_tag, self.p_comment}))
+
+        # cannot mix the two argument passing styles
+        self.assertRaises(TypeError, Schema.Union, [Schema(self.predicates)], Schema(self.predicates))
+
+        # all arguments must be Schema instances
+        self.assertRaises(TypeError, Schema.Union, Schema(self.predicates), 1234)
+        self.assertRaises(TypeError, Schema.Union, Schema(self.predicates), 1234, Schema(self.predicates))
+        self.assertRaises(TypeError, Schema.Union, Schema(self.predicates), 'hello world')
+
+        # Union merges predicates, nodes, and literals
+        self.assertEqual(Schema.Union(
+            Schema({self.p_comment}, {self.n_unused}, {}),
+            Schema({self.p_group}, {self.n_img}, {self.l_unused})),
+            Schema({self.p_comment, self.p_group}, {self.n_img, self.n_unused}, {self.l_unused}))
+
+        # Union does not accept inconsistent nodes
+        self.assertRaises(errors.ConsistencyError, Schema.Union, Schema(self.predicates),
+            Schema({}, {types.Node(ns.bsfs.Entity, None)}))
+        self.assertRaises(errors.ConsistencyError, Schema.Union, Schema({}, {self.n_ent}),
+            Schema({}, {types.Node(ns.bsfs.Entity, None)}))
+        self.assertRaises(errors.ConsistencyError, Schema.Union, Schema({}, {self.n_ent}),
+            Schema({}, {}, {types.Literal(ns.bsfs.Entity, None)}))
+
+        # Union does not accept inconsistent literals
+        self.assertRaises(errors.ConsistencyError, Schema.Union, Schema(self.predicates),
+            Schema({}, {}, {types.Literal(ns.xsd.string, None)}))
+        self.assertRaises(errors.ConsistencyError, Schema.Union, Schema({}, {}, {self.l_string}),
+            Schema({}, {}, {types.Literal(ns.xsd.string, None)}))
+        self.assertRaises(errors.ConsistencyError, Schema.Union, Schema({}, {}, {self.l_string}),
+            Schema({}, {types.Node(ns.xsd.string, None)}))
+
+        # Union does not accept inconsistent predicates
+        self.assertRaises(errors.ConsistencyError, Schema.Union, Schema({self.p_tag}),
+            Schema({types.Predicate(ns.bse.tag, None, self.n_ent, self.n_tag, False)}))
+        self.assertRaises(errors.ConsistencyError, Schema.Union, Schema({self.p_tag}),
+            Schema({}, {types.Node(ns.bse.tag, None)}))
+
+        # union is an alias for Union
+        self.assertEqual(Schema({self.p_comment}, {self.n_unused}, {}).union(
+            Schema({self.p_group}, {self.n_img}, {self.l_unused})),
+            Schema({self.p_comment, self.p_group}, {self.n_img, self.n_unused}, {self.l_unused}))
+        # union only accepts Schema instances
+        class Foo(): pass
+        self.assertRaises(TypeError, Schema({self.p_comment}, {self.n_unused}, {}).union, 1234)
+        self.assertRaises(TypeError, Schema({self.p_comment}, {self.n_unused}, {}).union, 'hello world')
+        self.assertRaises(TypeError, Schema({self.p_comment}, {self.n_unused}, {}).union, Foo())
+
+        # __add__ is an alias for Union
+        self.assertEqual(Schema({self.p_comment}, {self.n_unused}, {}) + Schema({self.p_group}, {self.n_img}, {self.l_unused}),
+            Schema({self.p_comment, self.p_group}, {self.n_img, self.n_unused}, {self.l_unused}))
+        # __add__ only accepts Schema instances
+        class Foo(): pass
+        self.assertRaises(TypeError, operator.add, Schema({self.p_comment}, {self.n_unused}, {}), 1234)
+        self.assertRaises(TypeError, operator.add, Schema({self.p_comment}, {self.n_unused}, {}), 'hello world')
+        self.assertRaises(TypeError, operator.add, Schema({self.p_comment}, {self.n_unused}, {}), Foo())
+
+        # __or__ is an alias for Union
+        self.assertEqual(Schema({self.p_comment}, {self.n_unused}, {}) | Schema({self.p_group}, {self.n_img}, {self.l_unused}),
+            Schema({self.p_comment, self.p_group}, {self.n_img, self.n_unused}, {self.l_unused}))
+        # __or__ only accepts Schema instances
+        class Foo(): pass
+        self.assertRaises(TypeError, operator.or_, Schema({self.p_comment}, {self.n_unused}, {}), 1234)
+        self.assertRaises(TypeError, operator.or_, Schema({self.p_comment}, {self.n_unused}, {}), 'hello world')
+        self.assertRaises(TypeError, operator.or_, Schema({self.p_comment}, {self.n_unused}, {}), Foo())
+
+    def test_type_getters(self):
+        schema = Schema(self.predicates, self.nodes, self.literals)
+        # nodes
+        self.assertEqual(self.n_root, schema.node(ns.bsfs.Node))
+        self.assertEqual(self.n_ent, schema.node(ns.bsfs.Entity))
+        self.assertEqual(self.n_img, schema.node(ns.bsfs.Image))
+        self.assertRaises(KeyError, schema.node, ns.bsfs.Document)
+        self.assertRaises(KeyError, schema.node, self.n_root)
+        # literals
+        self.assertEqual(self.l_root, schema.literal(ns.bsfs.Literal))
+        self.assertEqual(self.l_string, schema.literal(ns.xsd.string))
+        self.assertEqual(self.l_integer, schema.literal(ns.xsd.integer))
+        self.assertRaises(KeyError, schema.literal, ns.xsd.number)
+        self.assertRaises(KeyError, schema.literal, self.l_root)
+        # predicates
+        self.assertEqual(self.p_root, schema.predicate(ns.bsfs.Predicate))
+        self.assertEqual(self.p_tag, schema.predicate(ns.bse.tag))
+        self.assertEqual(self.p_group, schema.predicate(ns.bse.group))
+        self.assertRaises(KeyError, schema.predicate, ns.bse.mimetype)
+        self.assertRaises(KeyError, schema.predicate, self.p_root)
+
+    def test_list_getters(self):
+        schema = Schema(self.predicates, self.nodes, self.literals)
+        self.assertSetEqual(set(self.nodes), set(schema.nodes()))
+        self.assertSetEqual(set(self.literals), set(schema.literals()))
+        self.assertSetEqual(set(self.predicates), set(schema.predicates()))
+
+    def test_has(self):
+        schema = Schema(self.predicates, self.nodes, self.literals)
+        # nodes
+        self.assertTrue(schema.has_node(ns.bsfs.Node))
+        self.assertTrue(schema.has_node(ns.bsfs.Entity))
+        self.assertTrue(schema.has_node(ns.bsfs.Image))
+        self.assertFalse(schema.has_node(ns.bsfs.Document))
+        self.assertFalse(schema.has_node(self.n_root))
+        # literals
+        self.assertTrue(schema.has_literal(ns.bsfs.Literal))
+        self.assertTrue(schema.has_literal(ns.xsd.string))
+        self.assertTrue(schema.has_literal(ns.xsd.integer))
+        self.assertFalse(schema.has_literal(ns.xsd.number))
+        self.assertFalse(schema.has_literal(self.l_root))
+        # predicates
+        self.assertTrue(schema.has_predicate(ns.bsfs.Predicate))
+        self.assertTrue(schema.has_predicate(ns.bse.tag))
+        self.assertTrue(schema.has_predicate(ns.bse.group))
+        self.assertFalse(schema.has_predicate(ns.bse.mimetype))
+        self.assertFalse(schema.has_predicate(self.p_root))
+
+    def test_empty(self):
+        self.assertEqual(Schema.Empty(), Schema(
+            [types.Predicate(ns.bsfs.Predicate, None, types.Node(ns.bsfs.Node, None), None, False)],
+            [types.Node(ns.bsfs.Node, None)],
+            [types.Literal(ns.bsfs.Literal, None)],
+            ))
+
+    def test_from_string(self):
+        # from_string creates a schema
+        self.assertEqual(
+            Schema(self.predicates, self.nodes, self.literals),
+            Schema.from_string(self.schema_str))
+
+        # schema contains at least the root types
+        self.assertEqual(Schema.from_string(''), Schema({self.p_root}, {self.n_root}, {self.l_root}))
+
+        # custom example
+        self.assertEqual(
+            Schema({types.Predicate(ns.bsfs.Predicate, None, self.n_root, None, False).get_child(
+                ns.bse.filename, self.n_ent, self.l_string, False)}),
+            Schema.from_string('''
+                prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+                prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+                prefix bsfs: <http://bsfs.ai/schema/>
+                prefix bse: <http://bsfs.ai/schema/Entity#>
+
+                bsfs:Entity rdfs:subClassOf bsfs:Node .
+                xsd:string rdfs:subClassOf bsfs:Literal .
+
+                bse:filename rdfs:subClassOf bsfs:Predicate ;
+                    rdfs:domain bsfs:Entity ;
+                    rdfs:range xsd:string ;
+                    bsfs:unique "false"^^xsd:boolean .
+                '''))
+
+        # all nodes must be defined
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            xsd:string rdfs:subClassOf bsfs:Literal .
+
+            bse:filename rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                bsfs:unique "false"^^xsd:boolean .
+            ''')
+
+        # all literals must be defined
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+
+            bse:filename rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                bsfs:unique "false"^^xsd:boolean .
+            ''')
+
+        # must not have circular dependencies
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+            # ah, a nice circular dependency
+            bsfs:Entity rdfs:subClassOf bsfs:Document .
+            bsfs:Document rdfs:subClassOf bsfs:Entity .
+            bsfs:PDF rdfs:subClassOf bsfs:Document .
+            ''')
+
+        # range must be a node or literal
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+
+            bse:filename rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                bsfs:unique "false"^^xsd:boolean .
+            ''')
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+
+            bse:filename rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Foo ;
+                bsfs:unique "false"^^xsd:boolean .
+            ''')
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+
+            bse:filename rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Predicate ;
+                bsfs:unique "false"^^xsd:boolean .
+            ''')
+
+        # must be consistent
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+            bsfs:Document rdfs:subClassOf bsfs:Node .
+            bsfs:Document rdfs:subClassOf bsfs:Entity.
+            ''')
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+
+            xsd:string rdfs:subClassOf bsfs:Literal .
+            xsd:name rdfs:subClassOf bsfs:Literal .
+            xsd:name rdfs:subClassOf xsd:string .
+            ''')
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+
+            bse:foo rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Node ;
+                rdfs:range bsfs:Node ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            bse:foo rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity .
+
+            ''')
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+
+            bse:foo rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Node ;
+                rdfs:range bsfs:Node ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            bse:foo rdfs:subClassOf bsfs:Predicate ;
+                rdfs:range bsfs:Entity .
+
+            ''')
+        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+
+            bse:foo rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Node ;
+                rdfs:range bsfs:Node ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            bse:foo rdfs:subClassOf bsfs:Predicate ;
+                bsfs:unique "true"^^xsd:boolean .
+
+            ''')
+
+
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
diff --git a/test/schema/test_types.py b/test/schema/test_types.py
new file mode 100644
index 0000000..4a49e6e
--- /dev/null
+++ b/test/schema/test_types.py
@@ -0,0 +1,225 @@
+"""
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import operator
+import unittest
+
+# bsfs imports
+from bsfs.namespace import ns
+from bsfs.utils import errors
+
+# objects to test
+from bsfs.schema.types import _Type, _Vertex, Node, Literal, Predicate
+
+
+## code ##
+
+class TestType(unittest.TestCase):
+    def test_parents(self):
+        # create some types
+        fst = _Type('First')
+        snd = _Type('Second', fst)
+        trd = _Type('Third', snd)
+        frd = _Type('Fourth', trd)
+        # check parents
+        self.assertListEqual(list(fst.parents()), [])
+        self.assertListEqual(list(snd.parents()), [fst])
+        self.assertListEqual(list(trd.parents()), [snd, fst])
+        self.assertListEqual(list(frd.parents()), [trd, snd, fst])
+
+    def test_essentials(self):
+        # type w/o parent
+        self.assertEqual(str(_Type('Foo')), '_Type(Foo)')
+        self.assertEqual(repr(_Type('Foo')), '_Type(Foo, None)')
+        # type w/ parent
+        self.assertEqual(str(_Type('Foo', _Type('Bar'))), '_Type(Foo)')
+        self.assertEqual(repr(_Type('Foo', _Type('Bar'))), '_Type(Foo, _Type(Bar, None))')
+        # subtype w/o parent
+        class SubType(_Type): pass
+        self.assertEqual(str(SubType('Foo')), 'SubType(Foo)')
+        self.assertEqual(repr(SubType('Foo')), 'SubType(Foo, None)')
+        # subtype w/ parent
+        self.assertEqual(str(SubType('Foo', SubType('Bar'))), 'SubType(Foo)')
+        self.assertEqual(repr(SubType('Foo', SubType('Bar'))), 'SubType(Foo, SubType(Bar, None))')
+        # subtype and type mixed
+        self.assertEqual(str(SubType('Foo', _Type('Bar'))), 'SubType(Foo)')
+        self.assertEqual(repr(SubType('Foo', _Type('Bar'))), 'SubType(Foo, _Type(Bar, None))')
+        self.assertEqual(str(_Type('Foo', SubType('Bar'))), '_Type(Foo)')
+        self.assertEqual(repr(_Type('Foo', SubType('Bar'))), '_Type(Foo, SubType(Bar, None))')
+
+    def test_get_child(self):
+        # callee is used as parent
+        self.assertEqual(_Type('First').get_child('Second'), _Type('Second', _Type('First')))
+        # works with multiple parents
+        self.assertEqual(_Type('First').get_child('Second').get_child('Third'), _Type('Third', _Type('Second', _Type('First'))))
+        # type persists
+        class Foo(_Type): pass
+        self.assertEqual(Foo('First').get_child('Second'), Foo('Second', Foo('First')))
+
+    def test_equality(self):
+        # equality depends on uri
+        self.assertEqual(_Type('Foo'), _Type('Foo'))
+        self.assertEqual(hash(_Type('Foo')), hash(_Type('Foo')))
+        self.assertNotEqual(_Type('Foo'), _Type('Bar'))
+        self.assertNotEqual(hash(_Type('Foo')), hash(_Type('Bar')))
+        # comparison is case-sensitive
+        self.assertNotEqual(_Type('FOO'), _Type('foo'))
+        self.assertNotEqual(hash(_Type('FOO')), hash(_Type('foo')))
+        # comparison respects type
+        class Foo(_Type): pass
+        self.assertNotEqual(_Type('Foo'), Foo('Foo'))
+        self.assertNotEqual(hash(_Type('Foo')), hash(Foo('Foo')))
+        # comparison respects parent
+        self.assertNotEqual(_Type('Foo', _Type('Bar')), _Type('Foo'))
+        self.assertNotEqual(hash(_Type('Foo', _Type('Bar'))), hash(_Type('Foo')))
+
+    def test_order(self):
+        # create some types.
+        vehicle = _Type('Vehicle')
+        twowheel = _Type('Two-wheel', vehicle)
+        bike = _Type('Bike', twowheel)
+        bicycle = _Type('Bicycle', twowheel)
+        # two-wheel is equivalent to itself
+        self.assertFalse(twowheel == vehicle)
+        self.assertTrue(twowheel == twowheel)
+        self.assertFalse(twowheel == bicycle)
+        # two-wheel is a true subclass of Vehicle
+        self.assertTrue(twowheel < vehicle)
+        self.assertFalse(twowheel < twowheel)
+        self.assertFalse(twowheel < bicycle)
+        # two-wheel is a subclass of itself and Vehicle
+        self.assertTrue(twowheel <= vehicle)
+        self.assertTrue(twowheel <= twowheel)
+        self.assertFalse(twowheel <= bicycle)
+        # two-wheel is a true superclass of Bicycle
+        self.assertFalse(twowheel > vehicle)
+        self.assertFalse(twowheel > twowheel)
+        self.assertTrue(twowheel > bicycle)
+        # two-wheel is a superclass of itself and Bicycle
+        self.assertFalse(twowheel >= vehicle)
+        self.assertTrue(twowheel >= twowheel)
+        self.assertTrue(twowheel >= bicycle)
+        # analoguous to sets, this is not a total order
+        self.assertFalse(bike <= bicycle)
+        self.assertFalse(bike < bicycle)
+        self.assertFalse(bike > bicycle)
+        self.assertFalse(bike >= bicycle)
+        self.assertFalse(bike == bicycle)
+        class Foo(_Type): pass
+        foo = Foo(bike.uri, bike.parent)
+        # cannot compare different types
+        self.assertRaises(TypeError, operator.lt, foo, bike)
+        self.assertRaises(TypeError, operator.le, foo, bike)
+        self.assertRaises(TypeError, operator.gt, foo, bike)
+        self.assertRaises(TypeError, operator.ge, foo, bike)
+        # goes both ways
+        self.assertRaises(TypeError, operator.lt, bike, foo)
+        self.assertRaises(TypeError, operator.le, bike, foo)
+        self.assertRaises(TypeError, operator.gt, bike, foo)
+        self.assertRaises(TypeError, operator.ge, bike, foo)
+
+class TestPredicate(unittest.TestCase):
+    def test_construction(self):
+        # domain must be a node
+        self.assertRaises(TypeError, Predicate, ns.bse.foo, 1234, None, True)
+        self.assertRaises(TypeError, Predicate, ns.bse.foo, None, Literal(ns.bsfs.Foo, None), None, True)
+        # range must be None, a Literal, or a Node
+        self.assertRaises(TypeError, Predicate, ns.bse.foo, None, Node(ns.bsfs.Node, None), 1234, True)
+        self.assertRaises(TypeError, Predicate, ns.bse.foo, None, Node(ns.bsfs.Node, None), _Vertex(ns.bsfs.Foo, None), True)
+        self.assertRaises(TypeError, Predicate, ns.bse.foo, None, Node(ns.bsfs.Node, None), _Type(ns.bsfs.Foo, None), True)
+        class Foo(): pass
+        self.assertRaises(TypeError, Predicate, ns.bse.foo, None, Node(ns.bsfs.Node, None), Foo(), True)
+
+    def test_equality(self):
+        n_root = Node(ns.bsfs.Node, None)
+        n_ent = Node(ns.bsfs.Entity, Node(ns.bsfs.Node, None))
+        n_tag = Node(ns.bsfs.Tag, Node(ns.bsfs.Tag, None))
+        root = Predicate(
+            uri=ns.bsfs.Predicate,
+            parent=None,
+            domain=n_root,
+            range=None,
+            unique=False,
+            )
+        # instance is equal to itself
+        self.assertEqual(root, root)
+        self.assertEqual(hash(root), hash(root))
+        # instance is equal to a clone
+        self.assertEqual(root, Predicate(ns.bsfs.Predicate, None, n_root, None, False))
+        self.assertEqual(hash(root), hash(Predicate(ns.bsfs.Predicate, None, n_root, None, False)))
+        # equality respects uri
+        self.assertNotEqual(root, Predicate(ns.bsfs.Alternative, None, n_root, None, False))
+        self.assertNotEqual(hash(root), hash(Predicate(ns.bsfs.Alternative, None, n_root, None, False)))
+        # equality respects parent
+        self.assertNotEqual(root, Predicate(ns.bsfs.Predicate, n_root, n_root, None, False))
+        self.assertNotEqual(hash(root), hash(Predicate(ns.bsfs.Predicate, n_root, n_root, None, False)))
+        # equality respects domain
+        self.assertNotEqual(root, Predicate(ns.bsfs.Predicate, None, n_ent, None, False))
+        self.assertNotEqual(hash(root), hash(Predicate(ns.bsfs.Predicate, None, n_ent, None, False)))
+        # equality respects range
+        self.assertNotEqual(root, Predicate(ns.bsfs.Predicate, None, n_root, n_root, False))
+        self.assertNotEqual(hash(root), hash(Predicate(ns.bsfs.Predicate, None, n_root, n_root, False)))
+        # equality respects unique
+        self.assertNotEqual(root, Predicate(ns.bsfs.Predicate, None, n_root, None, True))
+        self.assertNotEqual(hash(root), hash(Predicate(ns.bsfs.Predicate, None, n_root, None, True)))
+
+    def test_get_child(self):
+        n_root = Node(ns.bsfs.Node, None)
+        n_ent = Node(ns.bsfs.Entity, Node(ns.bsfs.Node, None))
+        n_tag = Node(ns.bsfs.Tag, Node(ns.bsfs.Tag, None))
+        root = Predicate(
+            uri=ns.bsfs.Predicate,
+            parent=None,
+            domain=n_root,
+            range=None,
+            unique=False,
+            )
+        tag = Predicate(
+            uri=ns.bsfs.Entity,
+            parent=root,
+            domain=n_ent,
+            range=n_tag,
+            unique=False,
+            )
+
+        # uri is respected
+        self.assertEqual(ns.bse.foo, tag.get_child(ns.bse.foo).uri)
+        # domain is respected
+        dom = Node(ns.bsfs.Image, n_ent)
+        self.assertEqual(dom, tag.get_child(ns.bse.foo, domain=dom).domain)
+        # range is respected
+        rng = Node(ns.bsfs.Group, n_tag)
+        self.assertEqual(rng, tag.get_child(ns.bse.foo, range=rng).range)
+        # cannot set range to None
+        self.assertEqual(n_tag, tag.get_child(ns.bse.foo, range=None).range)
+        # unique is respected
+        self.assertTrue(tag.get_child(ns.bse.foo, unique=True).unique)
+
+        # domain is inherited from parent
+        self.assertEqual(n_ent, tag.get_child(ns.bse.foo).domain)
+        # range is inherited from parent
+        self.assertEqual(n_tag, tag.get_child(ns.bse.foo).range)
+        # uniqueness is inherited from parent
+        self.assertFalse(tag.get_child(ns.bse.foo).unique)
+
+        # domain must be subtype of parent's domain
+        self.assertRaises(errors.ConsistencyError, tag.get_child, ns.bse.foo, domain=n_root)
+        self.assertRaises(errors.ConsistencyError, tag.get_child, ns.bse.foo, domain=Node(ns.bsfs.Image, n_root))
+        # range cannot be None
+        self.assertRaises(ValueError, root.get_child, ns.bse.foo)
+        # range must be subtype of parent's range
+        self.assertRaises(errors.ConsistencyError, tag.get_child, ns.bse.foo, range=n_root)
+        self.assertRaises(errors.ConsistencyError, tag.get_child, ns.bse.foo, range=Node(ns.bsfs.Image, n_root))
+
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
+