FCL/sftools/depl/swconfigmdw: comparison configurationengine/source/cone/public/tests/unittest_rules_on

equal deleted inserted replaced

-:87cfa131b535
+:e7e0ae78773e
 # Contributors:
 #
 # Description:
 #
-import operator as ops
 import unittest
-import sys, os
-import __init__
+from cone.public import api,exceptions, plugin
-import tokenize
+from cone.public.rules import RelationContainerImpl
-import StringIO
+from cone.public.rules import DefaultContext, BaseRelation
-from cone.public import api,exceptions, utils
-from cone.public.rules import ASTInterpreter, RelationContainerImpl
-from cone.public.rules import ParseException, DefaultContext, BaseRelation
 from cone.public import rules
 #### TEST RELATIONS ####
-AA_BA = 'a.a == "foo" requires b.b != 0'
+AA_BA = '${a.a} == "foo" requires ${b.b} != 0'
-AB_BB = 'a.b configures b.b = a.b+":"+ "test"'
+AB_BB = '${a.b} configures ${b.b} = ${a.b}+":"+ "test"'
-BA_CA = 'b.a requires c.a and c.b and a.b'
+BA_CA = '${b.a} requires ${c.a} and ${c.b} and ${a.b}'
-CB_DA = 'c.b requires d.a'
+CB_DA = '${c.b} requires ${d.a}'
-DA_DB = 'd.a requires d.b'
+DA_DB = '${d.a} requires ${d.b}'
-AC_AB_BA = 'a.c and a.a requires b.a'
+AC_AB_BA = '${a.c} and ${a.a} requires ${b.a}'
-EA_FSTAR = 'e.a requires f.*'
+EA_FSTAR = '${e.a} requires ${f.*}'
 TEST_RELATIONS = {
-'a.a' : [AA_BA, 'a.a == "test" requires b.a'],
+'a.a' : [AA_BA, '${a.a} == "test" requires ${b.a}'],
 'a.b' : [AB_BB],
 'a.c' : [AC_AB_BA],
 'b.a' : [BA_CA],
 'c.b' : [CB_DA],
 'd.a' : [DA_DB],
 #print "handle_terminal constant %s" % (expression)
 try:
 return eval(expression)
 except (NameError,SyntaxError), e:
 return expression
+def convert_value(self, value):
+try:
+# Handle some special literals
+if value == 'true':     return True
+if value == 'false':    return False
+if value == 'none':     return None
+# Values can be any Python literals, so eval() the string to
+# get the value
+return eval(value)
+except Exception:
+raise RuntimeError("Could not evaluate '%s'" % value)
 def eval(self, ast, expression, value):
 #print "expression %s = %s" % (expression,value)
 pass
 class ConfigurationBaseRelation(BaseRelation):
 def __init__(self, data, left, right):
-self.context = ConfigurationContext(data)
+self.context = None
 super(ConfigurationBaseRelation, self).__init__(data, left, right)
 class RequireRelation(ConfigurationBaseRelation):
 KEY = 'requires'
 def __init__(self, data, left, right):
 super(RequireRelation, self).__init__(data, left, right)
-self.context = ConfigurationContext(data)
+self.context = None
 class ConfigureRelation(ConfigurationBaseRelation):
 KEY = 'configures'
 def __init__(self, data, left, right):
 super(ConfigureRelation, self).__init__(data, left, right)
-self.context = ConfigurationContext(data)
+self.context = None
 def handle_configure(self, left, right):
 if left and right:
 return True
 elif not left:
 class ConfigureExpression(rules.TwoOperatorExpression):
 PRECEDENCE = rules.PRECEDENCES['RELATION_OPERATORS']
 KEY = 'configures'
 OP = handle_configure
-def eval(self, context):
+def eval(self, context, **kwargs):
-super(ConfigureExpression, self).eval(context)
+super(ConfigureExpression, self).eval(context, **kwargs)
 if not self.value:
 left_keys = []
 for ref in self.ast.extract_refs(str(self.left)):
 for key in context.get_keys(ref):
 left_keys.append(key)
 class ConcatExpression(rules.TwoOperatorExpression):
 PRECEDENCE = rules.PRECEDENCES['ADDSUB_OPERATORS']
 KEY= '+'
 OP = handle_plus
-class SetExpression(rules.TwoOperatorExpression):
-PRECEDENCE = rules.PRECEDENCES['SET_OPERATORS']
-KEY= '='
-OP = handle_set
-def eval(self, context):
-try:
-variable = context.data.get_feature(self.left.expression)
-variable.set_value(self.right.eval(context))
-return True
-except exceptions.NotFound:
-return False
 class TestRelations(unittest.TestCase):
 def setUp(self):
 self.configuration = get_test_configuration()
 rules.RELATIONS[RequireRelation.KEY] = RequireRelation
 rules.RELATIONS[ConfigureRelation.KEY] = ConfigureRelation
 rules.OPERATORS[ConfigureExpression.KEY] = ConfigureExpression
 rules.OPERATORS[ConcatExpression.KEY] = ConcatExpression
-rules.OPERATORS[SetExpression.KEY] = SetExpression
 def tearDown(self):
 rules.RELATIONS = self.RELATIONS_BACKUP
 rules.OPERATORS = self.OPERATORS_BACKUP
 """
 factory = TestFactory()
 rels = factory.get_relations_for(self.configuration, 'a.a')
 ret= rels.execute()
 self.assertTrue(ret)
-def test_has_ref(self):
-"""
-Tests the relation and relation container
-"""
-factory = TestFactory()
-rels = factory.get_relations_for(self.configuration, 'a.a')
-ret= rels.execute()
-self.assertTrue(ret)
 def test_not_has_ref(self):
 factory = TestFactory()
 # depends on c.a which has no value in conf
 rels = factory.get_relations_for(self.configuration, 'b.a')
 self.assertTrue(ret)
 def test_not_has_ref_in_container(self):
 factory = TestFactory()
 rels = factory.get_relations_for(self.configuration, 'c.b')
-ret = rels.execute()
+context = plugin.GenerationContext(configuration=self.configuration)
+ret = rels.execute(context)
 self.assertFalse(ret)
 def test_two_on_the_left(self):
 factory = TestFactory()
 rels = factory.get_relations_for(self.configuration, 'a.c')
 self.assertTrue(ret)
 def test_configure_right_side(self):
 factory = TestFactory()
 rels = factory.get_relations_for(self.configuration, 'a.b')
-ret = rels.execute()
+context = plugin.GenerationContext(configuration=self.configuration)
+ret = rels.execute(context)
 self.assertTrue(ret)
 self.assertEquals(self.configuration.get_default_view().get_feature('b.b').get_value(),'hey:test')
+def test_get_refs_from_relation(self):
+factory = TestFactory()
+rels = factory.get_relations_for(self.configuration, 'a.b')
+self.assertEquals(rels.value_list[0].get_refs(), [u'a.b'])
+self.assertEquals(rels.value_list[0].get_set_refs(), [u'b.b'])
 if __name__ == '__main__':
 unittest.main()

changeset 3	e7e0ae78773e
parent 0	2e8eeb919028