aboutsummaryrefslogtreecommitdiffstats
path: root/test/extractor
diff options
context:
space:
mode:
Diffstat (limited to 'test/extractor')
-rw-r--r--test/extractor/generic/test_constant.py100
-rw-r--r--test/extractor/generic/test_path.py53
-rw-r--r--test/extractor/generic/test_stat.py48
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 ##
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-02 15:56:56 +0000