bsfs changes propagated to tests

7 files changed, 28 insertions, 28 deletions

diff --git a/.gitignore b/.gitignore
index 8e1df10..304ae08 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,6 +23,6 @@ build/
 doc/build/
 
 # testing data
-test/reader/image/testimage.nef
+test/reader/image/testimage.nef*
 
 ## EOF ##
diff --git a/test/extractor/generic/test_constant.py b/test/extractor/generic/test_constant.py
index a49345b..bde3805 100644
--- a/test/extractor/generic/test_constant.py
+++ b/test/extractor/generic/test_constant.py
@@ -36,19 +36,19 @@ class TestConstant(unittest.TestCase):
         node = _node.Node(ns.bsfs.Entity, '') # Blank node
         p_author = ext.schema.predicate(ns.bse.author)
         p_comment = ext.schema.predicate(ns.bse.comment)
-        entity = ext.schema.node(ns.bsfs.Node).get_child(ns.bsfs.Entity)
-        string = ext.schema.literal(ns.bsfs.Literal).get_child(ns.xsd.string)
+        entity = ext.schema.node(ns.bsfs.Node).child(ns.bsfs.Entity)
+        string = ext.schema.literal(ns.bsfs.Literal).child(ns.xsd.string)
         # baseline
         self.assertSetEqual(set(ext.extract(node, None, (p_author, p_comment))),
             {(node, p_author, 'Me, myself, and I'),
              (node, p_comment, 'the quick brown fox jumps over the lazy dog.')})
         # predicates is respected
-        p_foobar = ext.schema.predicate(ns.bsfs.Predicate).get_child(ns.bse.foobar, domain=entity, range=entity)
+        p_foobar = ext.schema.predicate(ns.bsfs.Predicate).child(ns.bse.foobar, domain=entity, range=entity)
         self.assertSetEqual(set(ext.extract(node, None, (p_author, p_foobar))),
             {(node, p_author, 'Me, myself, and I')})
         self.assertSetEqual(set(ext.extract(node, None, (p_comment, p_foobar))),
             {(node, p_comment, 'the quick brown fox jumps over the lazy dog.')})
-        p_barfoo = ext.schema.predicate(ns.bse.author).get_child(ns.bse.comment, domain=entity, range=string)
+        p_barfoo = ext.schema.predicate(ns.bse.author).child(ns.bse.comment, domain=entity, range=string)
         self.assertSetEqual(set(ext.extract(node, None, (p_foobar, p_barfoo))), set())
 
     def test_construct(self):
