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_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_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_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""")