diff -r 000000000000 -r 2e8eeb919028 configurationengine/source/cone/public/tests/unittest_rules_on_configuration.py --- /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()