Log message for revision 110747:
  Simplify / normalize test suite.

Changed:
  U   
Zope/branches/2.12/src/Products/PluginIndexes/PathIndex/tests/testPathIndex.py

-=-
Modified: 
Zope/branches/2.12/src/Products/PluginIndexes/PathIndex/tests/testPathIndex.py
===================================================================
--- 
Zope/branches/2.12/src/Products/PluginIndexes/PathIndex/tests/testPathIndex.py  
    2010-04-12 14:08:59 UTC (rev 110746)
+++ 
Zope/branches/2.12/src/Products/PluginIndexes/PathIndex/tests/testPathIndex.py  
    2010-04-12 14:40:20 UTC (rev 110747)
@@ -11,15 +11,10 @@
 #
 ##############################################################################
 """PathIndex unit tests.
-
-$Id$
 """
 
 import unittest
-import Testing
-import Zope2
 
-from Products.PluginIndexes.PathIndex.PathIndex import PathIndex
 
 
 class Dummy:
@@ -29,94 +24,141 @@
     def getPhysicalPath(self):
         return self.path.split('/')
 
+DUMMIES = {
+    1 : Dummy("/aa/aa/aa/1.html"),
+    2 : Dummy("/aa/aa/bb/2.html"),
+    3 : Dummy("/aa/aa/cc/3.html"),
+    4 : Dummy("/aa/bb/aa/4.html"),
+    5 : Dummy("/aa/bb/bb/5.html"),
+    6 : Dummy("/aa/bb/cc/6.html"),
+    7 : Dummy("/aa/cc/aa/7.html"),
+    8 : Dummy("/aa/cc/bb/8.html"),
+    9 : Dummy("/aa/cc/cc/9.html"),
+    10 : Dummy("/bb/aa/aa/10.html"),
+    11 : Dummy("/bb/aa/bb/11.html"),
+    12 : Dummy("/bb/aa/cc/12.html"),
+    13 : Dummy("/bb/bb/aa/13.html"),
+    14 : Dummy("/bb/bb/bb/14.html"),
+    15 : Dummy("/bb/bb/cc/15.html"),
+    16 : Dummy("/bb/cc/aa/16.html"),
+    17 : Dummy("/bb/cc/bb/17.html"),
+    18 : Dummy("/bb/cc/cc/18.html")
+}
 
+def _populateIndex(index):
+    for k, v in DUMMIES.items():
+        index.index_object(k, v)
+
+_marker = object()
+
 class PathIndexTests(unittest.TestCase):
     """ Test PathIndex objects """
 
-    def setUp(self):
-        self._index = PathIndex( 'path' )
-        self._values = {
-          1 : Dummy("/aa/aa/aa/1.html"),
-          2 : Dummy("/aa/aa/bb/2.html"),
-          3 : Dummy("/aa/aa/cc/3.html"),
-          4 : Dummy("/aa/bb/aa/4.html"),
-          5 : Dummy("/aa/bb/bb/5.html"),
-          6 : Dummy("/aa/bb/cc/6.html"),
-          7 : Dummy("/aa/cc/aa/7.html"),
-          8 : Dummy("/aa/cc/bb/8.html"),
-          9 : Dummy("/aa/cc/cc/9.html"),
-          10 : Dummy("/bb/aa/aa/10.html"),
-          11 : Dummy("/bb/aa/bb/11.html"),
-          12 : Dummy("/bb/aa/cc/12.html"),
-          13 : Dummy("/bb/bb/aa/13.html"),
-          14 : Dummy("/bb/bb/bb/14.html"),
-          15 : Dummy("/bb/bb/cc/15.html"),
-          16 : Dummy("/bb/cc/aa/16.html"),
-          17 : Dummy("/bb/cc/bb/17.html"),
-          18 : Dummy("/bb/cc/cc/18.html")
-        }
+    def _getTargetClass(self):
+        from Products.PluginIndexes.PathIndex.PathIndex import PathIndex
+        return PathIndex
 
