Simplify / normalize test suite.

src/Products/PluginIndexes/PathIndex/tests/testPathIndex.py

@@ -11,15 +11,10 @@
 #
 ##############################################################################
 """PathIndex unit tests.
-
-$Id$
 """
 
 import unittest
-import Testing
-import Zope2
 
-from Products.PluginIndexes.PathIndex.PathIndex import PathIndex
 
 
 class Dummy:
@@ -29,13 +24,7 @@ class Dummy:
     def getPhysicalPath(self):
         return self.path.split('/')
 
-
-class PathIndexTests(unittest.TestCase):
-    """ Test PathIndex objects """
-
-    def setUp(self):
-        self._index = PathIndex( 'path' )
-        self._values = {
+DUMMIES = {
     1 : Dummy("/aa/aa/aa/1.html"),
     2 : Dummy("/aa/aa/bb/2.html"),
     3 : Dummy("/aa/aa/cc/3.html"),
@@ -54,69 +43,122 @@ class PathIndexTests(unittest.TestCase):
     16 : Dummy("/bb/cc/aa/16.html"),
     17 : Dummy("/bb/cc/bb/17.html"),
     18 : Dummy("/bb/cc/cc/18.html")
-        }
+}
 
-    def _populateIndex(self):
-        for k, v in self._values.items():
-            self._index.index_object( k, v )
+def _populateIndex(index):
+    for k, v in DUMMIES.items():
+        index.index_object(k, v)
 
-    def test_z3interfaces(self):
-        from Products.PluginIndexes.interfaces import IPathIndex
-        from Products.PluginIndexes.interfaces import IUniqueValueIndex
-        from zope.interface.verify import verifyClass
+_marker = object()
 
-        verifyClass(IPathIndex, PathIndex)
-        verifyClass(IUniqueValueIndex, PathIndex)
+class PathIndexTests(unittest.TestCase):
+    """ Test PathIndex objects """
 
-    def testEmpty(self):
-        self.assertEqual(self._index.numObjects() ,0)
-        self.assertEqual(self._index.getEntryForObject(1234), None)
-        self._index.unindex_object( 1234 ) # nothrow
-        self.assertEqual(self._index._apply_index(dict(suxpath="xxx")), None)
+    def _getTargetClass(self):
+        from Products.PluginIndexes.PathIndex.PathIndex import PathIndex
+        return PathIndex
 
-    def testUnIndex(self):
-        self._populateIndex()
-        self.assertEqual(self._index.numObjects(), 18)
+    def _makeOne(self, id='path', caller=_marker):
+        if caller is not _marker:
+            return self._getTargetClass()(id, caller)
+        return self._getTargetClass()(id)
 
-        for k in self._values.keys():
-            self._index.unindex_object(k)
+    def test_class_conforms_to_IPathIndex(self):
+        from Products.PluginIndexes.interfaces import IPathIndex
+        from zope.interface.verify import verifyClass
+        verifyClass(IPathIndex, self._getTargetClass())
 
-        self.assertEqual(self._index.numObjects(), 0)
-        self.assertEqual(len(self._index._index), 0)
-        self.assertEqual(len(self._index._unindex), 0)
+    def test_instance_conforms_to_IPathIndex(self):
+        from Products.PluginIndexes.interfaces import IPathIndex
+        from zope.interface.verify import verifyObject
+        verifyObject(IPathIndex, self._makeOne())
 
-    def testReindex(self):
-        self._populateIndex()
-        self.assertEqual(self._index.numObjects(), 18)
+    def test_class_conforms_to_IUniqueValueIndex(self):
+        from Products.PluginIndexes.interfaces import IUniqueValueIndex
+        from zope.interface.verify import verifyClass
+        verifyClass(IUniqueValueIndex, self._getTargetClass())
 
+    def test_instance_conforms_to_IUniqueValueIndex(self):
+        from Products.PluginIndexes.interfaces import IUniqueValueIndex
+        from zope.interface.verify import verifyObject
+        verifyObject(IUniqueValueIndex, self._makeOne())
+
+    def test_numObjects_empty(self):
+        index = self._makeOne()
+        self.assertEqual(index.numObjects(), 0)
+
+    def test_numObjects_filled(self):
+        index = self._makeOne()
+        _populateIndex(index)
+        self.assertEqual(index.numObjects(), len(DUMMIES))
+
+    def test_getEntryForObject_miss(self):
+        index = self._makeOne()
+        self.assertEqual(index.getEntryForObject(1234), None)
+
+    def test_getEntryForObject_hit(self):
+        index = self._makeOne()
+        _populateIndex(index)
+        self.assertEqual(index.getEntryForObject(1), DUMMIES[1].path)
+
+    def test_unindex_object_nonesuch(self):
+        index = self._makeOne()
+        index.unindex_object( 1234 ) # nothrow
+
+    def test_unindex_object_broken_path(self):
+        index = self._makeOne()
+        _populateIndex(index)
+        index._unindex[1] = "/broken/thing"
+        index.unindex_object(1) # nothrow
+
+    def test_unindex_object_found(self):
+        index = self._makeOne()
+        _populateIndex(index)
+
+        for k in DUMMIES.keys():
+            index.unindex_object(k)
+
+        self.assertEqual(index.numObjects(), 0)
+        self.assertEqual(len(index._index), 0)
+        self.assertEqual(len(index._unindex), 0)
+
+    def test_index_object_again(self):
+        index = self._makeOne()
+        _populateIndex(index)
+        before = index.numObjects()
         o = Dummy('/foo/bar')
