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)