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_minus(self):
tree = (AndOperation(Prohibit(Word("test", tail=" ")),
Prohibit(Word("foo", tail=" "), head=" "),
Not(Word("bar", head=" "), head=" ")))
parsed = parser.parse("-test AND -foo AND NOT bar")
self.assertEqual(str(parsed), str(tree))
self.assertEqual(parsed, tree)
def test_zealous_or_not(self):
query = (OrOperation(Not(Word("foo")), Word("bar")))
check_zealous = LuceneCheck(zeal=1)
self.assertFalse(check_zealous(query))
self.assertIn("inconsistent", check_zealous.errors(query)[0])
check_easy_going = LuceneCheck()
self.assertTrue(check_easy_going(query))
def test_parents_tracking_no_tracking(self):
tree = AndOperation(Word("foo"), Phrase('"bar"'))
# no parents tracking !
visitor = self.TrackingParentsVisitor()
nodes = visitor.visit(tree)
self.assertListEqual([(tree, None), (Word("foo"), None),
(Phrase('"bar"'), None)], nodes)
def test_and_operation(self):
tree = AndOperation(Word("foo"), Phrase('"bar"'), Word("baz"))
all_paths = {(0, ), (1, ), (2, )}
matching = set()
paths_ok, paths_ko = self.propagate_matching(tree, matching,
all_paths - matching)
self.assertEqual(paths_ok, set())
self.assertEqual(paths_ko, {
(),
(0, ),
(1, ),
(2, ),
})
matching = {(2, )}
paths_ok, paths_ko = self.propagate_matching(tree, matching,
all_paths - matching)
self.assertEqual(paths_ok, {(2, )})
self.assertEqual(paths_ko, {(), (0, ), (1, )})
matching = {(0, ), (2, )}
paths_ok, paths_ko = self.propagate_matching(tree, matching,
all_paths - matching)
self.assertEqual(paths_ok, {(0, ), (2, )})
self.assertEqual(paths_ko, {(), (1, )})
matching = {(0, ), (1, ), (2, )}
paths_ok, paths_ko = self.propagate_matching(tree, matching,
all_paths - matching)
self.assertEqual(paths_ok, {(), (0, ), (1, ), (2, )})
self.assertEqual(paths_ko, set())
def test_basic_traversal(self):
tree = (AndOperation(Word("foo"), Word("bar")))
transformer = self.BasicTransformer()
new_tree = transformer.visit(tree)
self.assertEqual(new_tree, (AndOperation(Word("lol"), Word("lol"))))
def test_named_queries_not(self):
tree = Not(SearchField("text", Word("foo")))
set_name(tree, "a")
result = self.transformer(tree)
self.assertEqual(
result, {
'bool': {
'must_not': [{
'term': {
'text': {
'_name': 'a',
'value': 'foo'
}
}
}]
}
})
tree = Prohibit(SearchField("text", Word("foo")))
set_name(tree, "a")
result = self.transformer(tree)
self.assertEqual(
result, {
'bool': {
'must_not': [{
'term': {
'text': {
'_name': 'a',
'value': 'foo'
}
}
}]
}
})
def test_named_queries_unknown(self):
tree = UnknownOperation(SearchField("text", Word("foo")),
SearchField("spam", Word("bar")))
set_name(tree.operands[0], "a")
set_name(tree.operands[1], "b")
result = self.transformer(tree)
self.assertEqual(
result, {
'bool': {
'should': [{
'term': {
'text': {
'_name': 'a',
'value': 'foo'
}
}
}, {
'match': {
'spam': {
'_name': 'b',
'query': 'bar',
'zero_terms_query': 'none'
}
}
}]
}
})
def test_plus(self):
tree = (AndOperation(Plus(Word("test", tail=" ")),
Word("foo", head=" ", tail=" "),
Plus(Word("bar"), head=" ")))
parsed = parser.parse("+test AND foo AND +bar")
self.assertEqual(str(parsed), str(tree))
self.assertEqual(parsed, tree)
def test_generic_visit(self):
tree = AndOperation(Word("foo"), Word("bar"))
visitor = TreeVisitor()
nodes = visitor.visit(tree)
self.assertEqual(nodes, [])
# with a context for coverage…
nodes = visitor.visit(tree, context={})
self.assertEqual(nodes, [])
def test_flavours(self):
tree = SearchField(
"somedate",
Range(Word("now/d-1d+7H", tail=" "), Word("now/d+7H", head=" "),
True, True))
parsed = parser.parse('somedate:[now/d-1d+7H TO now/d+7H]')
self.assertEqual(str(parsed), str(tree))
self.assertEqual(parsed, tree)
def test_date_in_range(self):
# juste one funky expression
tree = SearchField(
"foo",
Range(Word(r"2015-12-19||+2\d", tail=" "),
Word(r"now+3d+12h\h", head=" ")))
parsed = parser.parse(r'foo:[2015-12-19||+2\d TO now+3d+12h\h]')
self.assertEqual(str(tree), str(parsed))
self.assertEqual(tree, parsed)
def test_datemath_in_field(self):
tree = SearchField("foo", Word(r"2015-12-19||+2\d"))
parsed = parser.parse(r'foo:2015-12-19||+2\d')
self.assertEqual(str(tree), str(parsed))
self.assertEqual(tree, parsed)
tree = SearchField("foo", Word(r"now+2h+20m\h"))
parsed = parser.parse(r'foo:now+2h+20m\h')
self.assertEqual(str(tree), str(parsed))
self.assertEqual(tree, parsed)
def test_repeating_expression(self):
# non regression test
tree = AndOperation(
Group(OrOperation(Word('bar'), Word('foo'))),
Group(OrOperation(Word('bar'), Word('foo'), Word('spam'))),
)
# basic transformer should not change tree
same_tree = TreeTransformer().visit(copy.deepcopy(tree))
self.assertEqual(same_tree, tree)
def test_approx(self):
tree = (UnknownOperation(
Proximity(Phrase('"foo bar"'), 3, tail=" "),
Proximity(Phrase('"foo baz"'), None, tail=" "),
Fuzzy(Word('baz'), Decimal("0.3"), tail=" "),
Fuzzy(Word('fou'), None)))
parsed = parser.parse('"foo bar"~3 "foo baz"~ baz~0.3 fou~')
self.assertEqual(str(parsed), str(tree))
self.assertEqual(parsed, tree)
def test_equality_boost(self):
b1 = Boost(expr=Word('foo'), force=5)
b2 = Boost(expr=Word('bar'), force=5)
b3 = Boost(expr=Word('foo'), force=5)
b4 = Boost(expr=Word('foo'), force=.5)
self.assertNotEqual(b1, b2)
self.assertEqual(b1, b3)
self.assertNotEqual(b1, b4)
def _test_unary(self, cls):
orig = cls(Word("foo"), pos=3, head="\n", tail="\t")
copy = orig.clone_item()
self.assert_equal_tail_head_pos(orig, copy)
self.assertEqual(copy.a, NONE_ITEM)
self.assertNotEqual(orig, copy)
copy.children = [Word("foo")]
self.assertEqual(orig, copy)
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_mro(self):
visitor = self.MROVisitor()
tree = OrOperation(Word('a'), Word('b'))
result = visitor.visit(tree)
self.assertEquals(result, 'a OR b')
tree = OrOperation(AndOperation(Word('a'), Word('b')), Word('c'))
result = visitor.visit(tree)
self.assertEquals(result, 'a BASE_OP b OR c')
def test_boost(self):
orig = Boost(Word("bar"), force=3.2, pos=3, head="\n", tail="\t")
copy = orig.clone_item()
self.assert_equal_tail_head_pos(orig, copy)
self.assertEqual(orig.force, copy.force)
self.assertEqual(copy.expr, NONE_ITEM)
self.assertNotEqual(orig, copy)
copy.children = [Word("bar")]
self.assertEqual(orig, copy)
def test_fuzzy(self):
orig = Fuzzy(Word("bar"), degree=.3, pos=3, head="\n", tail="\t")
copy = orig.clone_item()
self.assert_equal_tail_head_pos(orig, copy)
self.assertEqual(orig.degree, copy.degree)
self.assertEqual(copy.term, NONE_ITEM)
self.assertNotEqual(orig, copy)
copy.children = [Word("bar")]
self.assertEqual(orig, copy)
def test_mro(self):
visitor = self.MROVisitor()
tree = OrOperation(Word('a'), Word('b'))
result = visitor.visit(tree)
self.assertEquals(list(result), ['a OR b', 'a', 'b'])
tree = AndOperation(Word('a'), Word('b'))
result = visitor.visit(tree)
self.assertEquals(list(result), ['a BASE_OP b', 'a', 'b'])
def test_removal(self):
tree = (AndOperation(AndOperation(Word("foo"), Phrase('"bar"')),
AndOperation(Phrase('"baz"'), Phrase('"biz"'))))
transformer = self.BasicTransformer()
new_tree = transformer.visit(tree)
self.assertEqual(
new_tree,
(AndOperation(AndOperation(Word("lol")), AndOperation())))
def test_auto_head_tail_no_change_to_existing(self):
tree = AndOperation(
Range(Word("foo", tail="\t"), Word("bar", head="\n"), tail="\r"),
Not(Word("baz", head="\t\t"), head="\n\n", tail="\r\r"),
Word("spam", head="\t\n"),
)
self.assertEqual(str(tree),
"[foo\tTO\nbar]\rAND\n\nNOT\t\tbaz\r\rAND\t\nspam")
self.assertEqual(str(auto_head_tail(tree)),
"[foo\tTO\nbar]\rAND\n\nNOT\t\tbaz\r\rAND\t\nspam")
def test_auto_name_nested(self):
tree = AndOperation(
OrOperation(
SearchField("bar", Word("test")),
AndOperation(
Proximity(Phrase('"test"'), 2),
SearchField("baz", Word("test")),
),
),
Group(UnknownOperation(
Fuzzy(Word("test")),
Phrase('"test"'),
), ),
)
names = auto_name(tree)
self.assertEqual(sorted(names.keys()), list("abcdefgh"))
# and
and1 = tree
self.assertEqual(get_name(and1), None)
# - or
or1 = and1.children[0]
self.assertEqual(get_name(or1), "a")
self.assertEqual(names["a"], (0, ))
# -- search field
sfield1 = or1.children[0]
self.assertEqual(get_name(sfield1), "c")
self.assertEqual(names["c"], (0, 0))
self.assertEqual(get_name(sfield1.expr), None)
# -- and
and2 = or1.children[1]
self.assertEqual(get_name(and2), "d")
self.assertEqual(names["d"], (0, 1))
# --- proximity phrase
self.assertEqual(get_name(and2.children[0]), "e")
self.assertEqual(names["e"], (0, 1, 0))
self.assertEqual(get_name(and2.children[0].term), None)
# --- search field
sfield2 = and2.children[1]
self.assertEqual(get_name(sfield2), "f")
self.assertEqual(names["f"], (0, 1, 1))
self.assertEqual(get_name(sfield2.expr), None)
# - group
group1 = and1.children[1]
self.assertEqual(get_name(group1), "b")
self.assertEqual(names["b"], (1, ))
# -- unknown op
unknownop1 = group1.children[0]
self.assertEqual(get_name(unknownop1), None)
# --- fuzzy word
self.assertEqual(get_name(unknownop1.children[0]), "g")
self.assertEqual(names["g"], (1, 0, 0))
self.assertEqual(get_name(unknownop1.children[0].term), None)
# --- phrase
self.assertEqual(get_name(unknownop1.children[1]), "h")
self.assertEqual(names["h"], (1, 0, 1))
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_operands_list(self):
OrListOperation = self.OrListOperation
tree = (OrListOperation(OrListOperation(Word("foo"), Phrase('"bar"')),
OrListOperation(Phrase('"baz"'))))
transformer = self.BasicTransformer()
new_tree = transformer.visit(tree)
self.assertEqual(
new_tree,
(OrListOperation(OrListOperation(Word("lol")), OrListOperation())))
def test_equality_fuzzy(self):
f1 = Fuzzy(term=Word('foo'), degree=5)
f2 = Fuzzy(term=Word('bar'), degree=5)
f3 = Fuzzy(term=Word('foo'), degree=5)
f4 = Fuzzy(term=Word('foo'), degree=.5)
f5 = Fuzzy(term=Word('foo'), degree=None)
self.assertNotEqual(f1, f2)
self.assertEqual(f1, f3)
self.assertNotEqual(f1, f4)
self.assertEqual(f4, f5)
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_boost(self):
tree = (UnknownOperation(
Boost(Phrase('"foo bar"'), Decimal("3.0"), tail=" "),
Boost(
Group(
AndOperation(Word('baz', tail=" "), Word('bar',
head=" "))),
Decimal("2.1"))))
parsed = parser.parse('"foo bar"^3 (baz AND bar)^2.1')
self.assertEqual(str(parsed), str(tree))
self.assertEqual(parsed, tree)