-        self._index.index_object(19, o)
-        self.assertEqual(self._index.numObjects(), 19)
-        self._index.index_object(19, o)
-        self.assertEqual(self._index.numObjects(), 19)
-
-    def testUnIndexError(self):
-        self._populateIndex()
-        # this should not raise an error
-        self._index.unindex_object(-1)
-
-        # nor should this
-        self._index._unindex[1] = "/broken/thing"
-        self._index.unindex_object(1)
-
-    def testRoot(self):
-        self._populateIndex()
-
-        queries = (
-            dict(path=dict(query='/', level=0)),
-            dict(path=(('/', 0),)),
-        )
-        for q in queries:
-            res = self._index._apply_index(q)
+        index.index_object(1234, o)
+        self.assertEqual(index.numObjects(), before + 1)
+        index.index_object(1234, o)
+        self.assertEqual(index.numObjects(), before + 1)
+
+    def test__apply_index_no_match_in_query(self):
+        index = self._makeOne()
+        self.assertEqual(index._apply_index({'foo': 'xxx'}), None)
+
+    def test__apply_index_nonesuch(self):
+        index = self._makeOne()
+        res = index._apply_index({'path': 'xxx'})
+        self.assertEqual(len(res[0]), 0)
+        self.assertEqual(res[1], ('path',))
+
+    def test___apply_index_root_levelO_dict(self):
+        index = self._makeOne()
+        _populateIndex(index)
+        query = {'path': {'query': '/', 'level': 0}}
+        res = index._apply_index(query)
+        self.assertEqual(list(res[0].keys()), range(1,19))
+
+    def test___apply_index_root_levelO_tuple(self):
+        index = self._makeOne()
+        _populateIndex(index)
+        query = {'path': (('/', 0),)}
+        res = index._apply_index(query)
         self.assertEqual(list(res[0].keys()), range(1,19))
 
-    def testSimpleTests(self):
-        self._populateIndex()
+    def test__apply_index_simple(self):
+        index = self._makeOne()
+        _populateIndex(index)
         tests = [
             # component, level, expected results
             ("aa", 0, [1,2,3,4,5,6,7,8,9]),
@@ -135,34 +177,36 @@ class PathIndexTests(unittest.TestCase):
             ("cc/18.html", 2, [18]),
         ]
 
-        for comp, level, results in tests:
+        for comp, level, expected in tests:
             for path in [comp, "/"+comp, "/"+comp+"/"]:
                 # Test with the level passed in as separate parameter
-                res = self._index._apply_index(dict(path=
-                    dict(query=path, level=level)))
-                self.assertEqual(list(res[0].keys()), results)
+                query = {'path': {'query':path, 'level': level}}
+                res = index._apply_index(query)
+                self.assertEqual(list(res[0].keys()), expected)
 
                 # Test with the level passed in as part of the path parameter
-                res = self._index._apply_index(dict(path=
-                    dict(query=((path, level),))))
-                self.assertEqual(list(res[0].keys()), results)
+                query = {'path': ((path, level),)}
+                res = index._apply_index(query)
+                self.assertEqual(list(res[0].keys()), expected)
 
-    def testComplexOrTests(self):
-        self._populateIndex()
+    def test__apply_index_ComplexOrTests(self):
+        index = self._makeOne()
+        _populateIndex(index)
         tests = [
             (['aa','bb'],1,[1,2,3,4,5,6,10,11,12,13,14,15]),
             (['aa','bb','xx'],1,[1,2,3,4,5,6,10,11,12,13,14,15]),
             ([('cc',1),('cc',2)],0,[3,6,7,8,9,12,15,16,17,18]),
         ]
 
-        for lst, level, results in tests:
-            res = self._index._apply_index(dict(path=
-                dict(query=lst, level=level, operator='or')))
+        for lst, level, expected in tests:
+            query = {'path': {'query': lst, 'level': level, 'operator': 'or'}}
+            res = index._apply_index(query)
             lst = list(res[0].keys())
-            self.assertEqual(lst, results)
+            self.assertEqual(lst, expected)
 
-    def testComplexANDTests(self):
-        self._populateIndex()
+    def test__apply_index_ComplexANDTests(self):
+        index = self._makeOne()
+        _populateIndex(index)
         tests = [
             # Path query (as list or (path, level) tuple), level, expected
             (['aa','bb'], 1, []),
@@ -170,19 +214,19 @@ class PathIndexTests(unittest.TestCase):
             ([('aa',0), ('cc',2)], 0, [3,6,9]),
         ]
 
-        for lst, level, results in tests:
-            res = self._index._apply_index(dict(path=
-                dict(query=lst, level=level, operator='and')))
+        for lst, level, expected in tests:
+            query = {'path': {'query': lst, 'level': level, 'operator': 'and'}}
+            res = index._apply_index(query)
             lst = list(res[0].keys())
-            self.assertEqual(lst, results)
+            self.assertEqual(lst, expected)
 
-    def testQueryPathReturnedInResult(self):
-        index = self._index
+    def test__apply_index_QueryPathReturnedInResult(self):
+        index = self._makeOne()
         index.index_object(1, Dummy("/ff"))
         index.index_object(2, Dummy("/ff/gg"))
         index.index_object(3, Dummy("/ff/gg/3.html"))
         index.index_object(4, Dummy("/ff/gg/4.html"))
-        res = index._apply_index(dict(path=dict(query='/ff/gg')))
+        res = index._apply_index({'path': {'query': '/ff/gg'}})
         lst = list(res[0].keys())
         self.assertEqual(lst, [2, 3, 4])
 
@@ -191,6 +235,3 @@ def test_suite():
     return unittest.TestSuite((
             unittest.makeSuite(PathIndexTests),
         ))
-
-if __name__ == '__main__':
-    unittest.main(defaultTest='test_suite')