From 2da348c638ac5058d5acf09ab5df323ee04503d5 Mon Sep 17 00:00:00 2001 From: Matthias Baumgartner Date: Mon, 31 Oct 2022 14:14:42 +0100 Subject: constant, filesize, and filename extractors --- test/extractor/__init__.py | 0 test/extractor/generic/__init__.py | 0 test/extractor/generic/test_constant.py | 63 +++++++++++++++++++++++++++++++++ test/extractor/generic/test_path.py | 45 +++++++++++++++++++++++ test/extractor/generic/test_stat.py | 43 ++++++++++++++++++++++ 5 files changed, 151 insertions(+) create mode 100644 test/extractor/__init__.py create mode 100644 test/extractor/generic/__init__.py create mode 100644 test/extractor/generic/test_constant.py create mode 100644 test/extractor/generic/test_path.py create mode 100644 test/extractor/generic/test_stat.py (limited to 'test/extractor') diff --git a/test/extractor/__init__.py b/test/extractor/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/test/extractor/generic/__init__.py b/test/extractor/generic/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/test/extractor/generic/test_constant.py b/test/extractor/generic/test_constant.py new file mode 100644 index 0000000..f3ab0a3 --- /dev/null +++ b/test/extractor/generic/test_constant.py @@ -0,0 +1,63 @@ +""" + +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 ns +from bsie.utils.node import Node + +# objects to test +from bsie.extractor.generic.constant import Constant + + +## code ## + +class TestConstant(unittest.TestCase): + def test_extract(self): + schema = ''' + bse:author a bsfs:Predicate ; + rdfs:domain bsfs:Entity ; + rdfs:range xsd:string ; + owl:maxCardinality "1"^^xsd:number . + + bse:comment a 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) + # baseline + self.assertSetEqual(set(ext.extract(node, None, predicates)), + {(node, pred, value) for pred, value in tuples}) + # 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}) + + +## 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..8623490 --- /dev/null +++ b/test/extractor/generic/test_path.py @@ -0,0 +1,45 @@ +""" + +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 ns +from bsie.utils.node import Node + +# objects to test +from bsie.extractor.generic.path import Path + + +## code ## + +class TestPath(unittest.TestCase): + def test_extract(self): + node = Node(ns.bsfs.Entity, '') # Blank node + ext = Path() + + # baseline + self.assertSetEqual(set(ext.extract(node, '/tmp/foo/bar', (ns.bse.filename, ))), + {(node, ns.bse.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()) + # 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()) + + +## 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..f89b053 --- /dev/null +++ b/test/extractor/generic/test_stat.py @@ -0,0 +1,43 @@ +""" + +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.utils import ns +from bsie.utils.node import Node + +# objects to test +from bsie.extractor.generic.stat import Stat + + +## code ## + +class TestConstant(unittest.TestCase): + def test_extract(self): + node = Node(ns.bsfs.Entity, '') # Blank node + content = os.stat(__file__) + ext = Stat() + + # baseline + self.assertSetEqual(set(ext.extract(node, content, (ns.bse.filesize, ))), + {(node, ns.bse.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()) + # content variations + self.assertSetEqual(set(ext.extract(node, None, (ns.bse.filesize, ))), set()) + + +## main ## + +if __name__ == '__main__': + unittest.main() + +## EOF ## -- cgit v1.2.3 From e174a25585e64eb1b0759440cad48d642dd31829 Mon Sep 17 00:00:00 2001 From: Matthias Baumgartner Date: Fri, 25 Nov 2022 14:31:29 +0100 Subject: use schema and predicate types in extractors --- test/extractor/generic/test_constant.py | 63 +++++++++++++++++++++++---------- test/extractor/generic/test_path.py | 53 +++++++++++++++++++++------ test/extractor/generic/test_stat.py | 48 ++++++++++++++++++++----- 3 files changed, 126 insertions(+), 38 deletions(-) (limited to 'test/extractor') diff --git a/test/extractor/generic/test_constant.py b/test/extractor/generic/test_constant.py index f3ab0a3..7fdb8ac 100644 --- a/test/extractor/generic/test_constant.py +++ b/test/extractor/generic/test_constant.py @@ -20,39 +20,64 @@ 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())]) + ## 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 ## -- cgit v1.2.3 From 9ce32829b2bb85907a34a543bfcaa9183d1e362c Mon Sep 17 00:00:00 2001 From: Matthias Baumgartner Date: Fri, 25 Nov 2022 14:39:18 +0100 Subject: string conversion and equality checks --- test/extractor/generic/test_constant.py | 37 +++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) (limited to 'test/extractor') diff --git a/test/extractor/generic/test_constant.py b/test/extractor/generic/test_constant.py index 7fdb8ac..aa33fb4 100644 --- a/test/extractor/generic/test_constant.py +++ b/test/extractor/generic/test_constant.py @@ -78,6 +78,43 @@ class TestConstant(unittest.TestCase): #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 ## -- cgit v1.2.3 From edc747252a04675c46059215751719b6666a77f9 Mon Sep 17 00:00:00 2001 From: Matthias Baumgartner Date: Sat, 3 Dec 2022 18:57:58 +0100 Subject: adapt to schema interface update: owl:maxCardinality changed to bsfs:unique --- test/extractor/generic/test_constant.py | 12 ++++++------ test/extractor/generic/test_path.py | 2 +- test/extractor/generic/test_stat.py | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-) (limited to 'test/extractor') diff --git a/test/extractor/generic/test_constant.py b/test/extractor/generic/test_constant.py index aa33fb4..7f72ccf 100644 --- a/test/extractor/generic/test_constant.py +++ b/test/extractor/generic/test_constant.py @@ -23,11 +23,11 @@ class TestConstant(unittest.TestCase): bse:author rdfs:subClassOf bsfs:Predicate ; rdfs:domain bsfs:Entity ; rdfs:range xsd:string ; - owl:maxCardinality "1"^^xsd:number . + bsfs:unique "true"^^xsd:boolean . bse:comment rdfs:subClassOf bsfs:Predicate ; rdfs:domain bsfs:Entity ; rdfs:range xsd:string ; - owl:maxCardinality "INF"^^xsd:number . + bsfs:unique "false"^^xsd:boolean . ''' tuples = [ (ns.bse.author, 'Me, myself, and I'), @@ -58,11 +58,11 @@ class TestConstant(unittest.TestCase): bse:author rdfs:subClassOf bsfs:Predicate ; rdfs:domain bsfs:Entity ; rdfs:range xsd:string ; - owl:maxCardinality "1"^^xsd:number . + bsfs:unique "true"^^xsd:boolean . bse:comment rdfs:subClassOf bsfs:Predicate ; rdfs:domain bsfs:Entity ; rdfs:range xsd:string ; - owl:maxCardinality "INF"^^xsd:number . + bsfs:unique "false"^^xsd:boolean . ''' # can create a schema self.assertIsInstance(Constant(schema, [ @@ -83,13 +83,13 @@ class TestConstant(unittest.TestCase): bse:author rdfs:subClassOf bsfs:Predicate ; rdfs:domain bsfs:Entity ; rdfs:range xsd:string ; - owl:maxCardinality "1"^^xsd:number . + bsfs:unique "true"^^xsd:boolean . ''' schema_b = ''' bse:comment rdfs:subClassOf bsfs:Predicate ; rdfs:domain bsfs:Entity ; rdfs:range xsd:string ; - owl:maxCardinality "INF"^^xsd:number . + 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.') ] diff --git a/test/extractor/generic/test_path.py b/test/extractor/generic/test_path.py index 9376c7c..aa21b04 100644 --- a/test/extractor/generic/test_path.py +++ b/test/extractor/generic/test_path.py @@ -35,7 +35,7 @@ class TestPath(unittest.TestCase): bse:filename rdfs:subClassOf bsfs:Predicate ; rdfs:domain bsfs:Entity ; rdfs:range xsd:string ; - owl:maxCardinality "INF"^^xsd:number . + bsfs:unique "false"^^xsd:boolean . ''')) def test_extract(self): diff --git a/test/extractor/generic/test_stat.py b/test/extractor/generic/test_stat.py index 26dad6a..bed5fab 100644 --- a/test/extractor/generic/test_stat.py +++ b/test/extractor/generic/test_stat.py @@ -36,7 +36,7 @@ class TestStat(unittest.TestCase): bse:filesize rdfs:subClassOf bsfs:Predicate ; rdfs:domain bsfs:Entity ; rdfs:range xsd:integer ; - owl:maxCardinality "INF"^^xsd:number . + bsfs:unique "false"^^xsd:boolean . ''')) def test_extract(self): -- cgit v1.2.3 From 49cf03fc212c813862453de5352436dc90d1e458 Mon Sep 17 00:00:00 2001 From: Matthias Baumgartner Date: Thu, 15 Dec 2022 16:50:53 +0100 Subject: imports and init files --- test/extractor/generic/test_constant.py | 5 ++--- test/extractor/generic/test_path.py | 10 ++++------ test/extractor/generic/test_stat.py | 10 ++++------ 3 files changed, 10 insertions(+), 15 deletions(-) (limited to 'test/extractor') diff --git a/test/extractor/generic/test_constant.py b/test/extractor/generic/test_constant.py index 7f72ccf..9dbaced 100644 --- a/test/extractor/generic/test_constant.py +++ b/test/extractor/generic/test_constant.py @@ -8,8 +8,7 @@ Author: Matthias Baumgartner, 2022 import unittest # bsie imports -from bsie.utils import ns -from bsie.utils.node import Node +from bsie.utils import node as _node, ns # objects to test from bsie.extractor.generic.constant import Constant @@ -34,7 +33,7 @@ class TestConstant(unittest.TestCase): (ns.bse.comment, 'the quick brown fox jumps over the lazy dog.'), ] ext = Constant(schema, tuples) - node = Node(ns.bsfs.Entity, '') # Blank node + 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) diff --git a/test/extractor/generic/test_path.py b/test/extractor/generic/test_path.py index aa21b04..d2b6c61 100644 --- a/test/extractor/generic/test_path.py +++ b/test/extractor/generic/test_path.py @@ -8,10 +8,8 @@ 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 +from bsie.base import extractor +from bsie.utils import bsfs, node as _node, ns # objects to test from bsie.extractor.generic.path import Path @@ -31,7 +29,7 @@ class TestPath(unittest.TestCase): def test_schema(self): self.assertEqual(Path().schema, - schema.Schema.from_string(base.extractor.SCHEMA_PREAMBLE + ''' + bsfs.schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + ''' bse:filename rdfs:subClassOf bsfs:Predicate ; rdfs:domain bsfs:Entity ; rdfs:range xsd:string ; @@ -40,7 +38,7 @@ class TestPath(unittest.TestCase): def test_extract(self): ext = Path() - node = Node(ns.bsfs.Entity, '') # Blank node + 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) diff --git a/test/extractor/generic/test_stat.py b/test/extractor/generic/test_stat.py index bed5fab..6cfc57f 100644 --- a/test/extractor/generic/test_stat.py +++ b/test/extractor/generic/test_stat.py @@ -9,10 +9,8 @@ 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 +from bsie.base import extractor +from bsie.utils import bsfs, node as _node, ns # objects to test from bsie.extractor.generic.stat import Stat @@ -32,7 +30,7 @@ class TestStat(unittest.TestCase): def test_schema(self): self.assertEqual(Stat().schema, - schema.Schema.from_string(base.extractor.SCHEMA_PREAMBLE + ''' + bsfs.schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + ''' bse:filesize rdfs:subClassOf bsfs:Predicate ; rdfs:domain bsfs:Entity ; rdfs:range xsd:integer ; @@ -41,7 +39,7 @@ class TestStat(unittest.TestCase): def test_extract(self): ext = Stat() - node = Node(ns.bsfs.Entity, '') # Blank node + 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) -- cgit v1.2.3 From 8e6d27ea75d2c8d68f6dd8b3d529aaa278f291cc Mon Sep 17 00:00:00 2001 From: Matthias Baumgartner Date: Thu, 15 Dec 2022 17:12:56 +0100 Subject: file node class in default schema --- test/extractor/generic/test_path.py | 2 +- test/extractor/generic/test_stat.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'test/extractor') diff --git a/test/extractor/generic/test_path.py b/test/extractor/generic/test_path.py index d2b6c61..820f402 100644 --- a/test/extractor/generic/test_path.py +++ b/test/extractor/generic/test_path.py @@ -31,7 +31,7 @@ class TestPath(unittest.TestCase): self.assertEqual(Path().schema, bsfs.schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + ''' bse:filename rdfs:subClassOf bsfs:Predicate ; - rdfs:domain bsfs:Entity ; + rdfs:domain bsfs:File ; rdfs:range xsd:string ; bsfs:unique "false"^^xsd:boolean . ''')) diff --git a/test/extractor/generic/test_stat.py b/test/extractor/generic/test_stat.py index 6cfc57f..3441438 100644 --- a/test/extractor/generic/test_stat.py +++ b/test/extractor/generic/test_stat.py @@ -32,7 +32,7 @@ class TestStat(unittest.TestCase): self.assertEqual(Stat().schema, bsfs.schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + ''' bse:filesize rdfs:subClassOf bsfs:Predicate ; - rdfs:domain bsfs:Entity ; + rdfs:domain bsfs:File ; rdfs:range xsd:integer ; bsfs:unique "false"^^xsd:boolean . ''')) -- cgit v1.2.3