Merge branch 'develop' into main

5 files changed, 271 insertions, 0 deletions

diff --git a/test/extractor/__init__.py b/test/extractor/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/extractor/__init__.py
diff --git a/test/extractor/generic/__init__.py b/test/extractor/generic/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/extractor/generic/__init__.py
diff --git a/test/extractor/generic/test_constant.py b/test/extractor/generic/test_constant.py
new file mode 100644
index 0000000..9dbaced
--- /dev/null
+++ b/test/extractor/generic/test_constant.py
@@ -0,0 +1,124 @@
+"""
+
+Part of the bsie test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import unittest
+
+# bsie imports
+from bsie.utils import node as _node, ns
+
+# objects to test
+from bsie.extractor.generic.constant import Constant
+
+
+## code ##
+
+class TestConstant(unittest.TestCase):
+    def test_extract(self):
+        schema = '''
+            bse:author rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:comment rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                bsfs:unique "false"^^xsd:boolean .
+            '''
+        tuples = [
+            (ns.bse.author, 'Me, myself, and I'),
+            (ns.bse.comment, 'the quick brown fox jumps over the lazy dog.'),
+            ]
+        ext = Constant(schema, tuples)
+        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)
+        # 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)
+        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 ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:comment rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                bsfs:unique "false"^^xsd:boolean .
+            '''
+        # 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 ;
+                bsfs:unique "true"^^xsd:boolean .
+            '''
+        schema_b = '''
+            bse:comment rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                bsfs:unique "false"^^xsd:boolean .
+            '''
+        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 ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
diff --git a/test/extractor/generic/test_path.py b/test/extractor/generic/test_path.py
new file mode 100644
index 0000000..820f402
--- /dev/null
+++ b/test/extractor/generic/test_path.py
@@ -0,0 +1,74 @@
+"""
+
+Part of the bsie test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import unittest
+
+# bsie imports
+from bsie.base import extractor
+from bsie.utils import bsfs, node as _node, ns
+
+# objects to test
+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,
+            bsfs.schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + '''
+                bse:filename rdfs:subClassOf bsfs:Predicate ;
+                    rdfs:domain bsfs:File ;
+                    rdfs:range xsd:string ;
+                    bsfs:unique "false"^^xsd:boolean .
+                '''))
+
+    def test_extract(self):
+        ext = Path()
+        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)
+
+        # 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
+        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', (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 ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
diff --git a/test/extractor/generic/test_stat.py b/test/extractor/generic/test_stat.py
new file mode 100644
index 0000000..3441438
--- /dev/null
+++ b/test/extractor/generic/test_stat.py
@@ -0,0 +1,73 @@
+"""
+
+Part of the bsie test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import os
+import unittest
+
+# bsie imports
+from bsie.base import extractor
+from bsie.utils import bsfs, node as _node, ns
+
+# objects to test
+from bsie.extractor.generic.stat import Stat
+
+
+## code ##
+
+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,
+            bsfs.schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + '''
+                bse:filesize rdfs:subClassOf bsfs:Predicate ;
+                    rdfs:domain bsfs:File ;
+                    rdfs:range xsd:integer ;
+                    bsfs:unique "false"^^xsd:boolean .
+                '''))
+
+    def test_extract(self):
+        ext = Stat()
+        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)
+
+        # 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
+        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, 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 ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##