Merge branch 'mb/fetch' into develop

2 files changed, 351 insertions, 6 deletions

diff --git a/test/query/ast_test/test_fetch.py b/test/query/ast_test/test_fetch.py
new file mode 100644
index 0000000..0c48a1f
--- /dev/null
+++ b/test/query/ast_test/test_fetch.py
@@ -0,0 +1,239 @@
+"""
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import unittest
+
+# bsfs imports
+from bsfs.namespace import ns
+from bsfs.utils import URI
+
+# objects to test
+from bsfs.query.ast.fetch import FetchExpression
+from bsfs.query.ast.fetch import All, This
+from bsfs.query.ast.fetch import _Branch, Fetch
+from bsfs.query.ast.fetch import _Named, Node, Value
+
+
+## code ##
+
+class TestExpression(unittest.TestCase): # FetchExpression
+    def test_essentials(self):
+        class Foo(FetchExpression): pass
+        # comparison
+        self.assertEqual(FetchExpression(), FetchExpression())
+        self.assertEqual(hash(FetchExpression()), hash(FetchExpression()))
+        # comparison respects type
+        self.assertNotEqual(FetchExpression(), Foo())
+        self.assertNotEqual(hash(FetchExpression()), hash(Foo()))
+        # string conversion
+        self.assertEqual(str(FetchExpression()), 'FetchExpression()')
+        self.assertEqual(repr(FetchExpression()), 'FetchExpression()')
+        self.assertEqual(str(Foo()), 'Foo()')
+        self.assertEqual(repr(Foo()), 'Foo()')
+
+
+class TestAll(unittest.TestCase): # All
+    def test_essentials(self):
+        class Foo(All): pass
+        expr0 = This('hello')
+        expr1 = This('world')
+        # comparison
+        self.assertEqual(All(expr0), All(expr0))
+        self.assertEqual(hash(All(expr0)), hash(All(expr0)))
+        # comparison respects type
+        self.assertNotEqual(All(expr0), Foo(expr0))
+        self.assertNotEqual(hash(All(expr0)), hash(Foo(expr0)))
+        # comparison respects expressions
+        self.assertEqual(All(expr0, expr1), All(expr0, expr1))
+        self.assertEqual(hash(All(expr0, expr1)), hash(All(expr0, expr1)))
+        self.assertNotEqual(All(expr0), All(expr1))
+        self.assertNotEqual(hash(All(expr0)), hash(All(expr1)))
+        # expressions are unordered
+        self.assertEqual(All(expr0, expr1), All(expr1, expr0))
+        self.assertEqual(hash(All(expr0, expr1)), hash(All(expr1, expr0)))
+        # string conversion
+        self.assertIn(str(All(expr0, expr1)), {
+            'All({This(world), This(hello)})',
+            'All({This(hello), This(world)})'})
+        self.assertIn(repr(All(expr0, expr1)), {
+            'All({This(world), This(hello)})',
+            'All({This(hello), This(world)})'})
+
+    def test_members(self):
+        class Foo(): pass
+        expr0 = This('hello')
+        expr1 = This('world')
+        # requires at least one child expression
+        self.assertRaises(AttributeError, All)
+        # expr returns child expressions
+        self.assertEqual(All(expr0, expr1).expr, {expr0, expr1})
+        # can pass expressions as arguments
+        self.assertEqual(All(expr0, expr1).expr, {expr0, expr1})
+        # can pass a single expression as argument
+        self.assertEqual(All(expr0).expr, {expr0})
+        # can pass expressions as list-like
+        self.assertEqual(All([expr0, expr1]).expr, {expr0, expr1})
+        self.assertEqual(All((expr0, expr1)).expr, {expr0, expr1})
+        self.assertEqual(All({expr0, expr1}).expr, {expr0, expr1})
+        # can pass a single expression as list-like
+        self.assertEqual(All([expr0]).expr, {expr0})
+        # must pass a FilterExpression
+        self.assertRaises(TypeError, All, Foo())
+        self.assertRaises(TypeError, All, 1234)
+        self.assertRaises(TypeError, All, 'hello world')
+        # len returns the number of child expressions
+        self.assertEqual(len(All(expr0)), 1)
+        self.assertEqual(len(All(expr0, expr1)), 2)
+        # iter iterates over child expressions
+        self.assertSetEqual(set(All(expr0, expr1)), {expr0, expr1})
+
+
+class TestThis(unittest.TestCase): # This
+    def test_essentials(self):
+        class Foo(This): pass
+        # comparison
+        self.assertEqual(This('hello'), This('hello'))
+        self.assertEqual(hash(This('hello')), hash(This('hello')))
+        # comparison respects type
+        self.assertNotEqual(This('hello'), Foo('hello'))
+        self.assertNotEqual(hash(This('hello')), hash(Foo('hello')))
+        # comparison respects name
+        self.assertNotEqual(This('hello'), This('world'))
+        self.assertNotEqual(hash(This('hello')), hash(This('world')))
+        # string conversion
+        self.assertEqual(str(This('hello')), 'This(hello)')
+        self.assertEqual(repr(This('hello')), 'This(hello)')
+
+    def test_members(self):
+        class Foo(): pass
+        # name returns member
+        self.assertEqual(This('hello').name, 'hello')
+        self.assertEqual(This('world').name, 'world')
+        # name is converted to a string
+        self.assertEqual(This(1234).name, '1234')
+        foo = Foo()
+        self.assertEqual(This(foo).name, str(foo))
+
+
+class TestBranch(unittest.TestCase): # _Branch, Fetch
+    def test_essentials(self):
+        pred = ns.bse.tag
+        expr = FetchExpression()
+        # comparison
+        self.assertEqual(_Branch(pred), _Branch(pred))
+        self.assertEqual(hash(_Branch(pred)), hash(_Branch(pred)))
+        self.assertEqual(Fetch(pred, expr), Fetch(pred, expr))
+        self.assertEqual(hash(Fetch(pred, expr)), hash(Fetch(pred, expr)))
+        # comparison respects type
+        self.assertNotEqual(_Branch(pred), Fetch(pred, expr))
+        self.assertNotEqual(hash(_Branch(pred)), hash(Fetch(pred, expr)))
+        self.assertNotEqual(Fetch(pred, expr), _Branch(pred))
+        self.assertNotEqual(hash(Fetch(pred, expr)), hash(_Branch(pred)))
+        # comparison respects predicate
+        self.assertNotEqual(_Branch(pred), _Branch(ns.bse.filesize))
+        self.assertNotEqual(hash(_Branch(pred)), hash(_Branch(ns.bse.filesize)))
+        self.assertNotEqual(Fetch(pred, expr), Fetch(ns.bse.filesize, expr))
+        self.assertNotEqual(hash(Fetch(pred, expr)), hash(Fetch(ns.bse.filesize, expr)))
+        # comparison respects expression
+        self.assertNotEqual(Fetch(pred, expr), Fetch(pred, This('foo')))
+        self.assertNotEqual(hash(Fetch(pred, expr)), hash(Fetch(pred, This('foo'))))
+        # string conversion
+        self.assertEqual(str(_Branch(pred)), f'_Branch({pred})')
+        self.assertEqual(repr(_Branch(pred)), f'_Branch({pred})')
+        self.assertEqual(str(Fetch(pred, expr)), f'Fetch({pred}, {expr})')
+        self.assertEqual(repr(Fetch(pred, expr)), f'Fetch({pred}, {expr})')
+
+    def test_members(self):
+        class Foo(): pass
+        pred = ns.bse.tag
+        expr = FetchExpression()
+
+        # predicate returns member
+        self.assertEqual(_Branch(pred).predicate, pred)
+        self.assertEqual(Fetch(pred, expr).predicate, pred)
+        # can pass an URI
+        self.assertEqual(_Branch(ns.bse.filename).predicate, ns.bse.filename)
+        self.assertEqual(Fetch(ns.bse.filename, expr).predicate, ns.bse.filename)
+        # must pass an URI
+        self.assertRaises(TypeError, _Branch, Foo())
+        self.assertRaises(TypeError, Fetch, Foo(), expr)
+        # expression returns member
+        self.assertEqual(Fetch(pred, expr).expr, expr)
+        # expression must be a FilterExpression
+        self.assertRaises(TypeError, Fetch, ns.bse.filename, 'hello')
+        self.assertRaises(TypeError, Fetch, ns.bse.filename, 1234)
+        self.assertRaises(TypeError, Fetch, ns.bse.filename, Foo())
+
+
+class TestNamed(unittest.TestCase): # _Named, Node, Value
+    def test_essentials(self):
+        pred = ns.bse.tag
+        name = 'foobar'
+        # comparison
+        self.assertEqual(_Named(pred, name), _Named(pred, name))
+        self.assertEqual(hash(_Named(pred, name)), hash(_Named(pred, name)))
+        # comparison respects type
+        self.assertNotEqual(_Named(pred, name), Node(pred, name))
+        self.assertNotEqual(Node(pred, name), Value(pred, name))
+        self.assertNotEqual(Value(pred, name), _Named(pred, name))
+        self.assertNotEqual(hash(_Named(pred, name)), hash(Node(pred, name)))
+        self.assertNotEqual(hash(Node(pred, name)), hash(Value(pred, name)))
+        self.assertNotEqual(hash(Value(pred, name)), hash(_Named(pred, name)))
+        # comparison respects predicate
+        self.assertNotEqual(_Named(pred, name), _Named(ns.bse.filesize, name))
+        self.assertNotEqual(hash(_Named(pred, name)), hash(_Named(ns.bse.filesize, name)))
+        self.assertNotEqual(Node(pred, name), Node(ns.bse.filesize, name))
+        self.assertNotEqual(hash(Node(pred, name)), hash(Node(ns.bse.filesize, name)))
+        self.assertNotEqual(Value(pred, name), Value(ns.bse.filesize, name))
+        self.assertNotEqual(hash(Value(pred, name)), hash(Value(ns.bse.filesize, name)))
+        # comparison respects name
+        self.assertNotEqual(_Named(pred, name), _Named(pred, 'foo'))
+        self.assertNotEqual(hash(_Named(pred, name)), hash(_Named(pred, 'foo')))
+        self.assertNotEqual(Node(pred, name), Node(pred, 'foo'))
+        self.assertNotEqual(hash(Node(pred, name)), hash(Node(pred, 'foo')))
+        self.assertNotEqual(Value(pred, name), Value(pred, 'foo'))
+        self.assertNotEqual(hash(Value(pred, name)), hash(Value(pred, 'foo')))
+        # string conversion
+        self.assertEqual(str(_Named(pred, name)), f'_Named({pred}, {name})')
+        self.assertEqual(repr(_Named(pred, name)), f'_Named({pred}, {name})')
+        self.assertEqual(str(Node(pred, name)), f'Node({pred}, {name})')
+        self.assertEqual(repr(Node(pred, name)), f'Node({pred}, {name})')
+        self.assertEqual(str(Value(pred, name)), f'Value({pred}, {name})')
+        self.assertEqual(repr(Value(pred, name)), f'Value({pred}, {name})')
+
+    def test_members(self):
+        class Foo(): pass
+        pred = ns.bse.tag
+        name = 'foobar'
+        # predicate returns member
+        self.assertEqual(_Named(pred, name).predicate, pred)
+        self.assertEqual(Node(pred, name).predicate, pred)
+        self.assertEqual(Value(pred, name).predicate, pred)
+        # can pass an URI as predicate
+        self.assertEqual(_Named(ns.bse.filename, name).predicate, ns.bse.filename)
+        self.assertEqual(Node(ns.bse.filename, name).predicate, ns.bse.filename)
+        self.assertEqual(Value(ns.bse.filename, name).predicate, ns.bse.filename)
+        # must pass an URI
+        self.assertRaises(TypeError, _Named, Foo(), name)
+        self.assertRaises(TypeError, Node, Foo(), name)
+        self.assertRaises(TypeError, Value, Foo(), name)
+        # name returns member
+        self.assertEqual(_Named(pred, name).name, name)
+        self.assertEqual(Node(pred, name).name, name)
+        self.assertEqual(Value(pred, name).name, name)
+        # name is converted to a string
+        self.assertEqual(_Named(pred, 1234).name, '1234')
+        self.assertEqual(Node(pred, 1234).name, '1234')
+        self.assertEqual(Value(pred, 1234).name, '1234')
+
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
diff --git a/test/query/ast_test/test_filter_.py b/test/query/ast_test/test_filter_.py
index 9eb92e2..39b98f8 100644
--- a/test/query/ast_test/test_filter_.py
+++ b/test/query/ast_test/test_filter_.py
@@ -20,6 +20,7 @@ from bsfs.query.ast.filter_ import _Value, Is, Equals, Substring, StartsWith, En
 from bsfs.query.ast.filter_ import _Bounded, LessThan, GreaterThan
 from bsfs.query.ast.filter_ import Predicate, OneOf
 from bsfs.query.ast.filter_ import IsIn, IsNotIn
+from bsfs.query.ast.filter_ import Includes, Excludes, Between
 
 
 ## code ##
@@ -456,13 +457,15 @@ class TestOneOf(unittest.TestCase):
         self.assertEqual(len(OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename), Predicate(ns.bse.tag))), 3)
 
 
-    def testIsIn(self):
+    def test_IsIn(self):
+        # cannot pass zero arguments
+        self.assertRaises(AttributeError, IsIn)
         # can pass expressions as arguments
         self.assertEqual(IsIn('http://example.com/entity#1234', 'http://example.com/entity#4321'),
             Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321')))
         # can pass one expression as argument
         self.assertEqual(IsIn('http://example.com/entity#1234'),
-            Or(Is('http://example.com/entity#1234')))
+            Is('http://example.com/entity#1234'))
         # can pass expressions as iterator
         self.assertEqual(IsIn(iter(('http://example.com/entity#1234', 'http://example.com/entity#4321'))),
             Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321')))
@@ -477,16 +480,18 @@ class TestOneOf(unittest.TestCase):
             Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321')))
         # can pass one expression as list-like
         self.assertEqual(IsIn(['http://example.com/entity#1234']),
-            Or(Is('http://example.com/entity#1234')))
+            Is('http://example.com/entity#1234'))
 
 
-    def testIsNotIn(self):
+    def test_IsNotIn(self):
+        # cannot pass zero arguments
+        self.assertRaises(AttributeError, IsNotIn)
         # can pass expressions as arguments
         self.assertEqual(IsNotIn('http://example.com/entity#1234', 'http://example.com/entity#4321'),
             Not(Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321'))))
         # can pass one expression as argument
         self.assertEqual(IsNotIn('http://example.com/entity#1234'),
-            Not(Or(Is('http://example.com/entity#1234'))))
+            Not(Is('http://example.com/entity#1234')))
         # can pass expressions as iterator
         self.assertEqual(IsNotIn(iter(('http://example.com/entity#1234', 'http://example.com/entity#4321'))),
             Not(Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321'))))
@@ -501,9 +506,110 @@ class TestOneOf(unittest.TestCase):
             Not(Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321'))))
         # can pass one expression as list-like
         self.assertEqual(IsNotIn(['http://example.com/entity#1234']),
-            Not(Or(Is('http://example.com/entity#1234'))))
+            Not(Is('http://example.com/entity#1234')))
 
 
+    def test_Includes(self):
+        # cannot pass zero arguments
+        self.assertRaises(AttributeError, Includes)
+        # can pass expressions as arguments
+        self.assertEqual(Includes('hello', 'world'),
+            Or(Equals('hello'), Equals('world')))
+        self.assertEqual(Includes('hello', 'world', approx=True),
+            Or(Substring('hello'), Substring('world')))
+        # can pass one expression as argument
+        self.assertEqual(Includes('hello'),
+            Equals('hello'))
+        self.assertEqual(Includes('hello', approx=True),
+            Substring('hello'))
+        # can pass expressions as iterator
+        self.assertEqual(Includes(iter(('hello', 'world'))),
+            Or(Equals('hello'), Equals('world')))
+        self.assertEqual(Includes(iter(('hello', 'world')), approx=True),
+            Or(Substring('hello'), Substring('world')))
+        # can pass expressions as generator
+        def gen():
+            yield 'hello'
+            yield 'world'
+        self.assertEqual(Includes(gen()),
+            Or(Equals('hello'), Equals('world')))
+        self.assertEqual(Includes(gen(), approx=True),
+            Or(Substring('hello'), Substring('world')))
+        # can pass expressions as list-like
+        self.assertEqual(Includes(['hello', 'world']),
+            Or(Equals('hello'), Equals('world')))
+        self.assertEqual(Includes(['hello', 'world'], approx=True),
+            Or(Substring('hello'), Substring('world')))
+        # can pass one expression as list-like
+        self.assertEqual(Includes(['hello']),
+            Equals('hello'))
+        self.assertEqual(Includes(['hello'], approx=True),
+            Substring('hello'))
+
+
+    def test_Excludes(self):
+        # cannot pass zero arguments
+        self.assertRaises(AttributeError, Excludes)
+        # can pass expressions as arguments
+        self.assertEqual(Excludes('hello', 'world'),
+            Not(Or(Equals('hello'), Equals('world'))))
+        self.assertEqual(Excludes('hello', 'world', approx=True),
+            Not(Or(Substring('hello'), Substring('world'))))
+        # can pass one expression as argument
+        self.assertEqual(Excludes('hello'),
+            Not(Equals('hello')))
+        self.assertEqual(Excludes('hello', approx=True),
+            Not(Substring('hello')))
+        # can pass expressions as iterator
+        self.assertEqual(Excludes(iter(('hello', 'world'))),
+            Not(Or(Equals('hello'), Equals('world'))))
+        self.assertEqual(Excludes(iter(('hello', 'world')), approx=True),
+            Not(Or(Substring('hello'), Substring('world'))))
+        # can pass expressions as generator
+        def gen():
+            yield 'hello'
+            yield 'world'
+        self.assertEqual(Excludes(gen()),
+            Not(Or(Equals('hello'), Equals('world'))))
+        self.assertEqual(Excludes(gen(), approx=True),
+            Not(Or(Substring('hello'), Substring('world'))))
+        # can pass expressions as list-like
+        self.assertEqual(Excludes(['hello', 'world']),
+            Not(Or(Equals('hello'), Equals('world'))))
+        self.assertEqual(Excludes(['hello', 'world'], approx=True),
+            Not(Or(Substring('hello'), Substring('world'))))
+        # can pass one expression as list-like
+        self.assertEqual(Excludes(['hello']),
+            Not(Equals('hello')))
+        self.assertEqual(Excludes(['hello'], approx=True),
+            Not(Substring('hello')))
+
+
+    def test_Between(self):
+        # must specify at least one bound
+        self.assertRaises(ValueError, Between, float('inf'), float('inf'))
+        # lower bound must be less than the upper bound
+        self.assertRaises(ValueError, Between, 321, 123)
+        # can set a lower bound only
+        self.assertEqual(Between(123),
+            GreaterThan(123, strict=True))
+        self.assertEqual(Between(123, lo_strict=False),
+            GreaterThan(123, strict=False))
+        # can set an upper bound only
+        self.assertEqual(Between(hi=123),
+            LessThan(123, strict=True))
+        self.assertEqual(Between(hi=123, hi_strict=False),
+            LessThan(123, strict=False))
+        # can set both bounds
+        self.assertEqual(Between(123, 321),
+            And(GreaterThan(123, strict=True), LessThan(321, strict=True)))
+        self.assertEqual(Between(123, 321, False, False),
+            And(GreaterThan(123, strict=False), LessThan(321, strict=False)))
+        # can set identical bounds
+        self.assertRaises(ValueError, Between, 123, 123)
+        self.assertEqual(Between(123, 123, False, False),
+            Equals(123))
+
 
 ## main ##