configurationengine/source/plugins/common/ConeRulePlugin/ruleplugin/evals/tests/unittest_layer_utils.py
changeset 3 e7e0ae78773e
parent 0 2e8eeb919028
equal deleted inserted replaced
2:87cfa131b535 3:e7e0ae78773e
    13 #
    13 #
    14 # Description: 
    14 # Description: 
    15 #
    15 #
    16 
    16 
    17 import unittest
    17 import unittest
    18 import os, shutil
    18 import os
    19 import sys
    19 
    20 import pkg_resources
    20 from cone.public import api
    21 import re
       
    22 import logging
       
    23 
       
    24 import __init__
       
    25 
       
    26 from ruleplugin import ruleml, relations
       
    27 from cone.public import api, exceptions
       
    28 from ruleplugin.evals import layer_utils
    21 from ruleplugin.evals import layer_utils
    29 ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
    22 ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
    30 
    23 
    31 #logger = logging.getLogger("cone.ruleplugin.evals.layer_utils")
    24 #logger = logging.getLogger("cone.ruleplugin.evals.layer_utils")
    32 #logger.setLevel(logging.DEBUG)
    25 #logger.setLevel(logging.DEBUG)
    84         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value1"),2,2))
    77         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value1"),2,2))
    85         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value1"),1,7))
    78         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value1"),1,7))
    86         self.assertFalse(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value1"),8,9))
    79         self.assertFalse(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value1"),8,9))
    87         self.assertFalse(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),0,1))
    80         self.assertFalse(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),0,1))
    88         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),1,5))
    81         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),1,5))
    89 
    82         
    90         
    83         self.assertFalse(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),3,5))
       
    84         self.assertFalse(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),5,3))
       
    85         self.assertFalse(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),-2,-1))
       
    86         self.assertFalse(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),-1,-2))
       
    87         
       
    88         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),2,5))
       
    89         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),5,2))
       
    90         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),-3,-1))
       
    91         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),-1,-3))
       
    92         
       
    93         self.assertFalse(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),3,1000))
       
    94         self.assertFalse(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),-1000,1))
       
    95         self.assertTrue(layer_utils.changed_on_layers(dview.get_feature("StringFeatureTest.Value2"),-1000,1000))
       
    96 
       
    97     def test_layers_used_single_layer(self):
       
    98         project = api.Project(api.Storage.open(os.path.join(ROOT_PATH,'layer_filtering_project')))
       
    99         root_config = project.get_configuration('root.confml')
       
   100         
       
   101         layer_base_config = root_config.get_configuration_by_index(0)
       
   102         layer1_config = root_config.get_configuration_by_index(1)
       
   103         layer2_config = root_config.get_configuration_by_index(2)
       
   104         layer3_config = root_config.get_configuration_by_index(3)
       
   105         layer4_config = root_config.get_configuration_by_index(4)
       
   106         layer5_config = root_config.get_configuration_by_index(5)
       
   107         layer6_config = root_config.get_configuration_by_index(6)
       
   108         layer7_config = root_config.get_configuration_by_index(7)
       
   109         layer8_config = root_config.get_configuration_by_index(8)
       
   110         layer9_config = root_config.get_configuration_by_index(9)
       
   111         layer10_config = root_config.get_configuration_by_index(10)
       
   112         layer11_config = root_config.get_configuration_by_index(11)
       
   113         
       
   114         self.assertTrue(layer_utils.layers_used(root_config, [root_config], {'target' : ['uda']}))
       
   115         self.assertTrue(layer_utils.layers_used(root_config, [root_config], {'target' : ['rofs2']}))
       
   116         
       
   117         self.assertTrue( layer_utils.layers_used(root_config, [layer_base_config], {'target' : ['uda']}))
       
   118         self.assertTrue( layer_utils.layers_used(root_config, [layer1_config], {'target' : ['uda']}))
       
   119         self.assertFalse(layer_utils.layers_used(root_config, [layer2_config], {'target' : ['uda']}))
       
   120         self.assertFalse(layer_utils.layers_used(root_config, [layer3_config], {'target' : ['uda']}))
       
   121         self.assertTrue( layer_utils.layers_used(root_config, [layer4_config], {'target' : ['uda']}))
       
   122         self.assertFalse(layer_utils.layers_used(root_config, [layer5_config], {'target' : ['uda']}))
       
   123 
       
   124         self.assertTrue( layer_utils.layers_used(root_config, [layer_base_config], {'target' : ['rofs2']}))
       
   125         self.assertFalse(layer_utils.layers_used(root_config, [layer1_config], {'target' : ['rofs2']}))
       
   126         self.assertTrue( layer_utils.layers_used(root_config, [layer2_config], {'target' : ['rofs2']}))
       
   127         self.assertFalse(layer_utils.layers_used(root_config, [layer3_config], {'target' : ['rofs2']}))
       
   128         
       
   129         self.assertTrue( layer_utils.layers_used(root_config, [layer5_config], {'target' : ['rofs3']}))
       
   130         self.assertFalse(layer_utils.layers_used(root_config, [layer5_config], {'target' : ['uda']}))
       
   131         
       
   132         self.assertFalse(layer_utils.layers_used(root_config, [layer6_config], {'target' : ['rofs2']}))
       
   133         self.assertTrue( layer_utils.layers_used(root_config, [layer6_config], {'target' : ['rofs3']}))
       
   134         self.assertTrue( layer_utils.layers_used(root_config, [layer6_config], {'target' : ['uda']}))
       
   135         
       
   136         self.assertFalse(layer_utils.layers_used(root_config, [layer7_config], {'target' : ['rofs3']}))
       
   137         self.assertTrue( layer_utils.layers_used(root_config, [layer7_config], {'target' : ['uda']}))
       
   138         
       
   139         self.assertFalse(layer_utils.layers_used(root_config, [layer8_config], {'target' : ['rofs3']}))
       
   140         self.assertFalse(layer_utils.layers_used(root_config, [layer8_config], {'target' : ['uda']}))
       
   141         
       
   142         self.assertFalse(layer_utils.layers_used(root_config, [layer9_config], {'target' : ['rofs3']}))
       
   143         self.assertTrue( layer_utils.layers_used(root_config, [layer9_config], {'target' : ['uda']}))
       
   144         
       
   145         self.assertFalse(layer_utils.layers_used(root_config, [layer10_config], {'target' : ['rofs3']}))
       
   146         self.assertTrue( layer_utils.layers_used(root_config, [layer10_config], {'target' : ['uda']}))
       
   147         
       
   148         self.assertFalse(layer_utils.layers_used(root_config, [layer11_config], {'target' : ['rofs3']}))
       
   149         self.assertTrue( layer_utils.layers_used(root_config, [layer11_config], {'target' : ['uda']}))
       
   150 
       
   151     def test_layers_used_regex(self):
       
   152         project = api.Project(api.Storage.open(os.path.join(ROOT_PATH,'layer_filtering_project')))
       
   153         root_config = project.get_configuration('root.confml')
       
   154         
       
   155         self.assertTrue(layer_utils.layers_used(root_config, r'/base/', {'target' : ['uda']}))
       
   156         self.assertTrue(layer_utils.layers_used(root_config, r'/base/', {'target' : ['rofs2']}))
       
   157         
       
   158         self.assertTrue( layer_utils.layers_used(root_config, r'/base/', {'target' : ['uda']}))
       
   159         self.assertTrue( layer_utils.layers_used(root_config, r'/layer1/', {'target' : ['uda']}))
       
   160         self.assertFalse(layer_utils.layers_used(root_config, r'/layer2/', {'target' : ['uda']}))
       
   161         self.assertFalse(layer_utils.layers_used(root_config, r'/layer3/', {'target' : ['uda']}))
       
   162         self.assertTrue( layer_utils.layers_used(root_config, r'/layer4/', {'target' : ['uda']}))
       
   163         self.assertFalse(layer_utils.layers_used(root_config, r'/layer5/', {'target' : ['uda']}))
       
   164 
       
   165         self.assertTrue( layer_utils.layers_used(root_config, r'/base/', {'target' : ['rofs2']}))
       
   166         self.assertFalse(layer_utils.layers_used(root_config, r'/layer1/', {'target' : ['rofs2']}))
       
   167         self.assertTrue( layer_utils.layers_used(root_config, r'/layer2/', {'target' : ['rofs2']}))
       
   168         self.assertFalse(layer_utils.layers_used(root_config, r'/layer3/', {'target' : ['rofs2']}))
       
   169 
       
   170         self.assertTrue( layer_utils.layers_used(root_config, r'/layer5/', {'target' : ['rofs3']}))
       
   171         self.assertFalse(layer_utils.layers_used(root_config, r'/layer5/', {'target' : ['uda']}))
       
   172         
       
   173         self.assertFalse(layer_utils.layers_used(root_config, r'/layer6/', {'target' : ['rofs2']}))
       
   174         self.assertTrue( layer_utils.layers_used(root_config, r'/layer6/', {'target' : ['rofs3']}))
       
   175         self.assertTrue( layer_utils.layers_used(root_config, r'/layer6/', {'target' : ['uda']}))
       
   176         
       
   177         self.assertFalse(layer_utils.layers_used(root_config, r'/layer7/', {'target' : ['rofs3']}))
       
   178         self.assertTrue( layer_utils.layers_used(root_config, r'/layer7/', {'target' : ['uda']}))
       
   179         
       
   180         self.assertFalse(layer_utils.layers_used(root_config, r'/layer8/', {'target' : ['rofs3']}))
       
   181         self.assertFalse(layer_utils.layers_used(root_config, r'/layer8/', {'target' : ['uda']}))
       
   182         
       
   183         self.assertFalse(layer_utils.layers_used(root_config, r'/layer9/', {'target' : ['rofs3']}))
       
   184         self.assertTrue( layer_utils.layers_used(root_config, r'/layer9/', {'target' : ['uda']}))
       
   185         
       
   186         self.assertFalse(layer_utils.layers_used(root_config, r'/layer10/', {'target' : ['rofs3']}))
       
   187         self.assertTrue( layer_utils.layers_used(root_config, r'/layer10/', {'target' : ['uda']}))
       
   188     
       
   189     def test_changed_on_layers_regex(self):
       
   190         project = api.Project(api.Storage.open(os.path.join(ROOT_PATH, 'layerproject')))
       
   191         config = project.get_configuration('foobar_root.confml')
       
   192         dview = config.get_default_view()
       
   193         
       
   194         def check(regex, feature, expected):
       
   195             self.assertEquals(layer_utils.changed_on_layers_regex(dview.get_feature(feature), regex),
       
   196                               expected)
       
   197         
       
   198         check(r'.*', 'TestFeature.CustvariantManual', True)
       
   199         
       
   200         regex = r'/custvariant(_.*)?/manual/'
       
   201         check(regex, 'TestFeature.CustvariantManual', True)
       
   202         check(regex, 'TestFeature.CustvariantConfigurator', False)
       
   203         check(regex, 'TestFeature.Rnd', False)
       
   204         
       
   205         regex = r'/custvariant(_.*)?/configurator/'
       
   206         check(regex, 'TestFeature.CustvariantManual', False)
       
   207         check(regex, 'TestFeature.CustvariantConfigurator', True)
       
   208         check(regex, 'TestFeature.Rnd', False)
       
   209         
       
   210         regex = r'/custvariant(_.*)?/'
       
   211         check(regex, 'TestFeature.CustvariantManual', True)
       
   212         check(regex, 'TestFeature.CustvariantConfigurator', True)
       
   213         check(regex, 'TestFeature.Rnd', False)
       
   214         
       
   215         regex = r'foo/bar/'
       
   216         check(regex, 'StringFeatureTest.Value1', False)
       
   217         check(regex, 'TestFeature.CustvariantManual', True)
       
   218         check(regex, 'TestFeature.CustvariantConfigurator', True)
       
   219         check(regex, 'TestFeature.Rnd', True)
       
   220         
       
   221         regex = r'/rnd/'
       
   222         check(regex, 'TestFeature.CustvariantManual', False)
       
   223         check(regex, 'TestFeature.CustvariantConfigurator', False)
       
   224         check(regex, 'TestFeature.Rnd', True)
       
   225     
       
   226     def test_changed_on_custvariant_layer(self):
       
   227         project = api.Project(api.Storage.open(os.path.join(ROOT_PATH, 'layerproject')))
       
   228         config = project.get_configuration('foobar_root.confml')
       
   229         dview = config.get_default_view()
       
   230         
       
   231         def check(feature, expected):
       
   232             self.assertEquals(layer_utils.changed_on_custvariant_layer(dview.get_feature(feature)),
       
   233                               expected)
       
   234         check('StringFeatureTest.Value1', False)
       
   235         check('StringFeatureTest.Value2', False)
       
   236         check('TestFeature.CustvariantManual', True)
       
   237         check('TestFeature.CustvariantConfigurator', True)
       
   238         check('TestFeature.Rnd', False)
       
   239 
    91 if __name__ == "__main__":
   240 if __name__ == "__main__":
    92     unittest.main()
   241     unittest.main()