diff --git a/test/extractor/generic/test_path.py b/test/extractor/generic/test_path.py
index 778ac5a..ae68686 100644
--- a/test/extractor/generic/test_path.py
+++ b/test/extractor/generic/test_path.py
@@ -29,7 +29,7 @@ class TestPath(unittest.TestCase):
 
     def test_schema(self):
         self.assertEqual(Path().schema,
-            bsfs.schema.Schema.from_string(base.SCHEMA_PREAMBLE + '''
+            bsfs.schema.from_string(base.SCHEMA_PREAMBLE + '''
                 bse:filename rdfs:subClassOf bsfs:Predicate ;
                     rdfs:domain bsfs:File ;
                     rdfs:range xsd:string ;
@@ -41,19 +41,19 @@ class TestPath(unittest.TestCase):
         node = _node.Node(ns.bsfs.File, '') # Blank node
         content = '/tmp/foo/bar'
         p_filename = ext.schema.predicate(ns.bse.filename)
-        entity = ext.schema.node(ns.bsfs.Node).get_child(ns.bsfs.Entity)
-        string = ext.schema.literal(ns.bsfs.Literal).get_child(ns.xsd.string)
+        entity = ext.schema.node(ns.bsfs.Node).child(ns.bsfs.Entity)
+        string = ext.schema.literal(ns.bsfs.Literal).child(ns.xsd.string)
 
         # baseline
         self.assertSetEqual(set(ext.extract(node, content, (p_filename, ))),
             {(node, p_filename, 'bar')})
         # predicates parameter is respected
-        p_foo = ext.schema.predicate(ns.bsfs.Predicate).get_child(ns.bse.foo, domain=entity, range=string) # unsupported predicate
+        p_foo = ext.schema.predicate(ns.bsfs.Predicate).child(ns.bse.foo, domain=entity, range=string) # unsupported predicate
         self.assertSetEqual(set(ext.extract(node, content, (p_filename, p_foo))),
             {(node, p_filename, 'bar')})
         self.assertSetEqual(set(ext.extract(node, content, (p_foo, ))), set())
         # predicates are validated
-        p_bar = p_foo.get_child(ns.bse.filename) # same URI but different hierarchy
+        p_bar = p_foo.child(ns.bse.filename) # same URI but different hierarchy
         self.assertSetEqual(set(ext.extract(node, content, (p_filename, p_bar))),
             {(node, p_filename, 'bar')})
         self.assertSetEqual(set(ext.extract(node, content, (p_bar, ))), set())
diff --git a/test/extractor/generic/test_stat.py b/test/extractor/generic/test_stat.py
index ff74085..e5562d1 100644
--- a/test/extractor/generic/test_stat.py
+++ b/test/extractor/generic/test_stat.py
@@ -30,7 +30,7 @@ class TestStat(unittest.TestCase):
 
     def test_schema(self):
         self.assertEqual(Stat().schema,
-            bsfs.schema.Schema.from_string(base.SCHEMA_PREAMBLE + '''
+            bsfs.schema.from_string(base.SCHEMA_PREAMBLE + '''
                 bse:filesize rdfs:subClassOf bsfs:Predicate ;
                     rdfs:domain bsfs:File ;
                     rdfs:range xsd:integer ;
@@ -42,19 +42,19 @@ class TestStat(unittest.TestCase):
         node = _node.Node(ns.bsfs.File, '') # Blank node
         content = os.stat(__file__)
         p_filesize = ext.schema.predicate(ns.bse.filesize)
-        entity = ext.schema.node(ns.bsfs.Node).get_child(ns.bsfs.Entity)
-        string = ext.schema.literal(ns.bsfs.Literal).get_child(ns.xsd.string)
+        entity = ext.schema.node(ns.bsfs.Node).child(ns.bsfs.Entity)
+        string = ext.schema.literal(ns.bsfs.Literal).child(ns.xsd.string)
 
         # baseline
         self.assertSetEqual(set(ext.extract(node, content, (p_filesize, ))),
             {(node, p_filesize, content.st_size)})
         # predicates parameter is respected
-        p_foo = ext.schema.predicate(ns.bsfs.Predicate).get_child(ns.bse.foo, domain=entity, range=string) # unsupported predicate
+        p_foo = ext.schema.predicate(ns.bsfs.Predicate).child(ns.bse.foo, domain=entity, range=string) # unsupported predicate
         self.assertSetEqual(set(ext.extract(node, content, (p_filesize, p_foo))),
             {(node, p_filesize, content.st_size)})
         self.assertSetEqual(set(ext.extract(node, content, (p_foo, ))), set())
         # predicates are validated
-        p_bar = p_foo.get_child(ns.bse.filesizse) # same URI but different hierarchy
+        p_bar = p_foo.child(ns.bse.filesizse) # same URI but different hierarchy
         self.assertSetEqual(set(ext.extract(node, content, (p_filesize, p_bar))),
             {(node, p_filesize, content.st_size)})
         self.assertSetEqual(set(ext.extract(node, content, (p_bar, ))), set())
diff --git a/test/extractor/test_base.py b/test/extractor/test_base.py
index 6a63c59..acfaf58 100644
--- a/test/extractor/test_base.py
+++ b/test/extractor/test_base.py
@@ -18,7 +18,7 @@ from bsie.extractor import base
 
 class StubExtractor(base.Extractor):
     def __init__(self):
-        super().__init__(bsfs.schema.Schema.from_string(base.SCHEMA_PREAMBLE + '''
+        super().__init__(bsfs.schema.from_string(base.SCHEMA_PREAMBLE + '''
             bse:author rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:Entity ;
                 rdfs:range xsd:string ;
@@ -52,11 +52,11 @@ class TestExtractor(unittest.TestCase):
         self.assertNotEqual(hash(ext), hash(sub))
 
     def test_principals(self):
-        schema = bsfs.schema.Schema.Empty()
-        entity = schema.node(ns.bsfs.Node).get_child(ns.bsfs.Entity)
-        string = schema.literal(ns.bsfs.Literal).get_child(bsfs.URI('http://www.w3.org/2001/XMLSchema#string'))
-        p_author = schema.predicate(ns.bsfs.Predicate).get_child(ns.bse.author, domain=entity, range=string)
-        p_comment = schema.predicate(ns.bsfs.Predicate).get_child(ns.bse.comment, domain=entity, range=string)
+        schema = bsfs.schema.Schema()
+        entity = schema.node(ns.bsfs.Node).child(ns.bsfs.Entity)
+        string = schema.literal(ns.bsfs.Literal).child(bsfs.URI('http://www.w3.org/2001/XMLSchema#string'))
+        p_author = schema.predicate(ns.bsfs.Predicate).child(ns.bse.author, domain=entity, range=string)
+        p_comment = schema.predicate(ns.bsfs.Predicate).child(ns.bse.comment, domain=entity, range=string)
         ext = StubExtractor()
         self.assertSetEqual(set(ext.principals),
             {p_author, p_comment} | set(schema.predicates()) - {schema.predicate(ns.bsfs.Predicate)})
diff --git a/test/lib/test_bsie.py b/test/lib/test_bsie.py
index 52f1d44..38e6f59 100644
--- a/test/lib/test_bsie.py
+++ b/test/lib/test_bsie.py
@@ -52,7 +52,7 @@ class TestBSIE(unittest.TestCase):
             ns.bse.filesize,
             ns.bse.author,
             })
-        self.assertEqual(lib.schema, bsfs.schema.Schema.from_string(SCHEMA_PREAMBLE + '''
+        self.assertEqual(lib.schema, bsfs.schema.from_string(SCHEMA_PREAMBLE + '''
             bse:filename rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:File ;
                 rdfs:range xsd:string ;
@@ -79,7 +79,7 @@ class TestBSIE(unittest.TestCase):
             ns.bse.filesize,
             ns.bse.author,
             })
-        self.assertEqual(lib.schema, bsfs.schema.Schema.from_string(SCHEMA_PREAMBLE + '''
+        self.assertEqual(lib.schema, bsfs.schema.from_string(SCHEMA_PREAMBLE + '''
             bse:filesize rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:File ;
                 rdfs:range xsd:integer;
@@ -97,7 +97,7 @@ class TestBSIE(unittest.TestCase):
             ns.bse.filesize,
             ns.bse.author,
             })
-        self.assertEqual(lib.schema, bsfs.schema.Schema.from_string(SCHEMA_PREAMBLE + '''
+        self.assertEqual(lib.schema, bsfs.schema.from_string(SCHEMA_PREAMBLE + '''
             bse:filename rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:File ;
                 rdfs:range xsd:string ;
@@ -124,7 +124,7 @@ class TestBSIE(unittest.TestCase):
         self.assertSetEqual(set(lib.principals), {
             ns.bse.author,
             })
-        self.assertEqual(lib.schema, bsfs.schema.Schema.from_string(SCHEMA_PREAMBLE + '''
+        self.assertEqual(lib.schema, bsfs.schema.from_string(SCHEMA_PREAMBLE + '''
             bse:author rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:Entity ;
                 rdfs:range xsd:string ;
@@ -139,7 +139,7 @@ class TestBSIE(unittest.TestCase):
         self.assertSetEqual(set(lib.principals), {
             ns.bse.filesize,
             })
-        self.assertEqual(lib.schema, bsfs.schema.Schema.from_string(SCHEMA_PREAMBLE + '''
+        self.assertEqual(lib.schema, bsfs.schema.from_string(SCHEMA_PREAMBLE + '''
             bse:filesize rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:File ;
                 rdfs:range xsd:integer;
diff --git a/test/lib/test_pipeline.py b/test/lib/test_pipeline.py
index c6f7aba..8fecc74 100644
--- a/test/lib/test_pipeline.py
+++ b/test/lib/test_pipeline.py
@@ -74,7 +74,7 @@ class TestPipeline(unittest.TestCase):
 
         # equivalence respects schema
         p2 = Pipeline(self.prefix, self.ext2rdr)
-        p2._schema = pipeline.schema.Empty()
+        p2._schema = bsfs.schema.Schema()
         self.assertNotEqual(pipeline, p2)
         self.assertNotEqual(hash(pipeline), hash(p2))
 
@@ -100,7 +100,7 @@ class TestPipeline(unittest.TestCase):
         p_author = pipeline.schema.predicate(ns.bse.author)
         p_rating = pipeline.schema.predicate(ns.bse.rating)
         entity = pipeline.schema.node(ns.bsfs.File)
-        p_invalid = pipeline.schema.predicate(ns.bsfs.Predicate).get_child(ns.bse.foo, range=entity)
+        p_invalid = pipeline.schema.predicate(ns.bsfs.Predicate).child(ns.bse.foo, range=entity)
 
         # extract given predicates
         self.assertSetEqual(set(pipeline(testfile, {p_filename, p_filesize})), {