--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/configurationengine/source/cone/public/tests/unittest_rules_on_configuration.py Thu Mar 11 17:04:37 2010 +0200
@@ -0,0 +1,277 @@
+#
+# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+# All rights reserved.
+# This component and the accompanying materials are made available
+# under the terms of "Eclipse Public License v1.0"
+# which accompanies this distribution, and is available
+# at the URL "http://www.eclipse.org/legal/epl-v10.html".
+#
+# Initial Contributors:
+# Nokia Corporation - initial contribution.
+#
+# Contributors:
+#
+# Description:
+#
+
+import operator as ops
+import unittest
+import sys, os
+import __init__
+import tokenize
+import StringIO
+
+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'
+AB_BB = 'a.b configures b.b = a.b+":"+ "test"'
+BA_CA = 'b.a requires c.a and c.b and a.b'
+
+CB_DA = 'c.b requires d.a'
+DA_DB = 'd.a requires d.b'
+
+AC_AB_BA = 'a.c and a.a requires b.a'
+
+EA_FSTAR = 'e.a requires f.*'
+
+TEST_RELATIONS = {
+ '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],
+ 'e.a' : [EA_FSTAR]
+}
+
+def get_test_configuration():
+ config = api.Configuration()
+ config.add_feature(api.Feature('a'))
+ config.add_feature(api.Feature('a'),'a')
+ config.add_feature(api.Feature('b'),'a')
+ config.add_feature(api.Feature('c'),'a')
+ config.add_feature(api.Feature('b'))
+ config.add_feature(api.Feature('a'),'b')
+ config.add_feature(api.Feature('b'),'b')
+ config.add_feature(api.Feature('c'))
+ config.add_feature(api.Feature('a'),'c')
+ config.add_feature(api.Feature('b'),'c')
+ config.add_feature(api.Feature('d'))
+ config.add_feature(api.Feature('a'),'d')
+ config.add_feature(api.Feature('b'),'d')
+ config.add_feature(api.Feature('e'))
+ config.add_feature(api.Feature('a'),'e')
+ dview = config.get_default_view()
+ dview.get_feature('a.a').set_value('test')
+ dview.get_feature('a.b').set_value('hey')
+ dview.get_feature('a.c').set_value(False)
+ dview.get_feature('b.a').set_value(True)
+ dview.get_feature('b.b').set_value(True)
+ dview.get_feature('c.a').set_value(True)
+ dview.get_feature('c.b').set_value(True)
+ dview.get_feature('d.a').set_value(False)
+ dview.get_feature('d.b').set_value(False)
+ return config
+
+class TestFactory():
+ def get_relations_for(self, configuration, ref):
+ rels = TEST_RELATIONS.get(ref)
+ if rels:
+ relation_container = RelationContainerImpl()
+ for rel in rels:
+ (left_expression,relation_name,right_expression) = parse_rule(rel)
+ relation = rules.RELATIONS.get(relation_name)(configuration, left_expression, right_expression)
+ relation_container.add_relation(relation)
+ propagated_relations = self.get_relations_for(configuration, right_expression)
+ if propagated_relations:
+ for relation in propagated_relations:
+ relation_container.add_relation(relation)
+ return relation_container
+ return None
+
+def parse_rule(rulestring):
+ """
+ Divide the given rule string into (left side, relation, right side) components.
+ @return: Triple (left side, relation, right side)
+ """
+ left_expression = ''
+ relation_name = None
+ right_expression = ''
+ for token in rules.get_tokens(rulestring):
+ if relation_name == None:
+ if token in rules.RELATIONS.keys():
+ relation_name = token
+ else:
+ left_expression += ' ' + token
+ else:
+ right_expression += ' ' + token
+
+ if relation_name == None:
+ raise exceptions.ParseError('invalid rule definition %s' % rulestring)
+
+ return (left_expression,relation_name,right_expression)
+
+class ConfigurationContext(DefaultContext):
+ def handle_terminal(self, expression):
+ try:
+ value = self.data.get_feature(expression).get_value()
+ if value != None:
+ #print "handle_terminal %s = %s" % (expression,value)
+ return value
+ else:
+ raise exceptions.NotBound('Feature %s has no value' % expression)
+ except exceptions.NotFound,e:
+ """ return the expression itself if it is not a fearef """
+ #print "handle_terminal constant %s" % (expression)
+ try:
+ return eval(expression)
+ except (NameError,SyntaxError), e:
+ return expression
+
+ 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)
+ 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)
+
+class ConfigureRelation(ConfigurationBaseRelation):
+ KEY = 'configures'
+ def __init__(self, data, left, right):
+ super(ConfigureRelation, self).__init__(data, left, right)
+ self.context = ConfigurationContext(data)
+
+def handle_configure(self, left, right):
+ if left and right:
+ return True
+ elif not left:
+ return True
+ return False
+
+def handle_set(self, left, right):
+ left.set_value(right)
+
+class ConfigureExpression(rules.TwoOperatorExpression):
+ PRECEDENCE = rules.PRECEDENCES['RELATION_OPERATORS']
+ KEY = 'configures'
+ OP = handle_configure
+
+ def eval(self, context):
+ super(ConfigureExpression, self).eval(context)
+ 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)
+
+ for key in left_keys:
+ self.ast.add_error(key, { 'error_string' : 'CONFIGURES right side value is "False"',
+ 'left_key' : key,
+ 'rule' : self.ast.expression
+ })
+ return self.value
+
+def handle_plus(self, a,b):
+ #print "%s adding a: %s to b: %s" % (self, a,b)
+ return a + b
+
+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()
+
+ self.RELATIONS_BACKUP = rules.RELATIONS
+ self.OPERATORS_BACKUP = rules.OPERATORS
+ rules.RELATIONS = rules.RELATIONS.copy()
+ rules.OPERATORS = rules.OPERATORS.copy()
+ self.assertTrue(self.RELATIONS_BACKUP is not rules.RELATIONS)
+ self.assertTrue(self.OPERATORS_BACKUP is not rules.OPERATORS)
+
+ 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
+
+ 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_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')
+ ret = rels.execute()
+ 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()
+ self.assertFalse(ret)
+
+ def test_two_on_the_left(self):
+ factory = TestFactory()
+ rels = factory.get_relations_for(self.configuration, 'a.c')
+ ret = rels.execute()
+ self.assertTrue(ret)
+
+ def test_configure_right_side(self):
+ factory = TestFactory()
+ rels = factory.get_relations_for(self.configuration, 'a.b')
+ ret = rels.execute()
+ self.assertTrue(ret)
+ self.assertEquals(self.configuration.get_default_view().get_feature('b.b').get_value(),'hey:test')
+
+if __name__ == '__main__':
+ unittest.main()