Skip to content

Z
Zope
Commit 84f69299 authored by Tres Seaver's avatar Tres Seaver
Browse files
Options

Simplify / normalize test suite.

parent b39b67ab
Hide whitespace changes
Inline Side-by-side
Showing with 150 additions and 109 deletions
src/Products/PluginIndexes/PathIndex/tests/testPathIndex.py
View file @ 84f69299
......@@ -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 @@ class Dummy:
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 _populateIndex(self):
for k, v in self._values.items():
self._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
def _getTargetClass(self):
from Products.PluginIndexes.PathIndex.PathIndex import PathIndex
return PathIndex
verifyClass(IPathIndex, PathIndex)
verifyClass(IUniqueValueIndex, PathIndex)
def _makeOne(self, id='path', caller=_marker):
if caller is not _marker:
return self._getTargetClass()(id, caller)
return self._getTargetClass()(id)
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 testUnIndex(self):
self._populateIndex()
self.assertEqual(self._index.numObjects(), 18)
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)
self.assertEqual(list(res[0].keys()), range(1,19))
def testSimpleTests(self):
self._populateIndex()
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 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,27 +214,24 @@ 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])
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(PathIndexTests),
unittest.makeSuite(PathIndexTests),
))
if __name__ == '__main__':
unittest.main(defaultTest='test_suite')
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7