Merge branch 'mb/tools' into develop

3 files changed, 163 insertions, 38 deletions

diff --git a/test/extractor/generic/test_constant.py b/test/extractor/generic/test_constant.py
index f3ab0a3..aa33fb4 100644
--- a/test/extractor/generic/test_constant.py
+++ b/test/extractor/generic/test_constant.py
@@ -20,39 +20,101 @@ from bsie.extractor.generic.constant import Constant
 class TestConstant(unittest.TestCase):
     def test_extract(self):
         schema = '''
-            bse:author a bsfs:Predicate ;
+            bse:author rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:Entity ;
                 rdfs:range xsd:string ;
                 owl:maxCardinality "1"^^xsd:number .
-
-            bse:comment a bsfs:Predicate ;
+            bse:comment rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:Entity ;
                 rdfs:range xsd:string ;
                 owl:maxCardinality "INF"^^xsd:number .
-
             '''
         tuples = [
             (ns.bse.author, 'Me, myself, and I'),
             (ns.bse.comment, 'the quick brown fox jumps over the lazy dog.'),
             ]
-        node = Node(ns.bsfs.Entity, '') # Blank node
-        predicates = (ns.bse.author, ns.bse.comment)
         ext = Constant(schema, tuples)
+        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)
         # baseline
-        self.assertSetEqual(set(ext.extract(node, None, predicates)),
-            {(node, pred, value) for pred, value in tuples})
+        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
-        self.assertSetEqual(set(ext.extract(node, None, (ns.bse.author, ns.bse.foobar))),
-            {(node, ns.bse.author, 'Me, myself, and I')})
-        self.assertSetEqual(set(ext.extract(node, None, (ns.bse.comment, ns.bse.foobar))),
-            {(node, ns.bse.comment, 'the quick brown fox jumps over the lazy dog.')})
-        self.assertSetEqual(set(ext.extract(node, None, (ns.bse.foobar, ns.bse.barfoo))), set())
-
-        # FIXME: should change!
-        # for now: no schema compliance
-        ext = Constant('', tuples)
-        self.assertSetEqual(set(ext.extract(node, None, predicates)),
-            {(node, pred, value) for pred, value in tuples})
+        p_foobar = ext.schema.predicate(ns.bsfs.Predicate).get_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)
+        self.assertSetEqual(set(ext.extract(node, None, (p_foobar, p_barfoo))), set())
+
+    def test_construct(self):
+        # schema compliance
+        schema = '''
+            bse:author rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                owl:maxCardinality "1"^^xsd:number .
+            bse:comment rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                owl:maxCardinality "INF"^^xsd:number .
+            '''
+        # can create a schema
+        self.assertIsInstance(Constant(schema, [
+            (ns.bse.author, 'Me, myself, and I'),
+            (ns.bse.comment, 'the quick brown fox jumps over the lazy dog.'),
+            ]), Constant)
+        # predicates are validated
+        self.assertRaises(KeyError, Constant, schema, [
+            (ns.bse.author, 'Me, myself, and I'),
+            (ns.bse.foobar, 'foobar!')])
+        # FIXME: values are validated
+        #class Foo(): pass # not string compatible
+        #self.assertRaises(ValueError, Constant, schema, [
+        #    (ns.bse.author, Foo())])
+
+    def test_eq(self):
+        schema_a = '''
+            bse:author rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                owl:maxCardinality "1"^^xsd:number .
+            '''
+        schema_b = '''
+            bse:comment rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                owl:maxCardinality "INF"^^xsd:number .
+            '''
+        tuples_a = [(ns.bse.author, 'Me, myself, and I')]
+        tuples_b = [(ns.bse.comment, 'the quick brown fox jumps over the lazy dog.') ]
+        # distinct instances, same data
+        self.assertEqual(
+            Constant(schema_a, tuples_a),
+            Constant(schema_a, tuples_a))
+        self.assertEqual(
+            hash(Constant(schema_a, tuples_a)),
+            hash(Constant(schema_a, tuples_a)))
+        # different data
+        self.assertNotEqual(
+            Constant(schema_a, tuples_a),
+            Constant(schema_b, tuples_b))
+        self.assertNotEqual(
+            hash(Constant(schema_a, tuples_a)),
+            hash(Constant(schema_b, tuples_b)))
+        # different objects
+        class Foo(): pass
+        self.assertNotEqual(Constant(schema_a, tuples_a), Foo())
+        self.assertNotEqual(hash(Constant(schema_a, tuples_a)), hash(Foo()))
+        self.assertNotEqual(Constant(schema_a, tuples_a), 123)
+        self.assertNotEqual(hash(Constant(schema_a, tuples_a)), hash(123))
+        self.assertNotEqual(Constant(schema_a, tuples_a), None)
+        self.assertNotEqual(hash(Constant(schema_a, tuples_a)), hash(None))
 
 
 ## main ##
diff --git a/test/extractor/generic/test_path.py b/test/extractor/generic/test_path.py
index 8623490..9376c7c 100644
--- a/test/extractor/generic/test_path.py
+++ b/test/extractor/generic/test_path.py
@@ -8,7 +8,9 @@ Author: Matthias Baumgartner, 2022
 import unittest
 
 # bsie imports
+from bsie import base
 from bsie.utils import ns
+from bsie.utils.bsfs import schema
 from bsie.utils.node import Node
 
 # objects to test
