[Checkins] SVN: zope.index/trunk/src/zope/index/text/tests/test_queryparser.py Finish 'eyeball' coverage for zope.index.text.parsetree module.
Tres Seaver
tseaver at palladion.com
Wed Jun 10 23:05:58 EDT 2009
Log message for revision 100828:
Finish 'eyeball' coverage for zope.index.text.parsetree module.
Changed:
U zope.index/trunk/src/zope/index/text/tests/test_queryparser.py
-=-
Modified: zope.index/trunk/src/zope/index/text/tests/test_queryparser.py
===================================================================
--- zope.index/trunk/src/zope/index/text/tests/test_queryparser.py 2009-06-11 02:50:07 UTC (rev 100827)
+++ zope.index/trunk/src/zope/index/text/tests/test_queryparser.py 2009-06-11 03:05:57 UTC (rev 100828)
@@ -15,54 +15,51 @@
$Id$
"""
-from unittest import TestCase, TestSuite, main, makeSuite
+import unittest
-from zope.interface.verify import verifyClass
-from zope.index.text.interfaces import IQueryParser
-from zope.index.text.interfaces import IQueryParseTree
+class TestQueryParserBase(unittest.TestCase):
-from zope.index.text.queryparser import QueryParser
-from zope.index.text.parsetree import ParseError, ParseTreeNode
-from zope.index.text.parsetree import OrNode, AndNode, NotNode
-from zope.index.text.parsetree import AtomNode, PhraseNode, GlobNode
-from zope.index.text.lexicon import Lexicon, Splitter
+ def _getTargetClass(self):
+ from zope.index.text.queryparser import QueryParser
+ return QueryParser
+ def _makeOne(self, lexicon=None):
+ if lexicon is None
+ lexicon = self._makeLexicon()
+ return self._getTargetClass()(lexicon)
-class TestInterfaces(TestCase):
+ def _makePipeline(self):
+ from zope.index.text.lexicon import Splitter
+ return (Splitter(),)
- def testInterfaces(self):
- verifyClass(IQueryParser, QueryParser)
- verifyClass(IQueryParseTree, ParseTreeNode)
- verifyClass(IQueryParseTree, OrNode)
- verifyClass(IQueryParseTree, AndNode)
- verifyClass(IQueryParseTree, NotNode)
- verifyClass(IQueryParseTree, AtomNode)
- verifyClass(IQueryParseTree, PhraseNode)
- verifyClass(IQueryParseTree, GlobNode)
+ def _makeLexicon(self):
+ from zope.index.text.lexicon import Lexicon
+ return Lexicon(*self._makePipeline())
-
-class TestQueryParserBase(TestCase):
-
- def setUp(self):
- self.lexicon = Lexicon(Splitter())
- self.parser = QueryParser(self.lexicon)
-
- def expect(self, input, output, expected_ignored=[]):
- tree = self.parser.parseQuery(input)
- ignored = self.parser.getIgnored()
- self.compareParseTrees(tree, output)
+ def _expect(self, parser, input, output, expected_ignored=[]):
+ tree = parser.parseQuery(input)
+ ignored = parser.getIgnored()
+ self._compareParseTrees(tree, output)
self.assertEqual(ignored, expected_ignored)
# Check that parseQueryEx() == (parseQuery(), getIgnored())
- ex_tree, ex_ignored = self.parser.parseQueryEx(input)
- self.compareParseTrees(ex_tree, tree)
+ ex_tree, ex_ignored = parser.parseQueryEx(input)
+ self._compareParseTrees(ex_tree, tree)
self.assertEqual(ex_ignored, expected_ignored)
- def failure(self, input):
- self.assertRaises(ParseError, self.parser.parseQuery, input)
- self.assertRaises(ParseError, self.parser.parseQueryEx, input)
+ def _failure(self, parser, input):
+ from zope.index.text.parsetree import ParseError
+ self.assertRaises(ParseError, parser.parseQuery, input)
+ self.assertRaises(ParseError, parser.parseQueryEx, input)
- def compareParseTrees(self, got, expected, msg=None):
+ def _compareParseTrees(self, got, expected, msg=None):
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ from zope.index.text.parsetree import GlobNode
+ from zope.index.text.parsetree import NotNode
+ from zope.index.text.parsetree import OrNode
+ from zope.index.text.parsetree import ParseTreeNode
+ from zope.index.text.parsetree import PhraseNode
if msg is None:
msg = repr(got)
self.assertEqual(isinstance(got, ParseTreeNode), 1)
@@ -78,7 +75,7 @@
self.assertEqual(got.getValue(), expected.getValue(), msg)
elif isinstance(got, NotNode):
self.assertEqual(got.nodeType(), "NOT")
- self.compareParseTrees(got.getValue(), expected.getValue(), msg)
+ self._compareParseTrees(got.getValue(), expected.getValue(), msg)
elif isinstance(got, AndNode) or isinstance(got, OrNode):
self.assertEqual(got.nodeType(),
isinstance(got, AndNode) and "AND" or "OR", msg)
@@ -86,205 +83,324 @@
list2 = expected.getValue()
self.assertEqual(len(list1), len(list2), msg)
for i in range(len(list1)):
- self.compareParseTrees(list1[i], list2[i], msg)
+ self._compareParseTrees(list1[i], list2[i], msg)
class TestQueryParser(TestQueryParserBase):
+ def test_class_conforms_to_IQueryParser(self):
+ from zope.interface.verify import verifyClass
+ from zope.index.text.interfaces import IQueryParser
+ verifyClass(IQueryParser, self._getTargetClass())
+
+ def test_instance_conforms_to_IQueryParser(self):
+ from zope.interface.verify import verifyObject
+ from zope.index.text.interfaces import IQueryParser
+ verifyObject(IQueryParser, self._makeOne())
+
def test001(self):
- self.expect("foo", AtomNode("foo"))
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, "foo", AtomNode("foo"))
def test002(self):
- self.expect("note", AtomNode("note"))
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, "note", AtomNode("note"))
def test003(self):
- self.expect("aa and bb AND cc",
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, "aa and bb AND cc",
AndNode([AtomNode("aa"), AtomNode("bb"), AtomNode("cc")]))
def test004(self):
- self.expect("aa OR bb or cc",
+ from zope.index.text.parsetree import OrNode
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, "aa OR bb or cc",
OrNode([AtomNode("aa"), AtomNode("bb"), AtomNode("cc")]))
def test005(self):
- self.expect("aa AND bb OR cc AnD dd",
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ from zope.index.text.parsetree import OrNode
+ parser = self._makeOne()
+ self._expect(parser, "aa AND bb OR cc AnD dd",
OrNode([AndNode([AtomNode("aa"), AtomNode("bb")]),
AndNode([AtomNode("cc"), AtomNode("dd")])]))
def test006(self):
- self.expect("(aa OR bb) AND (cc OR dd)",
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ from zope.index.text.parsetree import OrNode
+ parser = self._makeOne()
+ self._expect(parser, "(aa OR bb) AND (cc OR dd)",
AndNode([OrNode([AtomNode("aa"), AtomNode("bb")]),
OrNode([AtomNode("cc"), AtomNode("dd")])]))
def test007(self):
- self.expect("aa AND NOT bb",
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ from zope.index.text.parsetree import NotNode
+ parser = self._makeOne()
+ self._expect(parser, "aa AND NOT bb",
AndNode([AtomNode("aa"), NotNode(AtomNode("bb"))]))
def test008(self):
- self.expect("aa NOT bb",
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ from zope.index.text.parsetree import NotNode
+ parser = self._makeOne()
+ self._expect(parser, "aa NOT bb",
AndNode([AtomNode("aa"), NotNode(AtomNode("bb"))]))
def test010(self):
- self.expect('"foo bar"', PhraseNode(["foo", "bar"]))
+ from zope.index.text.parsetree import PhraseNode
+ parser = self._makeOne()
+ self._expect(parser, '"foo bar"', PhraseNode(["foo", "bar"]))
def test011(self):
- self.expect("foo bar", AndNode([AtomNode("foo"), AtomNode("bar")]))
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, "foo bar", AndNode([AtomNode("foo"), AtomNode("bar")]))
def test012(self):
- self.expect('(("foo bar"))"', PhraseNode(["foo", "bar"]))
+ from zope.index.text.parsetree import PhraseNode
+ parser = self._makeOne()
+ self._expect(parser, '(("foo bar"))"', PhraseNode(["foo", "bar"]))
def test013(self):
- self.expect("((foo bar))", AndNode([AtomNode("foo"), AtomNode("bar")]))
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, "((foo bar))", AndNode([AtomNode("foo"), AtomNode("bar")]))
def test014(self):
- self.expect("foo-bar", PhraseNode(["foo", "bar"]))
+ from zope.index.text.parsetree import PhraseNode
+ parser = self._makeOne()
+ self._expect(parser, "foo-bar", PhraseNode(["foo", "bar"]))
def test015(self):
- self.expect("foo -bar", AndNode([AtomNode("foo"),
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ from zope.index.text.parsetree import NotNode
+ parser = self._makeOne()
+ self._expect(parser, "foo -bar", AndNode([AtomNode("foo"),
NotNode(AtomNode("bar"))]))
def test016(self):
- self.expect("-foo bar", AndNode([AtomNode("bar"),
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ from zope.index.text.parsetree import NotNode
+ parser = self._makeOne()
+ self._expect(parser, "-foo bar", AndNode([AtomNode("bar"),
NotNode(AtomNode("foo"))]))
def test017(self):
- self.expect("booh -foo-bar",
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ from zope.index.text.parsetree import NotNode
+ from zope.index.text.parsetree import PhraseNode
+ parser = self._makeOne()
+ self._expect(parser, "booh -foo-bar",
AndNode([AtomNode("booh"),
NotNode(PhraseNode(["foo", "bar"]))]))
def test018(self):
- self.expect('booh -"foo bar"',
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ from zope.index.text.parsetree import NotNode
+ from zope.index.text.parsetree import PhraseNode
+ parser = self._makeOne()
+ self._expect(parser, 'booh -"foo bar"',
AndNode([AtomNode("booh"),
NotNode(PhraseNode(["foo", "bar"]))]))
def test019(self):
- self.expect('foo"bar"',
+ from zope.index.text.parsetree import AndNode
+ parser = self._makeOne()
+ self._expect(parser, 'foo"bar"',
AndNode([AtomNode("foo"), AtomNode("bar")]))
def test020(self):
- self.expect('"foo"bar',
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, '"foo"bar',
AndNode([AtomNode("foo"), AtomNode("bar")]))
def test021(self):
- self.expect('foo"bar"blech',
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, 'foo"bar"blech',
AndNode([AtomNode("foo"), AtomNode("bar"),
AtomNode("blech")]))
def test022(self):
- self.expect("foo*", GlobNode("foo*"))
+ from zope.index.text.parsetree import GlobNode
+ parser = self._makeOne()
+ self._expect(parser, "foo*", GlobNode("foo*"))
def test023(self):
- self.expect("foo* bar", AndNode([GlobNode("foo*"),
+ from zope.index.text.parsetree import AndNode
+ from zope.index.text.parsetree import AtomNode
+ from zope.index.text.parsetree import GlobNode
+ parser = self._makeOne()
+ self._expect(parser, "foo* bar", AndNode([GlobNode("foo*"),
AtomNode("bar")]))
def test101(self):
- self.failure("")
+ parser = self._makeOne()
+ self._failure(parser, "")
def test102(self):
- self.failure("not")
+ parser = self._makeOne()
+ self._failure(parser, "not")
def test103(self):
- self.failure("or")
+ parser = self._makeOne()
+ self._failure(parser, "or")
def test104(self):
- self.failure("and")
+ parser = self._makeOne()
+ self._failure(parser, "and")
def test105(self):
- self.failure("NOT")
+ parser = self._makeOne()
+ self._failure(parser, "NOT")
def test106(self):
- self.failure("OR")
+ parser = self._makeOne()
+ self._failure(parser, "OR")
def test107(self):
- self.failure("AND")
+ parser = self._makeOne()
+ self._failure(parser, "AND")
def test108(self):
- self.failure("NOT foo")
+ parser = self._makeOne()
+ self._failure(parser, "NOT foo")
def test109(self):
- self.failure(")")
+ parser = self._makeOne()
+ self._failure(parser, ")")
def test110(self):
- self.failure("(")
+ parser = self._makeOne()
+ self._failure(parser, "(")
def test111(self):
- self.failure("foo OR")
+ parser = self._makeOne()
+ self._failure(parser, "foo OR")
def test112(self):
- self.failure("foo AND")
+ parser = self._makeOne()
+ self._failure(parser, "foo AND")
def test113(self):
- self.failure("OR foo")
+ parser = self._makeOne()
+ self._failure(parser, "OR foo")
def test114(self):
- self.failure("AND foo")
+ parser = self._makeOne()
+ self._failure(parser, "AND foo")
def test115(self):
- self.failure("(foo) bar")
+ parser = self._makeOne()
+ self._failure(parser, "(foo) bar")
def test116(self):
- self.failure("(foo OR)")
+ parser = self._makeOne()
+ self._failure(parser, "(foo OR)")
def test117(self):
- self.failure("(foo AND)")
+ parser = self._makeOne()
+ self._failure(parser, "(foo AND)")
def test118(self):
- self.failure("(NOT foo)")
+ parser = self._makeOne()
+ self._failure(parser, "(NOT foo)")
def test119(self):
- self.failure("-foo")
+ parser = self._makeOne()
+ self._failure(parser, "-foo")
def test120(self):
- self.failure("-foo -bar")
+ parser = self._makeOne()
+ self._failure(parser, "-foo -bar")
def test121(self):
- self.failure("foo OR -bar")
+ parser = self._makeOne()
+ self._failure(parser, "foo OR -bar")
def test122(self):
- self.failure("foo AND -bar")
+ parser = self._makeOne()
+ self._failure(parser, "foo AND -bar")
class StopWordTestQueryParser(TestQueryParserBase):
- def setUp(self):
- # Only 'stop' is a stopword (but 'and' is still an operator)
- self.lexicon = Lexicon(Splitter(), FakeStopWordRemover())
- self.parser = QueryParser(self.lexicon)
+ def _makePipeline(self):
+ from zope.index.text.lexicon import Splitter
+ return (Splitter(), FakeStopWordRemover())
def test201(self):
- self.expect('and/', AtomNode("and"))
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, 'and/', AtomNode("and"))
def test202(self):
- self.expect('foo AND stop', AtomNode("foo"), ["stop"])
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, 'foo AND stop', AtomNode("foo"), ["stop"])
def test203(self):
- self.expect('foo AND NOT stop', AtomNode("foo"), ["stop"])
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, 'foo AND NOT stop', AtomNode("foo"), ["stop"])
def test204(self):
- self.expect('stop AND foo', AtomNode("foo"), ["stop"])
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, 'stop AND foo', AtomNode("foo"), ["stop"])
def test205(self):
- self.expect('foo OR stop', AtomNode("foo"), ["stop"])
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, 'foo OR stop', AtomNode("foo"), ["stop"])
def test206(self):
- self.expect('stop OR foo', AtomNode("foo"), ["stop"])
+ from zope.index.text.parsetree import AtomNode
+ parser = self._makeOne()
+ self._expect(parser, 'stop OR foo', AtomNode("foo"), ["stop"])
def test301(self):
- self.failure('stop')
+ parser = self._makeOne()
+ self._failure(parser, 'stop')
def test302(self):
- self.failure('stop stop')
+ parser = self._makeOne()
+ self._failure(parser, 'stop stop')
def test303(self):
- self.failure('stop AND stop')
+ parser = self._makeOne()
+ self._failure(parser, 'stop AND stop')
def test304(self):
- self.failure('stop OR stop')
+ parser = self._makeOne()
+ self._failure(parser, 'stop OR stop')
def test305(self):
- self.failure('stop -foo')
+ parser = self._makeOne()
+ self._failure(parser, 'stop -foo')
def test306(self):
- self.failure('stop AND NOT foo')
+ parser = self._makeOne()
+ self._failure(parser, 'stop AND NOT foo')
class FakeStopWordRemover(object):
@@ -294,11 +410,7 @@
def test_suite():
- return TestSuite((makeSuite(TestQueryParser),
- makeSuite(StopWordTestQueryParser),
- makeSuite(TestInterfaces),
- ))
-
-
-if __name__=="__main__":
- main(defaultTest='test_suite')
+ return unittest.TestSuite((
+ unittest.makeSuite(TestQueryParser),
+ unittest.makeSuite(StopWordTestQueryParser),
+ ))
More information about the Checkins
mailing list