Added many tests

Several (the one which are still expected to fail) are disabled.
The enabled one are expected to pass all.

testing/test.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
 import logging
 import unittest
 import time
 import kb
+from minimalkb import __version__
 
 from Queue import Empty
 
@@ -65,6 +69,9 @@ class TestSequenceFunctions(unittest.TestCase):
         self.assertTrue('alfred likes icecream' in self.kb)
         self.assertTrue('alfred likes *' in self.kb)
         self.assertTrue('alfred likes ?smthg' in self.kb)
+        self.assertTrue('* likes *' in self.kb)
+        self.assertFalse('* dislikes *' in self.kb)
+        self.assertTrue('?toto likes *' in self.kb)
         self.assertFalse('alfred likes mygrandmother' in self.kb)
 
         self.kb -= ["alfred rdf:type Human", "alfred likes icecream"]
@@ -83,6 +90,17 @@ class TestSequenceFunctions(unittest.TestCase):
         time.sleep(REASONING_DELAY)
         self.assertTrue('alfred rdf:type Thing' in self.kb)
 
+    def _test_lookup(self):
+        self.assertItemsEqual(self.kb.lookup('alfred'), [])
+
+        self.kb += ["alfred rdf:type Robot"]
+        self.assertItemsEqual(self.kb.lookup('alfred'), [('alfred', 'instance')])
+
+        self.kb += ["nono rdfs:label \"alfred\""]
+        self.assertItemsEqual(self.kb.lookup('alfred'), [('alfred', 'instance'), ('nono', 'unknown')])
+
+        self.assertItemsEqual(self.kb.lookup('Robot'), [('Robot', 'class')])
+
     def test_retrieval(self):
 
         self.assertFalse(self.kb.about("Human"))
@@ -104,6 +122,29 @@ class TestSequenceFunctions(unittest.TestCase):
                               ['johnny'])
 
 
+    def _test_complex_queries(self):
+        self.assertItemsEqual(self.kb["?agent rdf:type Robot", "?agent desires ?obj"], [])
+
+        self.kb += ["nono rdf:type Human", "alfred rdf:type Robot"]
+        self.assertItemsEqual(self.kb["* * *"], [["nono", "rdf:type", "Human"], ["alfred", "rdf:type", "Robot"]])
+
+        self.kb += ["nono desires jump", "alfred desires oil"]
+        self.assertItemsEqual(self.kb["* * *"], [["nono", "desires", "jump"], ["alfred", "desires", "oil"], ["nono", "rdf:type", "Human"], ["alfred", "rdf:type", "Robot"]])
+        self.kb += ["jump rdf:type Action"]
+
+        self.assertItemsEqual(self.kb["?agent rdf:type Robot", "?agent desires ?obj"], [{"agent":"alfred", "obj":"oil"}])
+        self.assertItemsEqual(self.kb["?agent desires ?act", "?act rdf:type Action"], [{"agent":"nono", "act":"jump"}])
+        self.assertItemsEqual(self.kb["?agent desires ?obj"], [{"agent":"alfred", "obj":"oil"}, {"agent":"nono", "obj":"jump"}])
+
+    def _test_update(self):
+        self.kb += ["nono isNice true", "isNice rdf:type owl:FunctionalProperty"]
+        self.assertItemsEqual(self.kb["* isNice true"], ['nono'])
+
+        self.kb += ["nono isNice false"]
+        self.assertFalse(self.kb["* isNice true"])
+        self.assertItemsEqual(self.kb["* isNice false"], ['nono'])
+
+
     def test_events(self):
 
         eventtriggered = [False]
@@ -197,6 +238,63 @@ class TestSequenceFunctions(unittest.TestCase):
         self.assertEqual(id, evtid)
         self.assertItemsEqual(value, [u"batman"])
 
+    def test_complex_events(self):
+
+        evtid = self.kb.subscribe(["?a desires ?act", "?act rdf:type Action"], var="a")
+
+        # should not trigger an event
+        self.kb += ["alfred desires ragnagna"]
+        time.sleep(0.1)
+
+        with self.assertRaises(Empty):
+            self.kb.events.get_nowait()
+
+        # should not trigger an event
+        self.kb += ["ragnagna rdf:type Zorro"]
+        time.sleep(0.1)
+
+        with self.assertRaises(Empty):
+            self.kb.events.get_nowait()
+
+
+        # should trigger an event
+        self.kb += ["ragnagna rdf:type Action"]
+        time.sleep(0.1)
+
+        id, value = self.kb.events.get_nowait()
+        self.assertEqual(id, evtid)
+        self.assertItemsEqual(value, [u"alfred"])
+
+    def test_complex_events_rdfs(self):
+        """ Requires a RDFS reasoner to run.
+        """
+        evtid = self.kb.subscribe(["?a desires ?act", "?act rdf:type Action"], var = "a")
+
+        # should not trigger an event
+        self.kb += ["alfred desires ragnagna"]
+        time.sleep(0.1)
+
+        with self.assertRaises(Empty):
+            self.kb.events.get_nowait()
+
+        # should not trigger an event
+        self.kb += ["ragnagna rdf:type Zorro"]
+        time.sleep(0.1)
+
+        with self.assertRaises(Empty):
+            self.kb.events.get_nowait()
+
+        # should trigger an event
+        self.kb += ["Zorro rdfs:subClassOf Action"]
+        time.sleep(REASONING_DELAY)
+        # required to ensure the event is triggered after classification!
+        self.kb += ["nop nop nop"]
+        time.sleep(0.1)
+
+        id, value = self.kb.events.get_nowait()
+        self.assertEqual(id, evtid)
+        self.assertItemsEqual(value, [u"alfred"])
+
     def test_taxonomy_walking(self):
 
         self.assertFalse(self.kb.classesof("john"))
@@ -220,12 +318,25 @@ class TestSequenceFunctions(unittest.TestCase):
         time.sleep(REASONING_DELAY)
         self.assertFalse(self.kb.classesof("john"))
 
+def version():
+    print("minimalKB tests %s" % __version__)
 
 if __name__ == '__main__':
 
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Test suite for minimalKB.')
+    parser.add_argument('-v', '--version', action='version',
+                       version=version(), help='returns minimalKB version')
+    parser.add_argument('-f', '--failfast', action='store_true',
+                                help='stops at first failed test')
+
+    args = parser.parse_args()
+
+
     kblogger = logging.getLogger("kb")
     console = logging.StreamHandler()
     kblogger.setLevel(logging.DEBUG)
     kblogger.addHandler(console)
     
-    unittest.main(failfast=True)
+    unittest.main(failfast=args.failfast)