def test_ast_expression_left_operator_right_arithmeticcomparison_null(
self):
left_expr = ast.NullExpression(context)
right_expr = ast.NullExpression(context)
self.assertExpressionTests('ge', left_expr, right_expr, True)
self.assertExpressionTests('gt', left_expr, right_expr, False)
self.assertExpressionTests('le', left_expr, right_expr, True)
self.assertExpressionTests('lt', left_expr, right_expr, False)
def test_ast_unconditional_comprehension(self):
iterable = (None, )
iterable_expression = ast.LiteralExpressionBase.from_value(
context, iterable)
comprehension = ast.ComprehensionExpression(
context, ast.NullExpression(context), 'test', iterable_expression)
self.assertEqual(comprehension.evaluate(None), iterable)
def test_ast_conditional_comprehension_error(self):
iterable_expression = ast.SymbolExpression(context, 'iterable')
comprehension = ast.ComprehensionExpression(
context, ast.NullExpression(context), 'member',
iterable_expression)
with self.assertRaises(errors.EvaluationError):
comprehension.evaluate({'iterable': None})
def p_expression_decode(self, p):
'''expression : expression COMMA expression
'''
left, op, right, replacement = p[1], "==", ast.NullExpression(
self.context), p[3]
op_name = self.op_names[op]
p[0] = NVLResolutionExpression(self.context, op_name, left, right,
replacement).reduce()
def test_ast_expression_getitem_error(self):
for container in self.containers.values():
member = ast.FloatExpression(context, 100.0)
with self.assertRaises(errors.LookupError):
ast.GetItemExpression(context, container,
member).evaluate(None)
member = ast.FloatExpression(context, 1.1)
with self.assertRaises(errors.EvaluationError):
ast.GetItemExpression(context, container,
member).evaluate(None)
member = ast.NullExpression(context)
with self.assertRaises(errors.EvaluationError):
ast.GetItemExpression(context, container, member)
def test_ast_expression_attribute_safe(self):
symbol = ast.StringExpression(context, 'foo')
expression = ast.GetAttributeExpression(context,
symbol,
'undefined',
safe=True)
expression.evaluate(None)
expression = ast.GetAttributeExpression(context,
ast.NullExpression(context),
'undefined',
safe=True)
self.assertIsNone(expression.evaluate(None))
def test_ast_expression_left_operator_right_fuzzycomparison_nulls(self):
darth = ast.StringExpression(context, 'Darth Vader')
null = ast.NullExpression(context)
for operation, left, right in itertools.product(
('eq_fzm', 'eq_fzs'), (darth, null), (darth, null)):
self.assertExpressionTests(operation,
left_value=left,
right_value=right,
equals_value=left is right)
for operation, left, right in itertools.product(
('ne_fzm', 'ne_fzs'), (darth, null), (darth, null)):
self.assertExpressionTests(operation,
left_value=left,
right_value=right,
equals_value=left is not right)
def test_ast_comprehension_result_type(self):
iterable = (None, )
iterable_expression = ast.LiteralExpressionBase.from_value(
context, iterable)
comprehension = ast.ComprehensionExpression(
context, ast.NullExpression(context), 'test', iterable_expression)
self.assertEqual(comprehension.result_type,
types.DataType.ARRAY(types.DataType.NULL))
comprehension = ast.ComprehensionExpression(
context, ast.FloatExpression(context, 1), 'test',
iterable_expression)
self.assertEqual(comprehension.result_type,
types.DataType.ARRAY(types.DataType.FLOAT))
def test_ast_expression_literal_array(self):
self.assertLiteralTests(ast.ArrayExpression, tuple(),
tuple((ast.NullExpression(self.context), )))
def test_ast_expression_literal_null(self):
expression = ast.NullExpression(self.context)
self.assertIsNone(expression.evaluate(None))
import rule_engine.ast as ast
import rule_engine.engine as engine
__all__ = ('LiteralExpressionTests', )
context = engine.Context()
context.builtins = engine.Builtins.from_defaults(
{'test': {
'one': 1.0,
'two': 2.0
}})
# literal expressions which should evaluate to false
falseish = (ast.ArrayExpression(context, tuple()),
ast.BooleanExpression(context,
False), ast.FloatExpression(context, 0.0),
ast.NullExpression(context), ast.StringExpression(context, ''))
# literal expressions which should evaluate to true
trueish = (ast.ArrayExpression(context, tuple(
(ast.NullExpression(context), ))),
ast.ArrayExpression(context,
tuple((ast.FloatExpression(context, 1.0), ))),
ast.BooleanExpression(context, True),
ast.DatetimeExpression(context, datetime.datetime.now()),
ast.FloatExpression(context, float('-inf')),
ast.FloatExpression(context,
-1.0), ast.FloatExpression(context, 1.0),
ast.FloatExpression(context, float('inf')),
ast.StringExpression(context, 'non-empty'))
class UnknownType(object):
import rule_engine.ast as ast
import rule_engine.engine as engine
__all__ = ('LiteralExpressionTests',)
context = engine.Context()
context.builtins = engine.Builtins.from_defaults(
{'test': {'one': 1.0, 'two': 2.0}}
)
# literal expressions which should evaluate to false
falseish = (
ast.ArrayExpression(context, tuple()),
ast.BooleanExpression(context, False),
ast.FloatExpression(context, 0.0),
ast.NullExpression(context),
ast.StringExpression(context, '')
)
# literal expressions which should evaluate to true
trueish = (
ast.ArrayExpression(context, tuple((ast.NullExpression(context),))),
ast.BooleanExpression(context, True),
ast.DatetimeExpression(context, datetime.datetime.now()),
ast.FloatExpression(context, float('-inf')),
ast.FloatExpression(context, -1.0),
ast.FloatExpression(context, 1.0),
ast.FloatExpression(context, float('inf')),
ast.StringExpression(context, 'non-empty')
)
class UnknownType(object):
