filter ast definition and validation

3 files changed, 704 insertions, 6 deletions

diff --git a/test/query/ast/test_filter_.py b/test/query/ast/test_filter_.py
index cc815e3..4f69bdc 100644
--- a/test/query/ast/test_filter_.py
+++ b/test/query/ast/test_filter_.py
@@ -8,16 +8,468 @@ Author: Matthias Baumgartner, 2022
 import unittest
 
 # bsfs imports
+from bsfs.namespace import ns
+from bsfs.utils import URI
 
 # objects to test
-from bsfs.query.ast.filter_ import _Expression
+from bsfs.query.ast.filter_ import _Expression, FilterExpression, PredicateExpression
+from bsfs.query.ast.filter_ import _Branch, Any, All
+from bsfs.query.ast.filter_ import _Agg, And, Or
+from bsfs.query.ast.filter_ import Not, Has
+from bsfs.query.ast.filter_ import _Value, Is, Equals, Substring, StartsWith, EndsWith
+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
 
 
 ## code ##
 
 class TestExpression(unittest.TestCase):
     def test_essentials(self):
-        raise NotImplementedError()
+        # comparison
+        self.assertEqual(_Expression(), _Expression())
+        self.assertEqual(FilterExpression(), FilterExpression())
+        self.assertEqual(PredicateExpression(), PredicateExpression())
+        self.assertEqual(hash(_Expression()), hash(_Expression()))
+        self.assertEqual(hash(FilterExpression()), hash(FilterExpression()))
+        self.assertEqual(hash(PredicateExpression()), hash(PredicateExpression()))
+        # comparison respects type
+        self.assertNotEqual(FilterExpression(), _Expression())
+        self.assertNotEqual(_Expression(), PredicateExpression())
+        self.assertNotEqual(PredicateExpression(), FilterExpression())
+        self.assertNotEqual(hash(FilterExpression()), hash(_Expression()))
+        self.assertNotEqual(hash(_Expression()), hash(PredicateExpression()))
+        self.assertNotEqual(hash(PredicateExpression()), hash(FilterExpression()))
+        # string conversion
+        self.assertEqual(str(_Expression()), '_Expression()')
+        self.assertEqual(str(FilterExpression()), 'FilterExpression()')
+        self.assertEqual(str(PredicateExpression()), 'PredicateExpression()')
+        self.assertEqual(repr(_Expression()), '_Expression()')
+        self.assertEqual(repr(FilterExpression()), 'FilterExpression()')
+        self.assertEqual(repr(PredicateExpression()), 'PredicateExpression()')
+
+
+class TestBranch(unittest.TestCase): # _Branch, Any, All
+    def test_essentials(self):
+        pred = PredicateExpression()
+        expr = FilterExpression()
+
+        # comparison respects type
+        self.assertNotEqual(_Branch(pred, expr), Any(pred, expr))
+        self.assertNotEqual(Any(pred, expr), All(pred, expr))
+        self.assertNotEqual(All(pred, expr), _Branch(pred, expr))
+        self.assertNotEqual(hash(_Branch(pred, expr)), hash(Any(pred, expr)))
+        self.assertNotEqual(hash(Any(pred, expr)), hash(All(pred, expr)))
+        self.assertNotEqual(hash(All(pred, expr)), hash(_Branch(pred, expr)))
+
+        for cls in (_Branch, Any, All):
+            # comparison
+            self.assertEqual(cls(pred, expr), cls(pred, expr))
+            self.assertEqual(hash(cls(pred, expr)), hash(cls(pred, expr)))
+            # comparison respects predicate
+            self.assertNotEqual(cls(ns.bse.filename, expr), cls(ns.bse.filesize, expr))
+            self.assertNotEqual(hash(cls(ns.bse.filename, expr)), hash(cls(ns.bse.filesize, expr)))
+            # comparison respects expression
+            self.assertNotEqual(cls(pred, Equals('hello')), cls(pred, Equals('world')))
+            self.assertNotEqual(hash(cls(pred, Equals('hello'))), hash(cls(pred, Equals('world'))))
+
+        # string conversion
+        self.assertEqual(str(_Branch(pred, expr)), f'_Branch({pred}, {expr})')
+        self.assertEqual(repr(_Branch(pred, expr)), f'_Branch({pred}, {expr})')
+        self.assertEqual(str(Any(pred, expr)), f'Any({pred}, {expr})')
+        self.assertEqual(repr(Any(pred, expr)), f'Any({pred}, {expr})')
+        self.assertEqual(str(All(pred, expr)), f'All({pred}, {expr})')
+        self.assertEqual(repr(All(pred, expr)), f'All({pred}, {expr})')
+
+    def test_members(self):
+        class Foo(): pass
+        pred = PredicateExpression()
+        expr = FilterExpression()
+
+        for cls in (_Branch, Any, All):
+            # predicate returns member
+            self.assertEqual(cls(PredicateExpression(), expr).predicate, PredicateExpression())
+            # can pass an URI
+            self.assertEqual(cls(ns.bse.filename, expr).predicate, Predicate(ns.bse.filename))
+            # can pass a PredicateExpression
+            self.assertEqual(cls(Predicate(ns.bse.filename), expr).predicate, Predicate(ns.bse.filename))
+            # must pass an URI or PredicateExpression
+            self.assertRaises(TypeError, cls, Foo(), expr)
+            # expression returns member
+            self.assertEqual(cls(pred, Equals('hello')).expr, Equals('hello'))
+            # expression must be a FilterExpression
+            self.assertRaises(TypeError, cls, ns.bse.filename, 'hello')
+            self.assertRaises(TypeError, cls, ns.bse.filename, 1234)
+            self.assertRaises(TypeError, cls, ns.bse.filename, Foo())
+
+
+class TestAgg(unittest.TestCase): # _Agg, And, Or
+    def test_essentials(self):
+        expr = {Equals('hello'), Equals('world')}
+
+        # comparison respects type
+        self.assertNotEqual(_Agg(expr), And(expr))
+        self.assertNotEqual(And(expr), Or(expr))
+        self.assertNotEqual(Or(expr), _Agg(expr))
+        self.assertNotEqual(hash(_Agg(expr)), hash(And(expr)))
+        self.assertNotEqual(hash(And(expr)), hash(Or(expr)))
+        self.assertNotEqual(hash(Or(expr)), hash(_Agg(expr)))
+
+        for cls in (_Agg, And, Or):
+            # comparison
+            self.assertEqual(cls(expr), cls(expr))
+            self.assertEqual(hash(cls(expr)), hash(cls(expr)))
+            # comparison respects expression
+            self.assertNotEqual(cls(expr), cls(Equals('world')))
+            self.assertNotEqual(hash(cls(expr)), hash(cls(Equals('world'))))
+            self.assertNotEqual(cls(Equals('hello')), cls(Equals('world')))
+            self.assertNotEqual(hash(cls(Equals('hello'))), hash(cls(Equals('world'))))
+
+        # string conversion
+        self.assertEqual(str(_Agg(Equals('hello'))), '_Agg({Equals(hello)})')
+        self.assertEqual(repr(_Agg(Equals('hello'))), '_Agg({Equals(hello)})')
+        self.assertEqual(str(And(Equals('hello'))), 'And({Equals(hello)})')
+        self.assertEqual(repr(And(Equals('hello'))), 'And({Equals(hello)})')
+        self.assertEqual(str(Or(Equals('hello'))), 'Or({Equals(hello)})')
+        self.assertEqual(repr(Or(Equals('hello'))), 'Or({Equals(hello)})')
+
+    def test_expression(self):
+        class Foo(): pass
+
+        for cls in (_Agg, And, Or):
+            # can pass expressions as arguments
+            self.assertSetEqual(cls(Equals('hello'), Equals('world')).expr, {Equals('hello'), Equals('world')})
+            # can pass one expressions as argument
+            self.assertSetEqual(cls(Equals('hello')).expr, {Equals('hello')})
+            # can pass expressions as iterator
+            self.assertSetEqual(cls(iter((Equals('hello'), Equals('world')))).expr, {Equals('hello'), Equals('world')})
+            # can pass expressions as generator
+            def gen():
+                yield Equals('hello')
+                yield Equals('world')
+            self.assertSetEqual(cls(gen()).expr, {Equals('hello'), Equals('world')})
+            # can pass expressions as list-like
+            self.assertSetEqual(cls((Equals('hello'), Equals('world'))).expr, {Equals('hello'), Equals('world')})
+            # can pass one expression as list-like
+            self.assertSetEqual(cls([Equals('hello')]).expr, {Equals('hello')})
+            # must pass expressions
+            self.assertRaises(TypeError, cls, Foo(), Foo())
+            self.assertRaises(TypeError, cls, [Foo(), Foo()])
+
+            # iter
+            self.assertSetEqual(set(iter(cls(Equals('hello'), Equals('world')))), {Equals('hello'), Equals('world')})
+            # contains
+            self.assertIn(Equals('world'), cls(Equals('hello'), Equals('world')))
+            self.assertNotIn(Equals('foo'), cls(Equals('hello'), Equals('world')))
+            # len
+            self.assertEqual(len(cls(Equals('hello'), Equals('world'))), 2)
+            self.assertEqual(len(cls(Equals('hello'), Equals('world'), Equals('foo'))), 3)
+
+
+
+class TestNot(unittest.TestCase):
+    def test_essentials(self):
+        expr = FilterExpression()
+        # comparison
+        self.assertEqual(Not(expr), Not(expr))
+        self.assertEqual(hash(Not(expr)), hash(Not(expr)))
+        # comparison respects type
+        self.assertNotEqual(Not(expr), FilterExpression())
+        self.assertNotEqual(hash(Not(expr)), hash(FilterExpression()))
+        # comparison respects expression
+        self.assertNotEqual(Not(Equals('hello')), Not(Equals('world')))
+        self.assertNotEqual(hash(Not(Equals('hello'))), hash(Not(Equals('world'))))
+        # string conversion
+        self.assertEqual(str(Not(Equals('hello'))), 'Not(Equals(hello))')
+        self.assertEqual(repr(Not(Equals('hello'))), 'Not(Equals(hello))')
+
+    def test_expression(self):
+        # Not requires an expression argument
+        self.assertRaises(TypeError, Not)
+        # expression must be a FilterExpression
+        self.assertRaises(TypeError, Not, 'hello')
+        self.assertRaises(TypeError, Not, 1234)
+        self.assertRaises(TypeError, Not, Predicate(ns.bse.filesize))
+        # member returns expression
+        self.assertEqual(Not(Equals('hello')).expr, Equals('hello'))
+
+
+class TestHas(unittest.TestCase):
+    def test_essentials(self):
+        pred = PredicateExpression()
+        count = FilterExpression()
+        # comparison
+        self.assertEqual(Has(pred, count), Has(pred, count))
+        self.assertEqual(hash(Has(pred, count)), hash(Has(pred, count)))
+        # comparison respects type
+        self.assertNotEqual(Has(pred, count), FilterExpression())
+        self.assertNotEqual(hash(Has(pred, count)), hash(FilterExpression()))
+        # comparison respects predicate
+        self.assertNotEqual(Has(pred, count), Has(Predicate(ns.bse.filesize), count))
+        self.assertNotEqual(hash(Has(pred, count)), hash(Has(Predicate(ns.bse.filesize), count)))
+        # comparison respects count
+        self.assertNotEqual(Has(pred, count), Has(pred, LessThan(5)))
+        self.assertNotEqual(hash(Has(pred, count)), hash(Has(pred, LessThan(5))))
+        # string conversion
+        self.assertEqual(str(Has(Predicate(ns.bse.filesize), LessThan(5))),
+            f'Has(Predicate({ns.bse.filesize}, False), LessThan(5.0, True))')
+        self.assertEqual(repr(Has(Predicate(ns.bse.filesize), LessThan(5))),
+            f'Has(Predicate({ns.bse.filesize}, False), LessThan(5.0, True))')
+
+    def test_members(self):
+        pred = PredicateExpression()
+        count = FilterExpression()
+        # member returns expression
+        # predicate must be an URI or a PredicateExpression
+        self.assertEqual(Has(ns.bse.filesize, count).predicate, Predicate(ns.bse.filesize))
+        self.assertEqual(Has(Predicate(ns.bse.filesize), count).predicate, Predicate(ns.bse.filesize))
+        self.assertRaises(TypeError, Has, 1234, FilterExpression())
+        self.assertRaises(TypeError, Has, FilterExpression(), FilterExpression())
+        # member returns count
+        # count must be None, an integer, or a FilterExpression
+        self.assertEqual(Has(pred).count, GreaterThan(1, False))
+        self.assertEqual(Has(pred, LessThan(5)).count, LessThan(5))
+        self.assertEqual(Has(pred, 5).count, Equals(5))
+        self.assertRaises(TypeError, Has, pred, 'hello')
+        self.assertRaises(TypeError, Has, pred, Predicate(ns.bse.filesize))
+
+
+
+class TestValue(unittest.TestCase):
+    def test_essentials(self):
+        # comparison respects type
+        self.assertNotEqual(_Value('hello'), Equals('hello'))
+        self.assertNotEqual(Equals('hello'), Is('hello'))
+        self.assertNotEqual(Is('hello'), Substring('hello'))
+        self.assertNotEqual(Substring('hello'), StartsWith('hello'))
+        self.assertNotEqual(StartsWith('hello'), EndsWith('hello'))
+        self.assertNotEqual(EndsWith('hello'), _Value('hello'))
+        self.assertNotEqual(hash(_Value('hello')), hash(Equals('hello')))
+        self.assertNotEqual(hash(Equals('hello')), hash(Is('hello')))
+        self.assertNotEqual(hash(Is('hello')), hash(Substring('hello')))
+        self.assertNotEqual(hash(Substring('hello')), hash(StartsWith('hello')))
+        self.assertNotEqual(hash(StartsWith('hello')), hash(EndsWith('hello')))
+        self.assertNotEqual(hash(EndsWith('hello')), hash(_Value('hello')))
+
+        for cls in (_Value, Is, Equals, Substring, StartsWith, EndsWith):
+            # comparison
+            self.assertEqual(cls('hello'), cls('hello'))
+            self.assertEqual(hash(cls('hello')), hash(cls('hello')))
+            # comparison respects value
+            self.assertNotEqual(cls('hello'), cls('world'))
+            self.assertNotEqual(hash(cls('hello')), hash(cls('world')))
+
+        # string conversion
+        self.assertEqual(str(_Value('hello')), '_Value(hello)')
+        self.assertEqual(repr(_Value('hello')), '_Value(hello)')
+        self.assertEqual(str(Is('hello')), 'Is(hello)')
+        self.assertEqual(repr(Is('hello')), 'Is(hello)')
+        self.assertEqual(str(Equals('hello')), 'Equals(hello)')
+        self.assertEqual(repr(Equals('hello')), 'Equals(hello)')
+        self.assertEqual(str(Substring('hello')), 'Substring(hello)')
+        self.assertEqual(repr(Substring('hello')), 'Substring(hello)')
+        self.assertEqual(str(StartsWith('hello')), 'StartsWith(hello)')
+        self.assertEqual(repr(StartsWith('hello')), 'StartsWith(hello)')
+        self.assertEqual(str(EndsWith('hello')), 'EndsWith(hello)')
+        self.assertEqual(repr(EndsWith('hello')), 'EndsWith(hello)')
+
+    def test_value(self):
+        class Foo(): pass
+        for cls in (_Value, Is, Equals, Substring, StartsWith, EndsWith):
+            # value can be anything
+            # value returns member
+            f = Foo()
+            self.assertEqual(cls('hello').value, 'hello')
+            self.assertEqual(cls(1234).value, 1234)
+            self.assertEqual(cls(f).value, f)
+
+
+class TestBounded(unittest.TestCase):
+    def test_essentials(self):
+        # comparison respects type
+        self.assertNotEqual(_Bounded(1234), LessThan(1234))
+        self.assertNotEqual(LessThan(1234), GreaterThan(1234))
+        self.assertNotEqual(GreaterThan(1234), _Bounded(1234))
+        self.assertNotEqual(hash(_Bounded(1234)), hash(LessThan(1234)))
+        self.assertNotEqual(hash(LessThan(1234)), hash(GreaterThan(1234)))
+        self.assertNotEqual(hash(GreaterThan(1234)), hash(_Bounded(1234)))
+
+        for cls in (_Bounded, LessThan, GreaterThan):
+            # comparison
+            self.assertEqual(cls(1234), cls(1234))
+            self.assertEqual(hash(cls(1234)), hash(cls(1234)))
+            # comparison respects threshold
+            self.assertNotEqual(cls(1234), cls(4321))
+            self.assertNotEqual(hash(cls(1234)), hash(cls(4321)))
+            # comparison respects strict
+            self.assertNotEqual(cls(1234, True), cls(1234, False))
+            self.assertNotEqual(hash(cls(1234, True)), hash(cls(1234, False)))
+
+        # string conversion
+        self.assertEqual(str(_Bounded(1234, False)), '_Bounded(1234.0, False)')
+        self.assertEqual(repr(_Bounded(1234, False)), '_Bounded(1234.0, False)')
+        self.assertEqual(str(LessThan(1234, False)), 'LessThan(1234.0, False)')
+        self.assertEqual(repr(LessThan(1234, False)), 'LessThan(1234.0, False)')
+        self.assertEqual(str(GreaterThan(1234, False)), 'GreaterThan(1234.0, False)')
+        self.assertEqual(repr(GreaterThan(1234, False)), 'GreaterThan(1234.0, False)')
+
+    def test_members(self):
+        class Foo(): pass
+        for cls in (_Bounded, LessThan, GreaterThan):
+            # threshold becomes float
+            self.assertEqual(cls(1.234).threshold, 1.234)
+            self.assertEqual(cls(1234).threshold, 1234.0)
+            self.assertEqual(cls('1234').threshold, 1234)
+            self.assertRaises(TypeError, cls, Foo())
+            # strict becomes bool
+            self.assertEqual(cls(1234, True).strict, True)
+            self.assertEqual(cls(1234, False).strict, False)
+            self.assertEqual(cls(1234, Foo()).strict, True)
+
+
+class TestPredicate(unittest.TestCase):
+    def test_essentials(self):
+        # comparison
+        self.assertEqual(Predicate(ns.bse.filesize), Predicate(ns.bse.filesize))
+        self.assertEqual(hash(Predicate(ns.bse.filesize)), hash(Predicate(ns.bse.filesize)))
+        # comparison respects type
+        self.assertNotEqual(Predicate(ns.bse.filesize), PredicateExpression())
+        self.assertNotEqual(hash(Predicate(ns.bse.filesize)), hash(PredicateExpression()))
+        # comparison respects predicate
+        self.assertNotEqual(Predicate(ns.bse.filesize), Predicate(ns.bse.filename))
+        self.assertNotEqual(hash(Predicate(ns.bse.filesize)), hash(Predicate(ns.bse.filename)))
+        # comparison respects reverse
+        self.assertNotEqual(Predicate(ns.bse.filesize, True), Predicate(ns.bse.filesize, False))
+        self.assertNotEqual(hash(Predicate(ns.bse.filesize, True)), hash(Predicate(ns.bse.filesize, False)))
+        # string conversion
+        self.assertEqual(str(Predicate(ns.bse.filesize)), f'Predicate({ns.bse.filesize}, False)')
+        self.assertEqual(str(Predicate(ns.bse.filesize, True)),
+            f'Predicate({ns.bse.filesize}, True)')
+        self.assertEqual(repr(Predicate(ns.bse.filesize)), f'Predicate({ns.bse.filesize}, False)')
+        self.assertEqual(repr(Predicate(ns.bse.filesize, True)),
+            f'Predicate({ns.bse.filesize}, True)')
+
+    def test_members(self):
+        # member returns predicate
+        # predicate must be an URI
+        self.assertEqual(Predicate(ns.bse.filesize).predicate, ns.bse.filesize)
+        self.assertEqual(Predicate(URI('hello world')).predicate, URI('hello world'))
+        self.assertRaises(TypeError, Predicate, 1234)
+        self.assertRaises(TypeError, Predicate, FilterExpression())
+        self.assertRaises(TypeError, Predicate, FilterExpression())
+        # reverse becomes a boolean
+        self.assertEqual(Predicate(ns.bse.filesize, True).reverse, True)
+        self.assertEqual(Predicate(ns.bse.filesize, False).reverse, False)
+        self.assertEqual(Predicate(ns.bse.filesize, 'abc').reverse, True)
+
+
+class TestOneOf(unittest.TestCase):
+    def test_essentials(self):
+        expr = {Predicate(ns.bse.filename), Predicate(ns.bse.filesize)}
+        # comparison
+        self.assertEqual(OneOf(expr), OneOf(expr))
+        self.assertEqual(hash(OneOf(expr)), hash(OneOf(expr)))
+        # comparison respects type
+        self.assertNotEqual(OneOf(expr), PredicateExpression())
+        self.assertNotEqual(hash(OneOf(expr)), hash(PredicateExpression()))
+        # comparison respects expression
+        self.assertNotEqual(OneOf(expr), OneOf(Predicate(ns.bse.filename)))
+        self.assertNotEqual(hash(OneOf(expr)), hash(OneOf(Predicate(ns.bse.filename))))
+        # string conversion
+        self.assertEqual(str(OneOf(Predicate(ns.bse.filesize))),
+            f'OneOf({{Predicate({ns.bse.filesize}, False)}})')
+        self.assertEqual(repr(OneOf(Predicate(ns.bse.filesize))),
+            f'OneOf({{Predicate({ns.bse.filesize}, False)}})')
+
+    def test_expression(self):
+        class Foo(): pass
+        # can pass expressions as arguments
+        self.assertSetEqual(OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename)).expr,
+            {Predicate(ns.bse.filesize), Predicate(ns.bse.filename)})
+        # can pass one expressions as argument
+        self.assertSetEqual(OneOf(Predicate(ns.bse.filesize)).expr,
+            {Predicate(ns.bse.filesize)})
+        # can pass expressions as iterator
+        self.assertSetEqual(OneOf(iter((Predicate(ns.bse.filesize), Predicate(ns.bse.filename)))).expr,
+            {Predicate(ns.bse.filesize), Predicate(ns.bse.filename)})
+        # can pass expressions as generator
+        def gen():
+            yield Predicate(ns.bse.filesize)
+            yield Predicate(ns.bse.filename)
+        self.assertSetEqual(OneOf(gen()).expr,
+            {Predicate(ns.bse.filesize), Predicate(ns.bse.filename)})
+        # can pass expressions as list-like
+        self.assertSetEqual(OneOf((Predicate(ns.bse.filesize), Predicate(ns.bse.filename))).expr,
+            {Predicate(ns.bse.filesize), Predicate(ns.bse.filename)})
+        # can pass one expression as list-like
+        self.assertSetEqual(OneOf([Predicate(ns.bse.filesize)]).expr,
+            {Predicate(ns.bse.filesize)})
+        # must pass expressions
+        self.assertRaises(TypeError, OneOf, Foo(), Foo())
+        self.assertRaises(TypeError, OneOf, [Foo(), Foo()])
+        # must pass at least one expression
+        self.assertRaises(AttributeError, OneOf)
+
+        # iter
+        self.assertSetEqual(set(iter(OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename)))),
+            {Predicate(ns.bse.filesize), Predicate(ns.bse.filename)})
+        # contains
+        self.assertIn(Predicate(ns.bse.filesize),
+            OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename)))
+        self.assertNotIn(Predicate(ns.bse.tag),
+            OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename)))
+        # len
+        self.assertEqual(len(OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename))), 2)
+        self.assertEqual(len(OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename), Predicate(ns.bse.tag))), 3)
+
+
+    def testIsIn(self):
+        # 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')))
+        # 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')))
+        # can pass expressions as generator
+        def gen():
+            yield 'http://example.com/entity#1234'
+            yield 'http://example.com/entity#4321'
+        self.assertEqual(IsIn(gen()),
+            Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321')))
+        # can pass expressions as list-like
+        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 list-like
+        self.assertEqual(IsIn(['http://example.com/entity#1234']),
+            Or(Is('http://example.com/entity#1234')))
+
+
+    def testIsNotIn(self):
+        # 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'))))
+        # 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'))))
+        # can pass expressions as generator
+        def gen():
+            yield 'http://example.com/entity#1234'
+            yield 'http://example.com/entity#4321'
+        self.assertEqual(IsNotIn(gen()),
+            Not(Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321'))))
+        # can pass expressions as list-like
+        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 list-like
+        self.assertEqual(IsNotIn(['http://example.com/entity#1234']),
+            Not(Or(Is('http://example.com/entity#1234'))))
+
 
 
 ## main ##
diff --git a/test/query/test_validator.py b/test/query/test_validator.py
index 0e88ad3..4f8364a 100644
--- a/test/query/test_validator.py
+++ b/test/query/test_validator.py
@@ -8,6 +8,10 @@ Author: Matthias Baumgartner, 2022
 import unittest
 
 # bsfs imports
+from bsfs import schema as _schema
+from bsfs.namespace import ns
+from bsfs.query import ast
+from bsfs.utils import errors
 
 # objects to test
 from bsfs.query.validator import Filter
@@ -16,10 +20,237 @@ from bsfs.query.validator import Filter
 ## code ##
 
 class TestFilter(unittest.TestCase):
-    def test_parse(self):
-        raise NotImplementedError()
+    def setUp(self):
+        self.schema = _schema.Schema.from_string('''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+            bsfs:URI rdfs:subClassOf bsfs:Literal .
+
+            bsfs:Tag rdfs:subClassOf bsfs:Node .
+            xsd:string rdfs:subClassOf bsfs:Literal .
+            xsd:integer rdfs:subClassOf bsfs:Literal .
+
+            bse:comment rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Node ;
+                rdfs:range xsd:string ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            bse:filesize rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:integer ;
+                bsfs:unique "true"^^xsd:boolean .
+
+            bse:tag rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Tag ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            bse:label rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Tag ;
+                rdfs:range xsd:string ;
+                bsfs:unique "true"^^xsd:boolean .
+
+            bse:buddy rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Node ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            ''')
+        self.validate = Filter(self.schema)
+
+    def test_call(self):
+        # root_type must be a _schema.Node
+        self.assertRaises(TypeError, self.validate, 1234, None)
+        self.assertRaises(TypeError, self.validate, '1234', None)
+        self.assertRaises(TypeError, self.validate, self.schema.literal(ns.bsfs.URI), None)
+        # root_type must exist in the schema
+        self.assertRaises(errors.ConsistencyError, self.validate, self.schema.node(ns.bsfs.Node).get_child(ns.bsfs.Image), None)
+        self.assertRaises(errors.ConsistencyError, self.validate, self.schema.node(ns.bsfs.Entity).get_child(ns.bsfs.Image), None)
+        # valid query returns true
+        self.assertTrue(self.validate(self.schema.node(ns.bsfs.Entity),
+            ast.filter.Any(ast.filter.OneOf(ns.bse.tag, ns.bse.buddy),
+                ast.filter.Or(
+                    ast.filter.Is('http://example.com/symbol#1234'),
+                    ast.filter.All(ns.bse.comment, ast.filter.StartsWith('foo')),
+                    ast.filter.And(
+                        ast.filter.Has(ns.bse.comment, ast.filter.Or(
+                            ast.filter.GreaterThan(5),
+                            ast.filter.LessThan(1),
+                            )
+                        ),
+                        ast.filter.Not(ast.filter.Any(ns.bse.comment,
+                            ast.filter.Not(ast.filter.Equals('hello world')))),
+                    )))))
+        # invalid paths raise consistency error
+        self.assertRaises(errors.ConsistencyError, self.validate, self.schema.node(ns.bsfs.Entity),
+            ast.filter.Any(ast.filter.OneOf(ns.bse.tag, ns.bse.buddy),
+            ast.filter.Or(
+                ast.filter.All(ns.bse.comment, ast.filter.Equals('hello world')),
+                ast.filter.All(ns.bse.label, ast.filter.Equals('hello world')), # domain mismatch
+                )))
+
+    def test_routing(self):
+        self.assertRaises(errors.BackendError, self.validate._parse_filter_expression, ast.filter.FilterExpression(), self.schema.node(ns.bsfs.Node))
+        self.assertRaises(errors.BackendError, self.validate._parse_predicate_expression, ast.filter.PredicateExpression())
+
+    def test_predicate(self):
+        # predicate must be in the schema
+        self.assertRaises(errors.ConsistencyError, self.validate._predicate, ast.filter.Predicate(ns.bse.invalid))
+        # predicate must have a range
+        self.assertRaises(errors.BackendError, self.validate._predicate, ast.filter.Predicate(ns.bsfs.Predicate))
+        # predicate returns domain and range
+        self.assertEqual(self.validate._predicate(ast.filter.Predicate(ns.bse.tag)),
+            (self.schema.node(ns.bsfs.Entity), self.schema.node(ns.bsfs.Tag)))
+        # reverse is applied
+        self.assertEqual(self.validate._predicate(ast.filter.Predicate(ns.bse.tag, reverse=True)),
+            (self.schema.node(ns.bsfs.Tag), self.schema.node(ns.bsfs.Entity)))
+
+    def test_one_of(self):
+        # domains must both be nodes or literals
+        self.assertRaises(errors.ConsistencyError, self.validate._one_of, ast.filter.OneOf(ns.bse.tag, ast.filter.Predicate(ns.bse.label, reverse=True)))
+        # domains must be related
+        self.assertRaises(errors.ConsistencyError, self.validate._one_of, ast.filter.OneOf(ns.bse.tag, ns.bse.label))
+        # ranges must both be nodes or literals
+        self.assertRaises(errors.ConsistencyError, self.validate._one_of, ast.filter.OneOf(ns.bse.tag, ns.bse.comment))
+        # ranges must be related
+        self.assertRaises(errors.ConsistencyError, self.validate._one_of, ast.filter.OneOf(ns.bse.tag, ast.filter.Predicate(ns.bse.buddy, reverse=True)))
+        # one_of returns most specific domain
+        self.assertEqual(self.validate._one_of(ast.filter.OneOf(ns.bse.comment, ns.bse.label)),
+            (self.schema.node(ns.bsfs.Tag), self.schema.literal(ns.xsd.string)))
+        # one_of returns the most generic range
+        self.assertEqual(self.validate._one_of(ast.filter.OneOf(ns.bse.tag, ns.bse.buddy)),
+            (self.schema.node(ns.bsfs.Entity), self.schema.node(ns.bsfs.Node)))
+
+    def test_branch(self):
+        # type must be a node
+        self.assertRaises(errors.ConsistencyError, self.validate._branch, self.schema.literal(ns.bsfs.Literal), None)
+        # type must be in the schema
+        self.assertRaises(errors.ConsistencyError, self.validate._branch, self.schema.node(ns.bsfs.Node).get_child(ns.bsfs.Invalid), None)
+        # predicate is verified
+        self.assertRaises(errors.ConsistencyError, self.validate._branch, self.schema.node(ns.bsfs.Entity),
+            ast.filter.Any(ns.bsfs.Invalid, ast.filter.Is('http://example.com/entity#1234')))
+        # predicate must match the domain
+        self.assertRaises(errors.ConsistencyError, self.validate._branch, self.schema.node(ns.bsfs.Node),
+            ast.filter.Any(ns.bse.tag, ast.filter.Is('http://example.com/tag#1234')))
+        self.assertRaises(errors.ConsistencyError, self.validate._branch, self.schema.node(ns.bsfs.Tag),
+            ast.filter.Any(ns.bse.tag, ast.filter.Is('http://example.com/tag#1234')))
+        # child expression must be valid
+        self.assertRaises(errors.ConsistencyError, self.validate._branch, self.schema.node(ns.bsfs.Entity),
+            ast.filter.Any(ns.bse.tag, ast.filter.Equals('hello world')))
+        # branch accepts valid expressions
+        self.assertIsNone(self.validate._branch(self.schema.node(ns.bsfs.Entity),
+            ast.filter.Any(ns.bse.tag, ast.filter.Is('http://example.com/entity#1234'))))
+        self.assertIsNone(self.validate._branch(self.schema.node(ns.bsfs.Entity),
+            ast.filter.All(ns.bse.tag, ast.filter.Is('http://example.com/entity#1234'))))
+
+    def test_agg(self):
+        # agg evaluates child expressions
+        self.assertRaises(errors.ConsistencyError, self.validate._agg, self.schema.node(ns.bsfs.Entity),
+            ast.filter.And(ast.filter.Is('http://example.com/entity#1234'), ast.filter.Equals('hello world')))
+        self.assertRaises(errors.ConsistencyError, self.validate._agg, self.schema.literal(ns.xsd.string),
+            ast.filter.And(ast.filter.Is('http://example.com/entity#1234'), ast.filter.Equals('hello world')))
+        self.assertRaises(errors.ConsistencyError, self.validate._agg, self.schema.node(ns.bsfs.Entity),
+            ast.filter.Or(ast.filter.Is('http://example.com/entity#1234'), ast.filter.Equals('hello world')))
+        self.assertRaises(errors.ConsistencyError, self.validate._agg, self.schema.literal(ns.xsd.string),
+            ast.filter.Or(ast.filter.Is('http://example.com/entity#1234'), ast.filter.Equals('hello world')))
+        # agg works on nodes
+        self.assertIsNone(self.validate._agg(self.schema.node(ns.bsfs.Entity),
+            ast.filter.And(ast.filter.Is('http://example.com/entity#1234'), ast.filter.Is('http://example.com/entity#4321'))))
+        self.assertIsNone(self.validate._agg(self.schema.node(ns.bsfs.Entity),
+            ast.filter.Or(ast.filter.Is('http://example.com/entity#1234'), ast.filter.Is('http://example.com/entity#4321'))))
+        # agg works on literals
+        self.assertIsNone(self.validate._agg(self.schema.literal(ns.xsd.string),
+            ast.filter.And(ast.filter.Equals('foobar'), ast.filter.Equals('hello world'))))
+        self.assertIsNone(self.validate._agg(self.schema.literal(ns.xsd.string),
+            ast.filter.Or(ast.filter.Equals('foobar'), ast.filter.Equals('hello world'))))
+
+    def test_not(self):
+        # not evaluates child expressions
+        self.assertRaises(errors.ConsistencyError, self.validate._not, self.schema.node(ns.bsfs.Entity),
+            ast.filter.Not(ast.filter.Equals('hello world')))
+        self.assertRaises(errors.ConsistencyError, self.validate._not, self.schema.literal(ns.xsd.string),
+            ast.filter.Not(ast.filter.Is('http://example.com/entity#1234')))
+        # not works on nodes
+        self.assertIsNone(self.validate._not(self.schema.node(ns.bsfs.Entity),
+            ast.filter.Not(ast.filter.Is('http://example.com/entity#1234'))))
+        # not works on literals
+        self.assertIsNone(self.validate._not(self.schema.literal(ns.xsd.string),
+            ast.filter.Not(ast.filter.Equals('hello world'))))
+
+    def test_has(self):
+        # type must be node
+        self.assertRaises(errors.ConsistencyError, self.validate._has, self.schema.literal(ns.bsfs.Literal),
+            ast.filter.Has(ns.bse.tag))
+        # type must be in the schema
+        self.assertRaises(errors.ConsistencyError, self.validate._has, self.schema.node(ns.bsfs.Node).get_child(ns.bsfs.Invalid),
+            ast.filter.Has(ns.bse.tag))
+        # has checks predicate
+        self.assertRaises(errors.ConsistencyError, self.validate._has, self.schema.node(ns.bsfs.Entity),
+            ast.filter.Has(ns.bse.invalid))
+        # predicate must match domain
+        self.assertRaises(errors.ConsistencyError, self.validate._has, self.schema.node(ns.bsfs.Tag),
+            ast.filter.Has(ns.bse.tag))
+        # has checks count expression
+        self.assertRaises(errors.ConsistencyError, self.validate._has, self.schema.node(ns.bsfs.Entity),
+            ast.filter.Has(ns.bse.tag, ast.filter.Is('http://example.com/entity#1234')))
+        # has accepts correct expressions
+        self.assertIsNone(self.validate._has(self.schema.node(ns.bsfs.Entity), ast.filter.Has(ns.bse.tag, ast.filter.GreaterThan(5))))
+
+    def test_is(self):
+        # type must be node
+        self.assertRaises(errors.ConsistencyError, self.validate._is, self.schema.literal(ns.bsfs.Literal),
+            ast.filter.Is('http://example.com/foo'))
+        # type must be in the schema
+        self.assertRaises(errors.ConsistencyError, self.validate._is, self.schema.node(ns.bsfs.Node).get_child(ns.bsfs.Invalid),
+            ast.filter.Is('http://example.com/foo'))
+        # is accepts correct expressions
+        self.assertIsNone(self.validate._is(self.schema.node(ns.bsfs.Entity), ast.filter.Is('http://example.com/entity#1234')))
+
+    def test_value(self):
+        # type must be literal
+        self.assertRaises(errors.ConsistencyError, self.validate._value, self.schema.node(ns.bsfs.Node),
+            ast.filter.Equals('hello world'))
+        self.assertRaises(errors.ConsistencyError, self.validate._value, self.schema.node(ns.bsfs.Node),
+            ast.filter.Substring('hello world'))
+        self.assertRaises(errors.ConsistencyError, self.validate._value, self.schema.node(ns.bsfs.Node),
+            ast.filter.StartsWith('hello world'))
+        self.assertRaises(errors.ConsistencyError, self.validate._value, self.schema.node(ns.bsfs.Node),
+            ast.filter.EndsWith('hello world'))
+        # type must be in the schema
+        self.assertRaises(errors.ConsistencyError, self.validate._value, self.schema.literal(ns.bsfs.Literal).get_child(ns.bsfs.Invalid),
+            ast.filter.Equals('hello world'))
+        self.assertRaises(errors.ConsistencyError, self.validate._value, self.schema.literal(ns.bsfs.Literal).get_child(ns.bsfs.Invalid),
+            ast.filter.Substring('hello world'))
+        self.assertRaises(errors.ConsistencyError, self.validate._value, self.schema.literal(ns.bsfs.Literal).get_child(ns.bsfs.Invalid),
+            ast.filter.StartsWith('hello world'))
+        self.assertRaises(errors.ConsistencyError, self.validate._value, self.schema.literal(ns.bsfs.Literal).get_child(ns.bsfs.Invalid),
+            ast.filter.EndsWith('hello world'))
+        # value accepts correct expressions
+        self.assertIsNone(self.validate._value(self.schema.literal(ns.xsd.string), ast.filter.Equals('hello world')))
+        self.assertIsNone(self.validate._value(self.schema.literal(ns.xsd.string), ast.filter.Substring('hello world')))
+        self.assertIsNone(self.validate._value(self.schema.literal(ns.xsd.string), ast.filter.StartsWith('hello world')))
+        self.assertIsNone(self.validate._value(self.schema.literal(ns.xsd.string), ast.filter.EndsWith('hello world')))
+
+    def test_bounded(self):
+        # type must be literal
+        self.assertRaises(errors.ConsistencyError, self.validate._bounded, self.schema.node(ns.bsfs.Node),
+            ast.filter.GreaterThan(0))
+        self.assertRaises(errors.ConsistencyError, self.validate._bounded, self.schema.node(ns.bsfs.Node),
+            ast.filter.LessThan(0))
+        # type must be in the schema
+        self.assertRaises(errors.ConsistencyError, self.validate._bounded, self.schema.literal(ns.bsfs.Literal).get_child(ns.bsfs.Invalid),
+            ast.filter.GreaterThan(0))
+        self.assertRaises(errors.ConsistencyError, self.validate._bounded, self.schema.literal(ns.bsfs.Literal).get_child(ns.bsfs.Invalid),
+            ast.filter.LessThan(0))
+        # bounded accepts correct expressions
+        self.assertIsNone(self.validate._bounded(self.schema.literal(ns.xsd.integer), ast.filter.LessThan(0)))
+        self.assertIsNone(self.validate._bounded(self.schema.literal(ns.xsd.integer), ast.filter.GreaterThan(0)))
 
-    # FIXME: subtests for individual functions
 
 
 ## main ##
diff --git a/test/utils/test_commons.py b/test/utils/test_commons.py
index ce73788..3ad6dea 100644
--- a/test/utils/test_commons.py
+++ b/test/utils/test_commons.py
@@ -8,7 +8,7 @@ Author: Matthias Baumgartner, 2022
 import unittest
 
 # objects to test
-from bsfs.utils.commons import typename
+from bsfs.utils.commons import typename, normalize_args
 
 
 ## code ##
@@ -21,6 +21,21 @@ class TestCommons(unittest.TestCase):
         self.assertEqual(typename(123), 'int')
         self.assertEqual(typename(None), 'NoneType')
 
+    def test_normalize_args(self):
+        # one argument
+        self.assertEqual(normalize_args(1), (1, ))
+        # pass as arguments
+        self.assertEqual(normalize_args(1,2,3), (1,2,3))
+        # pass as iterator
+        self.assertEqual(normalize_args(iter([1,2,3])), (1,2,3))
+        # pass as generator
+        self.assertEqual(normalize_args((i for i in range(1, 4))), (1,2,3))
+        self.assertEqual(normalize_args(i for i in range(1, 4)), (1,2,3)) # w/o brackets
+        # pass as iterable
+        self.assertEqual(normalize_args([1,2,3]), (1,2,3))
+        # pass an iterable with a single item
+        self.assertEqual(normalize_args([1]), (1, ))
+
 
 
 ## main ##