def test_logical_eval5(self):
l = ast.Literal("l")
r = ast.Literal("r")
a = ast.LogicalOperator('or', l, r)
res, ctx = a.analyze(MockPred(), {"l": False})
assert not res
assert ctx.literals["l"] == False
assert ctx.literals["r"] == ast.Undefined()
assert "Both sides of OR operator" in ctx.failed[0]
def test_match_undef(self):
l = ast.Literal("l")
r = ast.Regex(ast.Literal('abcd'))
a = ast.MatchOperator(l, r)
d = {}
res, ctx = a.analyze(MockPred(), d)
assert not res
assert "not a string" in ctx.failed[0]
assert ctx.literals["l"] == ast.Undefined()
def test_undef_contains(self):
"Tests removing an Empty contains X"
u = ast.Undefined()
v = ast.Literal('foo')
cn = ast.ContainsOperator(u, v)
c, r = optimizer.optimization_pass(cn)
assert c == 1
assert isinstance(r, ast.Constant)
assert r.value == False
def test_contains_undef(self):
l = ast.Literal("l")
r = ast.Literal("r")
a = ast.ContainsOperator(l, r)
d = {"r": 5}
res, ctx = a.analyze(MockPred(), d)
assert not res
assert "not in left side" in ctx.failed[0]
assert ctx.literals["l"] == ast.Undefined()
assert ctx.literals["r"] == 5
def test_is_any_undef(self):
l = ast.Literal("l")
r = ast.Literal("r")
a = ast.SetComparisonOperator("is_any", l, r)
d = {"l": 5}
res, ctx = a.analyze(MockPred(), d)
assert not res
assert "not in right side" in ctx.failed[0]
assert ctx.literals["l"] == 5
assert ctx.literals["r"] == ast.Undefined()
def test_contains_all_undef(self):
l = ast.Literal("l")
r = ast.Literal("r")
a = ast.SetComparisonOperator("all", l, r)
d = {"r": [5]}
res, ctx = a.analyze(MockPred(), d)
assert not res
assert "not in left side" in ctx.failed[0]
assert ctx.literals["l"] == ast.Undefined()
assert ctx.literals["r"] == [5]
def test_compare_undef(self, type):
l = ast.Literal("l")
r = ast.Literal("r")
a = ast.CompareOperator(type, l, r)
d = {"l": 1}
res, ctx = a.analyze(MockPred(), d)
# Determine the expected result
if type == "!=":
assert res
else:
assert not res
if not res:
assert ("%s comparison at" % type.upper()) in ctx.failed[0]
assert ctx.literals["l"] == d["l"]
assert ctx.literals["r"] == ast.Undefined()
def test_names(self):
n1 = ast.Literal("foo")
assert ("Literal", "foo") == merge.node_name(n1)
n2 = ast.Number(12)
assert ("Number", 12) == merge.node_name(n2)
n3 = ast.Constant(True)
assert ("Constant", True) == merge.node_name(n3)
n4 = ast.Regex("^tubez$")
assert ("Regex", "^tubez$") == merge.node_name(n4)
n5 = ast.Undefined()
assert "Undefined" == merge.node_name(n5)
n6 = ast.Empty()
assert "Empty" == merge.node_name(n6)
# Negate does not emit the operator!
n7 = ast.NegateOperator(n3)
assert ("Constant", True) == merge.node_name(n7)
n8 = ast.CompareOperator('=', n1, n2)
n8_name = merge.node_name(n8)
assert ("CompareOperator", "=", ("Literal", "foo"), ("Number",
12)) == n8_name
n8_static = merge.node_name(n8, True)
assert ("CompareOperator", "equality", ("Literal", "foo"),
("Number", "static")) == n8_static
n9 = ast.MatchOperator(n1, n4)
n9_name = merge.node_name(n9)
assert ("MatchOperator", ("Literal", "foo"), ("Regex",
"^tubez$")) == n9_name
n10 = ast.ContainsOperator(n1, n2)
n10_name = merge.node_name(n10)
assert ("ContainsOperator", ("Literal", "foo"), ("Number",
12.0)) == n10_name
# Logical operator returns literal!
n11 = ast.LogicalOperator('and', n1, n3)
n11_name = merge.node_name(n11)
assert ("Literal", "foo") == n11_name
# Literal set just uses name
n12 = ast.LiteralSet([n1, n2])
n12_name = merge.node_name(n12)
assert "LiteralSet" == n12_name
def test_names(self):
n1 = ast.Literal("foo")
assert ("Literal", "foo") == compact.node_name(n1)
n2 = ast.Number(12)
assert ("Number", 12) == compact.node_name(n2)
n3 = ast.Constant(True)
assert ("Constant", True) == compact.node_name(n3)
n4 = ast.Regex("^tubez$")
assert ("Regex", "^tubez$") == compact.node_name(n4)
n5 = ast.Undefined()
assert "Undefined" == compact.node_name(n5)
n6 = ast.Empty()
assert "Empty" == compact.node_name(n6)
n7 = ast.NegateOperator(n3)
assert ("NegateOperator", ("Constant", True)) == compact.node_name(n7)
n8 = ast.CompareOperator('=', n1, n2)
n8_name = compact.node_name(n8)
assert ("CompareOperator", "=", ("Literal", "foo"), ("Number",
12)) == n8_name
n9 = ast.MatchOperator(n1, n4)
n9_name = compact.node_name(n9)
assert ("MatchOperator", ("Literal", "foo"), ("Regex",
"^tubez$")) == n9_name
n10 = ast.ContainsOperator(n1, n2)
n10_name = compact.node_name(n10)
assert ("ContainsOperator", ("Literal", "foo"), ("Number",
12.0)) == n10_name
n11 = ast.LogicalOperator('and', n1, n3)
n11_name = compact.node_name(n11)
assert ("LogicalOperator", "and", ("Literal", "foo"),
("Constant", True)) == n11_name
def static_resolve(self, identifier):
if identifier[0] == identifier[-1] and identifier[0] in ("'", "\""):
return identifier[1:-1]
return ast.Undefined()
def resolve_identifier(self, doc, ident):
if ident in doc:
return doc[ident]
else:
return ast.Undefined()
def test_resolve_missing(self):
p = Predicate("name is 'Jack' and friend is 'Jill'")
assert p.resolve_identifier({}, "name") == ast.Undefined()