-    def _populateIndex(self):
-        for k, v in self._values.items():
-            self._index.index_object( k, v )
+    def _makeOne(self, id='path', caller=_marker):
+        if caller is not _marker:
+            return self._getTargetClass()(id, caller)
+        return self._getTargetClass()(id)
 
-    def test_z3interfaces(self):
+    def test_class_conforms_to_IPathIndex(self):
         from Products.PluginIndexes.interfaces import IPathIndex
+        from zope.interface.verify import verifyClass
+        verifyClass(IPathIndex, self._getTargetClass())
+
+    def test_instance_conforms_to_IPathIndex(self):
+        from Products.PluginIndexes.interfaces import IPathIndex
+        from zope.interface.verify import verifyObject
+        verifyObject(IPathIndex, self._makeOne())
+
+    def test_class_conforms_to_IUniqueValueIndex(self):
         from Products.PluginIndexes.interfaces import IUniqueValueIndex
         from zope.interface.verify import verifyClass
+        verifyClass(IUniqueValueIndex, self._getTargetClass())
 
-        verifyClass(IPathIndex, PathIndex)
-        verifyClass(IUniqueValueIndex, PathIndex)
+    def test_instance_conforms_to_IUniqueValueIndex(self):
+        from Products.PluginIndexes.interfaces import IUniqueValueIndex
+        from zope.interface.verify import verifyObject
+        verifyObject(IUniqueValueIndex, self._makeOne())
 
-    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 test_numObjects_empty(self):
+        index = self._makeOne()
+        self.assertEqual(index.numObjects(), 0)
 
-    def testUnIndex(self):
-        self._populateIndex()
-        self.assertEqual(self._index.numObjects(), 18)
+    def test_numObjects_filled(self):
+        index = self._makeOne()
+        _populateIndex(index)
+        self.assertEqual(index.numObjects(), len(DUMMIES))
 
-        for k in self._values.keys():
-            self._index.unindex_object(k)
+    def test_getEntryForObject_miss(self):
+        index = self._makeOne()
+        self.assertEqual(index.getEntryForObject(1234), None)
 
-        self.assertEqual(self._index.numObjects(), 0)
-        self.assertEqual(len(self._index._index), 0)
-        self.assertEqual(len(self._index._unindex), 0)
+    def test_getEntryForObject_hit(self):
+        index = self._makeOne()
+        _populateIndex(index)
+        self.assertEqual(index.getEntryForObject(1), DUMMIES[1].path)
 
-    def testReindex(self):
-        self._populateIndex()
-        self.assertEqual(self._index.numObjects(), 18)
+    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)
+        index.index_object(1234, o)
+        self.assertEqual(index.numObjects(), before + 1)
+        index.index_object(1234, o)
+        self.assertEqual(index.numObjects(), before + 1)
 
-    def testUnIndexError(self):
-        self._populateIndex()
-        # this should not raise an error
-        self._index.unindex_object(-1)
+    def test__apply_index_no_match_in_query(self):
+        index = self._makeOne()
+        self.assertEqual(index._apply_index({'foo': 'xxx'}), None)
 
-        # nor should this
-        self._index._unindex[1] = "/broken/thing"
-        self._index.unindex_object(1)
+    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 testRoot(self):
-        self._populateIndex()
+    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))
 
-        queries = (
-            dict(path=dict(query='/', level=0)),
-            dict(path=(('/', 0),)),
-        )
-        for q in queries:
-            res = self._index._apply_index(q)
-            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 @@
             ("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,27 +214,24 @@
             ([('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])
 
 
 def test_suite():
     return unittest.TestSuite((
-        unittest.makeSuite(PathIndexTests),
+            unittest.makeSuite(PathIndexTests),
         ))
-
-if __name__ == '__main__':
-    unittest.main(defaultTest='test_suite')

_______________________________________________
Zope-Checkins maillist  -  Zope-Checkins@zope.org
https://mail.zope.org/mailman/listinfo/zope-checkins

Reply via email to