@@ -18,23 +20,52 @@ from bsie.extractor.generic.path import Path
 ## code ##
 
 class TestPath(unittest.TestCase):
+    def test_eq(self):
+        # distinct instances, same data
+        self.assertEqual(Path(), Path())
+        # different classes
+        class Foo(): pass
+        self.assertNotEqual(Path(), Foo())
+        self.assertNotEqual(Path(), 123)
+        self.assertNotEqual(Path(), None)
+
+    def test_schema(self):
+        self.assertEqual(Path().schema,
+            schema.Schema.from_string(base.extractor.SCHEMA_PREAMBLE + '''
+                bse:filename rdfs:subClassOf bsfs:Predicate ;
+                    rdfs:domain bsfs:Entity ;
+                    rdfs:range xsd:string ;
+                    owl:maxCardinality "INF"^^xsd:number .
+                '''))
+
     def test_extract(self):
-        node = Node(ns.bsfs.Entity, '') # Blank node
         ext = Path()
+        node = Node(ns.bsfs.Entity, '') # 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)
 
         # baseline
-        self.assertSetEqual(set(ext.extract(node, '/tmp/foo/bar', (ns.bse.filename, ))),
-            {(node, ns.bse.filename, 'bar')})
+        self.assertSetEqual(set(ext.extract(node, content, (p_filename, ))),
+            {(node, p_filename, 'bar')})
         # predicates parameter is respected
-        self.assertSetEqual(set(ext.extract(node, '/tmp/foo/bar', (ns.bse.filename, ns.bse.foo))),
-            {(node, ns.bse.filename, 'bar')})
-        self.assertSetEqual(set(ext.extract(node, '/tmp/foo/bar', (ns.bse.foo, ))), set())
+        p_foo = ext.schema.predicate(ns.bsfs.Predicate).get_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
+        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())
         # path variations
-        self.assertSetEqual(set(ext.extract(node, 'bar', (ns.bse.filename, ))),
-            {(node, ns.bse.filename, 'bar')})
-        self.assertSetEqual(set(ext.extract(node, '', (ns.bse.filename, ))),
-            {(node, ns.bse.filename, '')})
-        self.assertSetEqual(set(ext.extract(node, None, (ns.bse.filename, ))), set())
+        self.assertSetEqual(set(ext.extract(node, 'bar', (p_filename, ))),
+            {(node, p_filename, 'bar')})
+        self.assertSetEqual(set(ext.extract(node, '', (p_filename, ))),
+            {(node, p_filename, '')})
+        # errors are suppressed
+        self.assertSetEqual(set(ext.extract(node, None, (p_filename, ))), set())
 
 
 ## main ##
diff --git a/test/extractor/generic/test_stat.py b/test/extractor/generic/test_stat.py
index f89b053..26dad6a 100644
--- a/test/extractor/generic/test_stat.py
+++ b/test/extractor/generic/test_stat.py
@@ -9,7 +9,9 @@ import os
 import unittest
 
 # bsie imports
+from bsie import base
 from bsie.utils import ns
+from bsie.utils.bsfs import schema
 from bsie.utils.node import Node
 
 # objects to test
@@ -18,21 +20,51 @@ from bsie.extractor.generic.stat import Stat
 
 ## code ##
 
-class TestConstant(unittest.TestCase):
+class TestStat(unittest.TestCase):
+    def test_eq(self):
+        # distinct instances, same data
+        self.assertEqual(Stat(), Stat())
+        # different classes
+        class Foo(): pass
+        self.assertNotEqual(Stat(), Foo())
+        self.assertNotEqual(Stat(), 123)
+        self.assertNotEqual(Stat(), None)
+
+    def test_schema(self):
+        self.assertEqual(Stat().schema,
+            schema.Schema.from_string(base.extractor.SCHEMA_PREAMBLE + '''
+                bse:filesize rdfs:subClassOf bsfs:Predicate ;
+                    rdfs:domain bsfs:Entity ;
+                    rdfs:range xsd:integer ;
+                    owl:maxCardinality "INF"^^xsd:number .
+                '''))
+
     def test_extract(self):
+        ext = Stat()
         node = Node(ns.bsfs.Entity, '') # Blank node
         content = os.stat(__file__)
-        ext = Stat()
+        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)
 
         # baseline
-        self.assertSetEqual(set(ext.extract(node, content, (ns.bse.filesize, ))),
-            {(node, ns.bse.filesize, content.st_size)})
+        self.assertSetEqual(set(ext.extract(node, content, (p_filesize, ))),
+            {(node, p_filesize, content.st_size)})
         # predicates parameter is respected
-        self.assertSetEqual(set(ext.extract(node, content, (ns.bse.filesize, ns.bse.foo))),
-            {(node, ns.bse.filesize, content.st_size)})
-        self.assertSetEqual(set(ext.extract(node, content, (ns.bse.foo, ))), set())
+        p_foo = ext.schema.predicate(ns.bsfs.Predicate).get_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
+        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())
         # content variations
-        self.assertSetEqual(set(ext.extract(node, None, (ns.bse.filesize, ))), set())
+        self.assertSetEqual(set(ext.extract(node, os.stat_result([12345] * len(content)), (p_filesize, p_bar))),
+            {(node, p_filesize, 12345)})
+        # errors are suppressed
+        self.assertSetEqual(set(ext.extract(node, None, (p_filesize, ))), set())
 
 
 ## main ##