[Checkins] SVN: zope.index/trunk/src/zope/index/text/tests/test_index.py Test both 32bit and 64bit versions; put text index tests into canonical form:
Tres Seaver
tseaver at palladion.com
Wed Jun 10 13:58:58 EDT 2009
Log message for revision 100805:
Test both 32bit and 64bit versions; put text index tests into canonical form:
o No module-scope imports of modules-under-test.
o Use standard '_getTargetClass' / '_makeOne' pattern, rather than creating
object-under-test in 'setUp'.
o Remove support for running test module as script.
Changed:
U zope.index/trunk/src/zope/index/text/tests/test_index.py
-=-
Modified: zope.index/trunk/src/zope/index/text/tests/test_index.py
===================================================================
--- zope.index/trunk/src/zope/index/text/tests/test_index.py 2009-06-10 17:42:40 UTC (rev 100804)
+++ zope.index/trunk/src/zope/index/text/tests/test_index.py 2009-06-10 17:58:58 UTC (rev 100805)
@@ -15,178 +15,211 @@
$Id$
"""
-from unittest import TestCase, TestSuite, main, makeSuite
+import unittest
-import BTrees
+class IndexTestBase:
+ # Subclasses must define '_getTargetClass' and '_getBTreesFamily'
+ def _makeOne(self):
+ from zope.index.text.lexicon import Lexicon
+ from zope.index.text.lexicon import Splitter
+ lexicon = Lexicon(Splitter())
+ return self._getTargetClass()(lexicon, family=self._getBTreesFamily())
-from zope.index.text.lexicon import Lexicon, Splitter
-from zope.index.text.cosineindex import CosineIndex
-from zope.index.text.okapiindex import OkapiIndex
+ def _check_index_has_document(self, index, docid, word_count=5):
+ self.assertEqual(index.documentCount(), 1)
+ self.assertEqual(index.wordCount(), word_count)
+ self.assertEqual(index._lexicon.wordCount(), word_count)
+ self.assert_(index.has_doc(docid))
+ self.assert_(index._docweight[docid])
+ self.assertEqual(len(index._docweight), 1)
+ self.assertEqual(len(index._wordinfo), word_count)
+ self.assertEqual(len(index._docwords), 1)
+ self.assertEqual(len(index.get_words(docid)), word_count)
+ self.assertEqual(len(index._wordinfo),
+ index.wordCount())
+ for map in index._wordinfo.values():
+ self.assertEqual(len(map), 1)
+ self.assert_(map.has_key(docid))
-# Subclasses must set a class variable IndexFactory to the appropriate
-# index object constructor.
+ def _check_index_is_empty(self, index):
+ self.assertEqual(len(index._docweight), 0)
+ self.assertEqual(len(index._wordinfo), 0)
+ self.assertEqual(len(index._docwords), 0)
+ self.assertEqual(len(index._wordinfo),
+ index.wordCount())
-class IndexTest(TestCase):
+ def test_empty(self):
+ index = self._makeOne()
+ self._check_index_is_empty(index)
- def setUp(self):
- self.lexicon = Lexicon(Splitter())
- self.index = self.IndexFactory(self.lexicon)
+ def test_index_document(self):
+ doc = "simple document contains five words"
+ index = self._makeOne()
+ self.assert_(not index.has_doc(1))
+ index.index_doc(1, doc)
+ self._check_index_has_document(index, 1)
-
- def _test_index_document_assertions(self, DOCID=1):
- self.assertEqual(self.index.documentCount(), 1)
- self.assertEqual(self.index.wordCount(), 5)
- self.assertEqual(self.lexicon.wordCount(), 5)
- self.assert_(self.index.has_doc(DOCID))
- self.assert_(self.index._docweight[DOCID])
- self.assertEqual(len(self.index._docweight), 1)
- self.assertEqual(len(self.index._wordinfo), 5)
- self.assertEqual(len(self.index._docwords), 1)
- self.assertEqual(len(self.index.get_words(DOCID)), 5)
- self.assertEqual(len(self.index._wordinfo),
- self.index.wordCount())
- for map in self.index._wordinfo.values():
- self.assertEqual(len(map), 1)
- self.assert_(map.has_key(DOCID))
-
- def test_index_document(self, DOCID=1):
+ def test_unindex_document(self):
doc = "simple document contains five words"
- self.assert_(not self.index.has_doc(DOCID))
- self.index.index_doc(DOCID, doc)
- self._test_index_document_assertions(DOCID)
+ index = self._makeOne()
+ index.index_doc(1, doc)
+ index.unindex_doc(1)
+ self._check_index_is_empty(index)
def test_unindex_document_absent_docid(self):
- self.test_index_document(1)
- self.index.unindex_doc(2)
- self._test_index_document_assertions(1)
+ doc = "simple document contains five words"
+ index = self._makeOne()
+ index.index_doc(1, doc)
+ index.unindex_doc(2)
+ self._check_index_has_document(index, 1)
def test_clear(self):
- self.test_index_document(1)
- self.index.clear()
- self._test_unindex_document_assertions()
+ doc = "simple document contains five words"
+ index = self._makeOne()
+ index.index_doc(1, doc)
+ index.clear()
+ self._check_index_is_empty(index)
- def _test_unindex_document_assertions(self):
- self.assertEqual(len(self.index._docweight), 0)
- self.assertEqual(len(self.index._wordinfo), 0)
- self.assertEqual(len(self.index._docwords), 0)
- self.assertEqual(len(self.index._wordinfo),
- self.index.wordCount())
-
- def test_unindex_document(self):
- DOCID = 1
- self.test_index_document(DOCID)
- self.index.unindex_doc(DOCID)
- self._test_unindex_document_assertions()
-
-
def test_index_two_documents(self):
- self.test_index_document()
- doc = "another document just four"
- DOCID = 2
- self.index.index_doc(DOCID, doc)
- self.assert_(self.index._docweight[DOCID])
- self.assertEqual(len(self.index._docweight), 2)
- self.assertEqual(len(self.index._wordinfo), 8)
- self.assertEqual(len(self.index._docwords), 2)
- self.assertEqual(len(self.index.get_words(DOCID)), 4)
- self.assertEqual(len(self.index._wordinfo),
- self.index.wordCount())
- wids = self.lexicon.termToWordIds("document")
+ doc1 = "simple document contains five words"
+ doc2 = "another document just four"
+ index = self._makeOne()
+ index.index_doc(1, doc1)
+ index.index_doc(2, doc2)
+ self.failUnless(index._docweight[2])
+ self.assertEqual(len(index._docweight), 2)
+ self.assertEqual(len(index._wordinfo), 8)
+ self.assertEqual(len(index._docwords), 2)
+ self.assertEqual(len(index.get_words(2)), 4)
+ self.assertEqual(len(index._wordinfo),
+ index.wordCount())
+ wids = index._lexicon.termToWordIds("document")
self.assertEqual(len(wids), 1)
document_wid = wids[0]
- for wid, map in self.index._wordinfo.items():
+ for wid, map in index._wordinfo.items():
if wid == document_wid:
self.assertEqual(len(map), 2)
self.assert_(map.has_key(1))
- self.assert_(map.has_key(DOCID))
+ self.assert_(map.has_key(2))
else:
self.assertEqual(len(map), 1)
def test_index_two_unindex_one(self):
# index two documents, unindex one, and test the results
- self.test_index_two_documents()
- self.index.unindex_doc(1)
- DOCID = 2
- self.assertEqual(len(self.index._docweight), 1)
- self.assert_(self.index._docweight[DOCID])
- self.assertEqual(len(self.index._wordinfo), 4)
- self.assertEqual(len(self.index._docwords), 1)
- self.assertEqual(len(self.index.get_words(DOCID)), 4)
- self.assertEqual(len(self.index._wordinfo),
- self.index.wordCount())
- for map in self.index._wordinfo.values():
+ doc1 = "simple document contains five words"
+ doc2 = "another document just four"
+ index = self._makeOne()
+ index.index_doc(1, doc1)
+ index.index_doc(2, doc2)
+ index.unindex_doc(1)
+ self.assertEqual(len(index._docweight), 1)
+ self.assert_(index._docweight[2])
+ self.assertEqual(len(index._wordinfo), 4)
+ self.assertEqual(len(index._docwords), 1)
+ self.assertEqual(len(index.get_words(2)), 4)
+ self.assertEqual(len(index._wordinfo),
+ index.wordCount())
+ for map in index._wordinfo.values():
self.assertEqual(len(map), 1)
- self.assert_(map.has_key(DOCID))
+ self.assert_(map.has_key(2))
- def test_index_duplicated_words(self, DOCID=1):
+ def test_index_duplicated_words(self):
doc = "very simple repeat repeat repeat document test"
- self.index.index_doc(DOCID, doc)
- self.assert_(self.index._docweight[DOCID])
- self.assertEqual(len(self.index._wordinfo), 5)
- self.assertEqual(len(self.index._docwords), 1)
- self.assertEqual(len(self.index.get_words(DOCID)), 7)
- self.assertEqual(len(self.index._wordinfo),
- self.index.wordCount())
- wids = self.lexicon.termToWordIds("repeat")
+ index = self._makeOne()
+ index.index_doc(1, doc)
+ self.assert_(index._docweight[1])
+ self.assertEqual(len(index._wordinfo), 5)
+ self.assertEqual(len(index._docwords), 1)
+ self.assertEqual(len(index.get_words(1)), 7)
+ self.assertEqual(len(index._wordinfo),
+ index.wordCount())
+ wids = index._lexicon.termToWordIds("repeat")
self.assertEqual(len(wids), 1)
repititive_wid = wids[0]
- for wid, map in self.index._wordinfo.items():
+ for wid, map in index._wordinfo.items():
self.assertEqual(len(map), 1)
- self.assert_(map.has_key(DOCID))
+ self.assert_(map.has_key(1))
def test_simple_query_oneresult(self):
- self.index.index_doc(1, 'not the same document')
- results = self.index.search("document")
+ index = self._makeOne()
+ index.index_doc(1, 'not the same document')
+ results = index.search("document")
self.assertEqual(list(results.keys()), [1])
def test_simple_query_noresults(self):
- self.index.index_doc(1, 'not the same document')
- results = self.index.search("frobnicate")
+ index = self._makeOne()
+ index.index_doc(1, 'not the same document')
+ results = index.search("frobnicate")
self.assertEqual(list(results.keys()), [])
def test_query_oneresult(self):
- self.index.index_doc(1, 'not the same document')
- self.index.index_doc(2, 'something about something else')
- results = self.index.search("document")
+ index = self._makeOne()
+ index.index_doc(1, 'not the same document')
+ index.index_doc(2, 'something about something else')
+ results = index.search("document")
self.assertEqual(list(results.keys()), [1])
def test_search_phrase(self):
- self.index.index_doc(1, "the quick brown fox jumps over the lazy dog")
- self.index.index_doc(2, "the quick fox jumps lazy over the brown dog")
- results = self.index.search_phrase("quick brown fox")
+ index = self._makeOne()
+ index.index_doc(1, "the quick brown fox jumps over the lazy dog")
+ index.index_doc(2, "the quick fox jumps lazy over the brown dog")
+ results = index.search_phrase("quick brown fox")
self.assertEqual(list(results.keys()), [1])
def test_search_glob(self):
- self.index.index_doc(1, "how now brown cow")
- self.index.index_doc(2, "hough nough browne cough")
- self.index.index_doc(3, "bar brawl")
- results = self.index.search_glob("bro*")
+ index = self._makeOne()
+ index.index_doc(1, "how now brown cow")
+ index.index_doc(2, "hough nough browne cough")
+ index.index_doc(3, "bar brawl")
+ results = index.search_glob("bro*")
self.assertEqual(list(results.keys()), [1, 2])
- results = self.index.search_glob("b*")
+ results = index.search_glob("b*")
self.assertEqual(list(results.keys()), [1, 2, 3])
-class CosineIndexTest(IndexTest):
- IndexFactory = CosineIndex
+class CosineIndexTest32(IndexTestBase, unittest.TestCase):
-class OkapiIndexTest(IndexTest):
- IndexFactory = OkapiIndex
+ def _getTargetClass(self):
+ from zope.index.text.cosineindex import CosineIndex
+ return CosineIndex
-class CosineIndexTest(IndexTest):
+ def _getBTreesFamily(self):
+ import BTrees
+ return BTrees.family32
- @staticmethod
- def IndexFactory(*args, **kw):
- return CosineIndex(family=BTrees.family64, *args, **kw)
+class OkapiIndexTest32(IndexTestBase, unittest.TestCase):
-class OkapiIndexTest(IndexTest):
+ def _getTargetClass(self):
+ from zope.index.text.okapiindex import OkapiIndex
+ return OkapiIndex
- @staticmethod
- def IndexFactory(*args, **kw):
- return OkapiIndex(family=BTrees.family64, *args, **kw)
+ def _getBTreesFamily(self):
+ import BTrees
+ return BTrees.family32
+class CosineIndexTest64(IndexTestBase, unittest.TestCase):
+
+ def _getTargetClass(self):
+ from zope.index.text.cosineindex import CosineIndex
+ return CosineIndex
+
+ def _getBTreesFamily(self):
+ import BTrees
+ return BTrees.family64
+
+class OkapiIndexTest64(IndexTestBase, unittest.TestCase):
+
+ def _getTargetClass(self):
+ from zope.index.text.okapiindex import OkapiIndex
+ return OkapiIndex
+
+ def _getBTreesFamily(self):
+ import BTrees
+ return BTrees.family64
+
def test_suite():
- return TestSuite((makeSuite(CosineIndexTest),
- makeSuite(OkapiIndexTest),
+ return unittest.TestSuite((
+ unittest.makeSuite(CosineIndexTest32),
+ unittest.makeSuite(OkapiIndexTest32),
+ unittest.makeSuite(CosineIndexTest64),
+ unittest.makeSuite(OkapiIndexTest64),
))
-
-if __name__=='__main__':
- main(defaultTest='test_suite')
More information about the Checkins
mailing list