def test_set_children_raises(self): test = self._test_set_children_raises test(Word("foo"), [Word("foo")]) test(Phrase('"foo"'), [Word("foo")]) test(Regex("/foo/"), [Word("foo")]) test(SearchField("foo", Word("bar")), []) test(SearchField("foo", Word("bar")), [Word("bar"), Word("baz")]) test(Group(Word("foo")), []) test(Group(Word("foo")), [Word("foo"), Word("bar")]) test(FieldGroup(Word("foo")), []) test(FieldGroup(Word("foo")), [Word("foo"), Word("bar")]) test(Range(Word("20"), Word("30")), []) test(Range(Word("20"), Word("30")), [Word("20"), Word("30"), Word("40")]) test(Proximity(Word("foo")), []) test(Proximity(Word("foo")), [Word("foo"), Word("bar")]) test(Fuzzy(Word("foo")), []) test(Fuzzy(Word("foo")), [Word("foo"), Word("bar")]) test(Boost(Word("foo"), force=1), []) test(Boost(Word("foo"), force=1), [Word("foo"), Word("bar")]) test(Plus(Word("foo")), []) test(Plus(Word("foo")), [Word("foo"), Word("bar")]) test(Not(Word("foo")), []) test(Not(Word("foo")), [Word("foo"), Word("bar")]) test(Prohibit(Word("foo")), []) test(Prohibit(Word("foo")), [Word("foo"), Word("bar")])
def test_bad_fieldgroup(self): check = LuceneCheck() query = FieldGroup(Word("foo")) self.assertFalse(check(query)) self.assertEqual(len(check.errors(query)), 1) self.assertIn("FieldGroup misuse", check.errors(query)[0]) query = OrOperation(FieldGroup(Word("bar")), Word("foo")) self.assertFalse(check(query)) self.assertEqual(len(check.errors(query)), 1) self.assertIn("FieldGroup misuse", check.errors(query)[0])
def test_named_queries_group(self): tree = SearchField("text", FieldGroup(Word("bar"))) set_name(tree.children[0], "a") result = self.transformer(tree) self.assertEqual( result, {"term": { "text": { "value": "bar", "_name": "a" } }}, ) tree = Group(SearchField("text", Word("bar"))) set_name(tree, "a") result = self.transformer(tree) self.assertEqual( result, {"term": { "text": { "value": "bar", "_name": "a" } }}, )
def test_field_group(self): orig = FieldGroup(Word("bar"), pos=3, head="\n", tail="\t") copy = orig.clone_item() self.assert_equal_tail_head_pos(orig, copy) self.assertEqual(copy.expr, NONE_ITEM) self.assertNotEqual(orig, copy) copy.children = [Word("bar")] self.assertEqual(orig, copy)
def test_groups(self): tree = (OrOperation( Word('test', tail=" "), Group(AndOperation( SearchField("subject", FieldGroup( OrOperation(Word('foo', tail=" "), Word('bar', head=" "))), tail=" "), Word('baz', head=" ")), head=" "))) parsed = parser.parse('test OR (subject:(foo OR bar) AND baz)') self.assertEqual(str(parsed), str(tree)) self.assertEqual(parsed, tree)
def test_simple_propagation(self): # propagation in nodes with only one children tree = Boost(Group(SearchField("foo", FieldGroup(Plus(Word("bar"))))), force=2) paths_ok, paths_ko = self.propagate_matching(tree, set(), {()}) self.assertEqual(paths_ok, set()) self.assertEqual(paths_ko, {(), (0, ), (0, 0), (0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0, 0)}) paths_ok, paths_ko = self.propagate_matching(tree, {()}, set()) self.assertEqual(paths_ok, {(), (0, ), (0, 0), (0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0, 0)}) self.assertEqual(paths_ko, set())
def test_check_ok(self): query = (AndOperation( SearchField( "f", FieldGroup( AndOperation( Boost(Proximity(Phrase('"foo bar"'), 4), "4.2"), Prohibit(Range("100", "200"))))), Group(OrOperation(Fuzzy(Word("baz"), ".8"), Plus(Word("fizz")))))) check = LuceneCheck() self.assertTrue(check(query)) self.assertEqual(check.errors(query), []) check = LuceneCheck(zeal=1) self.assertTrue(check(query)) self.assertEqual(check.errors(query), [])
def test_combinations(self): # self.assertEqual(parser.parse("subject:test desc:(house OR car)").pval, "") tree = (UnknownOperation( SearchField("subject", Word("test"), tail=" "), AndOperation( SearchField("desc", FieldGroup( OrOperation(Word("house", tail=" "), Word("car", head=" "))), tail=" "), Not(Proximity(Phrase('"approximatly this"'), 3, head=" "), head=" ")))) parsed = parser.parse( 'subject:test desc:(house OR car) AND NOT "approximatly this"~3') self.assertEqual(str(parsed), str(tree)) self.assertEqual(parsed, tree)
def test_field_group(self): tree = parser.parse("\rfoo:\t( bar\n)\t\n") self.assertEqual(tree, SearchField("foo", FieldGroup(Word("bar")))) self.assertEqual(tree.head, "\r") self.assertEqual(tree.tail, "") self.assertEqual(tree.pos, 1) self.assertEqual(tree.size, 15) group, = tree.children self.assertEqual(group.head, "\t") self.assertEqual(group.tail, "\t\n") self.assertEqual(group.pos, 6) self.assertEqual(group.size, 8) bar, = group.children self.assertEqual(bar.head, " ") self.assertEqual(bar.tail, "\n") self.assertEqual(bar.pos, 9) self.assertEqual(bar.size, 3) self.assertEqual(str(tree), "foo:\t( bar\n)\t\n") self.assertEqual(tree.__str__(head_tail=True), "\rfoo:\t( bar\n)\t\n")
def test_complex(self): tree = Group( OrOperation( SearchField( "foo", FieldGroup( UnknownOperation(Word("bar"), Range(Word("baz"), Word("spam")))), ), Not(Proximity(Phrase('"ham ham"'), 2)), Plus(Fuzzy(Word("hammer"), 3)), )) self.assertEqual(str(tree), '(foo:(bar[bazTOspam])ORNOT"ham ham"~2OR+hammer~3)') self.assertEqual( str(auto_head_tail(tree)), '(foo:(bar [baz TO spam]) OR NOT "ham ham"~2 OR +hammer~3)', ) # idem potent self.assertEqual( str(auto_head_tail(auto_head_tail(tree))), '(foo:(bar [baz TO spam]) OR NOT "ham ham"~2 OR +hammer~3)', )
def test_set_children(self): test = self._test_set_children test(Word("foo"), []) test(Phrase('"foo"'), []) test(Regex("/foo/"), []) test(SearchField("foo", Word("bar")), [Word("baz")]) test(Group(Word("foo")), [Word("foo")]) test(FieldGroup(Word("foo")), [Word("foo")]) test(Range(Word("20"), Word("30")), [Word("40"), Word("50")]) test(Proximity(Word("foo")), [Word("foo")]) test(Fuzzy(Word("foo")), [Word("foo")]) test(Boost(Word("foo"), force=1), [Word("foo")]) many_terms = tuple(Word(f"foo_{i}") for i in range(5)) test(UnknownOperation(Word("foo"), Word("bar")), (Word("foo"), Word("bar"))) test(UnknownOperation(*many_terms), many_terms) test(AndOperation(Word("foo"), Word("bar")), (Word("foo"), Word("bar"))) test(AndOperation(*many_terms), many_terms) test(OrOperation(Word("foo"), Word("bar")), (Word("foo"), Word("bar"))) test(OrOperation(*many_terms), many_terms) test(Plus(Word("foo")), [Word("foo")]) test(Not(Word("foo")), [Word("foo")]) test(Prohibit(Word("foo")), [Word("foo")])
def test_combination(self): tree = AndOperation( OrOperation( SearchField( "mine", FieldGroup( Plus(AndOperation( Word("foo"), Regex("/fizz/"), ), ), ), ), Boost( Group( AndOperation( Phrase('"ham"'), Word("spam"), Prohibit(Fuzzy(Word("fuzz"))), ), ), force=2, ), ), Not(OrOperation( Word('"bar"'), Word('"baz"'), ), ), ) to_path = simple_naming(tree) paths_ok, paths_ko = self.propagate_matching(tree, set()) self.assertEqual( paths_to_names(tree, paths_ok), {"prohibit", "not"}, ) self.assertEqual( paths_to_names(tree, paths_ko), { "and", "or", "searchfield", "fieldgroup", "plus", "and2", "foo", "fizz", "boost", "group", "and3", "ham", "spam", "fuzzy", "or2", "bar", "baz" }, ) # adding matching just enough positive expressions, so that complete expression matches paths_ok, paths_ko = self.propagate_matching( tree, {to_path["foo"], to_path["fizz"], to_path["ham"]}, ) self.assertEqual( paths_to_names(tree, paths_ok), { "and", "or", "searchfield", "fieldgroup", "plus", "and2", "foo", "fizz", "ham", "prohibit", "not" }, ) self.assertEqual( paths_to_names(tree, paths_ko), {"boost", "group", "and3", "spam", "fuzzy", "or2", "bar", "baz"}, ) # making everything match paths_ok, paths_ko = self.propagate_matching( tree, {to_path["foo"], to_path["fizz"], to_path["ham"], to_path["spam"]}, ) self.assertEqual( paths_to_names(tree, paths_ok), { "and", "or", "searchfield", "fieldgroup", "plus", "and2", "foo", "fizz", "ham", "prohibit", "boost", "group", "and3", "spam", "not" }) self.assertEqual(paths_to_names(tree, paths_ko), {"fuzzy", "or2", "bar", "baz"}) # making everything match, but some negative expression paths_ok, paths_ko = self.propagate_matching( tree, { to_path["foo"], to_path["fizz"], to_path["ham"], to_path["spam"], to_path["fuzzy"], to_path["bar"], }, ) self.assertEqual( paths_to_names(tree, paths_ok), { "or", "searchfield", "fieldgroup", "plus", "and2", "foo", "fizz", "ham", "spam", "fuzzy", "or2", "bar", }, ) self.assertEqual( paths_to_names(tree, paths_ko), { "and", "boost", "group", "and3", "prohibit", "boost", "group", "and3", "not", "baz", }, )
class TestPrettify(TestCase): big_tree = AndOperation( Group(OrOperation(Word("baaaaaaaaaar"), Word("baaaaaaaaaaaaaz"))), Word("fooooooooooo")) fat_tree = AndOperation( SearchField( "subject", FieldGroup( OrOperation( Word("fiiiiiiiiiiz"), AndOperation(Word("baaaaaaaaaar"), Word("baaaaaaaaaaaaaz"))))), AndOperation(Word("fooooooooooo"), Word("wiiiiiiiiiz"))) def test_one_liner(self): tree = AndOperation(Group(OrOperation(Word("bar"), Word("baz"))), Word("foo")) self.assertEqual(prettify(tree), "( bar OR baz ) AND foo") def test_with_unknown_op(self): prettify = Prettifier(indent=8, max_len=20) tree = UnknownOperation( Group( UnknownOperation(Word("baaaaaaaaaar"), Word("baaaaaaaaaaaaaz"))), Word("fooooooooooo")) self.assertEqual( "\n" + prettify(tree), """ ( baaaaaaaaaar baaaaaaaaaaaaaz ) fooooooooooo""") def test_with_unknown_op_nested(self): prettify = Prettifier(indent=8, max_len=20) tree = OrOperation( UnknownOperation(Word("baaaaaaaaaar"), Word("baaaaaaaaaaaaaz")), Word("fooooooooooo")) self.assertEqual( "\n" + prettify(tree), """ baaaaaaaaaar baaaaaaaaaaaaaz OR fooooooooooo""") def test_small(self): prettify = Prettifier(indent=8, max_len=20) self.assertEqual( "\n" + prettify(self.big_tree), """ ( baaaaaaaaaar OR baaaaaaaaaaaaaz ) AND fooooooooooo""") self.assertEqual( "\n" + prettify(self.fat_tree), """ subject: ( fiiiiiiiiiiz OR baaaaaaaaaar AND baaaaaaaaaaaaaz ) AND fooooooooooo AND wiiiiiiiiiz""") def test_small_inline_ops(self): prettify = Prettifier(indent=8, max_len=20, inline_ops=True) self.assertEqual( "\n" + prettify(self.big_tree), """ ( baaaaaaaaaar OR baaaaaaaaaaaaaz ) AND fooooooooooo""") self.assertEqual( "\n" + prettify(self.fat_tree), """ subject: ( fiiiiiiiiiiz OR baaaaaaaaaar AND baaaaaaaaaaaaaz ) AND fooooooooooo AND wiiiiiiiiiz""") def test_normal(self): prettify = Prettifier(indent=4, max_len=50) self.assertEqual( "\n" + prettify(self.big_tree), """ ( baaaaaaaaaar OR baaaaaaaaaaaaaz ) AND fooooooooooo""") self.assertEqual( "\n" + prettify(self.fat_tree), """ subject: ( fiiiiiiiiiiz OR baaaaaaaaaar AND baaaaaaaaaaaaaz ) AND fooooooooooo AND wiiiiiiiiiz""") def test_normal_inline_ops(self): prettify = Prettifier(indent=4, max_len=50, inline_ops=True) self.assertEqual( "\n" + prettify(self.big_tree), """ ( baaaaaaaaaar OR baaaaaaaaaaaaaz ) AND fooooooooooo""") self.assertEqual( "\n" + prettify(self.fat_tree), """ subject: ( fiiiiiiiiiiz OR baaaaaaaaaar AND baaaaaaaaaaaaaz ) AND fooooooooooo AND wiiiiiiiiiz""")