Mercurial Mercurial > oss > FCL > sftools > depl > swconfigmdw / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
configurationengine/source/cone/public/tests/unittest_views.py
changeset 3 e7e0ae78773e
parent 0 2e8eeb919028
equal deleted inserted replaced
2:87cfa131b535 3:e7e0ae78773e 
    18 Test the configuration
 
    18 Test the configuration
 
    19 """
 
    19 """
 
    20 import unittest
 
    20 import unittest
 
    21 import string
 
    21 import string
 
    22 import sys,os
 
    22 import sys,os
 
    23 import __init__
 
    23 
       
    24 ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
 
    24 
    25 
    25 from cone.public import api,exceptions,utils
 
    26 from cone.public import api,exceptions,utils
 
    26 
    27 
    27 class TestViews(unittest.TestCase):    
    28 class TestViews(unittest.TestCase):    
    28     def setUp(self):
 
    29     def setUp(self):
 
    29         pass
 
    30         pass
 
    30 
    31 
    31     def test_create_view(self):
 
    32     def test_create_view(self):
 
    32         view = api.View("view1")
 
    33         view = api.View("view1")
 
       
    34         self.assertTrue(view)
 
       
    35         self.assertTrue(view.ref, "view1")
 
       
    36 
       
    37     def test_create_view_with_configuration(self):
 
       
    38         config = api.Configuration("")
 
       
    39         view = config.create_view("view1")
 
    33         self.assertTrue(view)
 
    40         self.assertTrue(view)
 
    34         self.assertTrue(view.ref, "view1")
 
    41         self.assertTrue(view.ref, "view1")
 
    35 
    42 
    36     def test_view_add(self):
 
    43     def test_view_add(self):
 
    37         view = api.View("view1")
 
    44         view = api.View("view1")
 
    65     def test_feature_add(self):
 
    72     def test_feature_add(self):
 
    66         feature = api.Feature("Feature")
 
    73         feature = api.Feature("Feature")
 
    67         feature._add(api.Feature("Test"))
 
    74         feature._add(api.Feature("Test"))
 
    68         self.assertEquals(feature._list(),['Test'])
 
    75         self.assertEquals(feature._list(),['Test'])
 
    69 
    76 
    70     def test_view_add_groups_and_features_and_list_all(self):
 
    77     def test_view_create_groups_and_features_and_list_all(self):
 
    71         view = api.View("view1")
 
    78         view = api.View("view1")
 
    72         view._add(api.Group("group1"))
 
    79         view._add(api.Group("group1"))
 
    73         view._add(api.Group("group2"))
 
    80         view._add(api.Group("group2"))
 
    74         view._add(api._FeatureProxy("feature1"))
 
    81         view._add(api._FeatureProxy("feature1"))
 
    75         view.group1._add(api.Group("group21"))
 
    82         view.group1._add(api.Group("group21"))
 
    83                                            'group1.group21', 
    90                                            'group1.group21', 
    84                                            'group1.group21.feature211', 
    91                                            'group1.group21.feature211', 
    85                                            'group1.group21.feature212', 
    92                                            'group1.group21.feature212', 
    86                                            'feature1.feature11']))
 
    93                                            'feature1.feature11']))
 
    87 
    94 
    88     def test_view_add_groups_and_features_and_list_features(self):
 
    95     def test_view_create_groups_and_features_and_list_features(self):
 
    89         view = api.View("view1")
 
    96         view = api.View("view1")
 
    90         view._add(api.Group("group1"))
 
    97         view._add(api.Group("group1"))
 
    91         view._add(api.Group("group2"))
 
    98         view._add(api.Group("group2"))
 
    92         view._add(api._FeatureProxy("feature1"))
 
    99         view._add(api._FeatureProxy("feature1"))
 
    93         view.group1._add(api.Group("group21"))
 
   100         view.group1._add(api.Group("group21"))
 
   111                                           'com.nokia.s60.feature2', 
   118                                           'com.nokia.s60.feature2', 
   112                                           'com.nokia.s60.feature2.feature21', 
   119                                           'com.nokia.s60.feature2.feature21', 
   113                                           ]))
 
   120                                           ]))
 
   114 
   121 
   115 
   122 
   116     def test_view_add_features_and_get_features(self):
 
   123     def test_view_add_features_and_get_matching_features(self):
 
   117         view = api.View("view1")
 
   124         view = api.View("view1")
 
   118         view.add_feature(api.Feature("feature1"))
 
   125         view.add_feature(api.Feature("feature1"))
 
   119         view.add_feature(api.Feature("feature2"), "com.nokia.s60")
 
   126         view.add_feature(api.Feature("feature2"), "com.nokia.s60")
 
   120         view.com.nokia.s60.feature2.add_feature(api.Feature("feature21"))
 
   127         view.com.nokia.s60.feature2.add_feature(api.Feature("feature21"))
 
   121         self.assertEquals(view.get_feature("com.nokia.s60.feature2"), view.com.nokia.s60.feature2)
 
   128         self.assertEquals(view.get_feature("com.nokia.s60.feature2"), view.com.nokia.s60.feature2)
 
   122 
   129 
   123     def test_view_get_features(self):
 
   130     def test_view_get_matching_features(self):
 
   124         view = api.View("view1")
 
   131         view = api.View("view1")
 
   125         view.add_feature(api.Feature("feature1",type='boolean'))
 
   132         view.add_feature(api.Feature("feature1",type='boolean'))
 
   126         view.add_feature(api.Feature("feature2"))
 
   133         view.add_feature(api.Feature("feature2"))
 
   127         view.add_feature(api.Feature("feature11", type='boolean'),"feature1")
 
   134         view.add_feature(api.Feature("feature11", type='boolean'),"feature1")
 
   128         view.add_feature(api.Feature("feature12"),"feature1")
 
   135         view.add_feature(api.Feature("feature12"),"feature1")
 
   129         self.assertEquals(view.get_features("feature2"), [view.feature2])
 
   136         self.assertEquals(view.get_matching_features("feature2"), [view.feature2])
 
   130         self.assertEquals(view.get_features("feature2.*"), [])
 
   137         self.assertEquals(view.get_matching_features("feature2.*"), [])
 
   131         self.assertEquals(view.get_features("feature1.*"), [view.feature1.feature11, view.feature1.feature12])
 
   138         self.assertEquals(view.get_matching_features("feature1.*"), [view.feature1.feature11, view.feature1.feature12])
 
   132         self.assertEquals(view.get_features("feature1.*", name='feature11'), [view.feature1.feature11])
 
   139         self.assertEquals(view.get_matching_features("feature1.*", name='feature11'), [view.feature1.feature11])
 
   133         self.assertEquals(view.get_features("**", filters=[lambda x: x.get_type()=='boolean']), 
   140         self.assertEquals(view.get_matching_features("**", filters=[lambda x: x.get_type()=='boolean']), 
   134                           [view.feature1,
 
   141                           [view.feature1,
 
   135                            view.feature1.feature11])
 
   142                            view.feature1.feature11])
 
       
   143 
       
   144 
       
   145     def test_view_get_matching_features_with_list(self):
 
       
   146         view = api.View("view1")
 
       
   147         view.add_feature(api.Feature("feature1",type='boolean'))
 
       
   148         view.add_feature(api.Feature("feature2"))
 
       
   149         view.add_feature(api.Feature("feature11", type='boolean'),"feature1")
 
       
   150         view.add_feature(api.Feature("feature12"),"feature1")
 
       
   151         self.assertEquals(view.get_features(["feature2", "feature1"]), [view.feature2, view.feature1])
 
       
   152         self.assertEquals(view.get_features(["feature2", "feature1.*"]), [view.feature2, 
       
   153                                                                           view.feature1.feature11,
 
       
   154                                                                           view.feature1.feature12])
 
       
   155         self.assertEquals(view.get_features([""]), [])
 
   136 
   156 
   137     def test_view_add_features_and_remove_features(self):
 
   157     def test_view_add_features_and_remove_features(self):
 
   138         view = api.View("view1")
 
   158         view = api.View("view1")
 
   139         view.add_feature(api.Feature("feature1"))
 
   159         view.add_feature(api.Feature("feature1"))
 
   140         view.add_feature(api.Feature("feature2"), "com.nokia.s60")
 
   160         view.add_feature(api.Feature("feature2"), "com.nokia.s60")
 
   144         self.assertEquals(view.get_group("com.nokia.s60").list_features(),['feature2'])
 
   164         self.assertEquals(view.get_group("com.nokia.s60").list_features(),['feature2'])
 
   145         for fearef in view.list_features():
 
   165         for fearef in view.list_features():
 
   146             view.remove_feature(fearef)
 
   166             view.remove_feature(fearef)
 
   147         self.assertEquals(view.list_all_features(),['com.nokia.s60.feature2', 'com.nokia.s60.feature2.feature21'])
 
   167         self.assertEquals(view.list_all_features(),['com.nokia.s60.feature2', 'com.nokia.s60.feature2.feature21'])
 
   148 
   168 
   149     def test_view_add_groups_remove_groups(self):
 
   169     def test_view_create_groups_remove_groups(self):
 
   150         view = api.View("view1")
 
   170         view = api.View("view1")
 
   151         view.add_group("Group one")
 
   171         view.create_group("Group one")
 
   152         view.add_group("Group two")
 
   172         view.create_group("Group two")
 
   153         view.add_feature(api.Feature("feature2"),"Group one")
 
   173         view.add_feature(api.Feature("feature2"),"Group one")
 
   154         self.assertEquals(view.list_groups(),['Group one',  'Group two'])
 
   174         self.assertEquals(view.list_groups(),['Group one',  'Group two'])
 
   155         view.remove_group("Group two")
 
   175         view.remove_group("Group two")
 
   156         self.assertEquals(view.list_groups(),['Group one'])
 
   176         self.assertEquals(view.list_groups(),['Group one'])
 
   157         view.get_group('Group one').add_feature(api.Feature("testing"))
 
   177         view.get_group('Group one').add_feature(api.Feature("testing"))
 
   159         self.assertEquals(view.list_all_features(),['Group one.feature2', 'Group one.testing'])
 
   179         self.assertEquals(view.list_all_features(),['Group one.feature2', 'Group one.testing'])
 
   160         view.remove_group("Group one")
 
   180         view.remove_group("Group one")
 
   161         self.assertEquals(view.list_groups(),[])
 
   181         self.assertEquals(view.list_groups(),[])
 
   162         self.assertEquals(view.list_features(),[])
 
   182         self.assertEquals(view.list_features(),[])
 
   163 
   183 
       
   184     def test_create_featurelink(self):
 
       
   185         self.assertEquals(api.FeatureLink.get_featurelink_ref("fealink"), "link_fealink")
 
       
   186         fealink = api.FeatureLink("fealink")
 
       
   187         self.assertEquals(fealink.ref, "link_fealink")
 
       
   188         self.assertEquals(fealink.link, "fealink")
 
       
   189         
       
   190     def test_view_create_featurelink(self):
 
       
   191         view = api.View("view1")
 
       
   192         fl = view.create_featurelink("Testing.foobar")
 
       
   193         self.assertTrue(isinstance(fl, api.FeatureLink))
 
       
   194         self.assertEquals(view.get_featurelink("Testing.foobar"), fl)
 
       
   195         
       
   196 
       
   197     def test_view_create_group_with_name(self):
 
       
   198         view = api.View("view1")
 
       
   199         view.create_group("Group one", name="Testing group")
 
       
   200         self.assertEquals(view.get_group("Group one").name, "Testing group")
 
       
   201 
   164     def test_view_add_featurelink(self):
 
   202     def test_view_add_featurelink(self):
 
   165         view = api.View("view1")
 
   203         view = api.View("view1")
 
   166         view.add_group("Group one")
 
   204         view.create_group("Group one")
 
   167         view.add_group("Group two")
 
   205         view.create_group("Group two")
 
   168         view.add_feature(api.Feature("feature2"),"Group one")
 
   206         view.add_feature(api.Feature("feature2"),"Group one")
 
   169         self.assertEquals(view.list_groups(),['Group one',  'Group two'])
 
   207         self.assertEquals(view.list_groups(),['Group one',  'Group two'])
 
   170         view.remove_group("Group two")
 
   208         view.remove_group("Group two")
 
   171         #view.add(api.FeatureGroup('foo.*'))
 
   209         #view.add(api.FeatureGroup('foo.*'))
 
   172         self.assertEquals(view.list_groups(),['Group one'])
 
   210         self.assertEquals(view.list_groups(),['Group one'])
 
   173         view.get_group('Group one').add(api.FeatureLink("testing"))
 
   211         view.get_group('Group one').create_featurelink("testing", name='testing 1')
 
       
   212         self.assertEquals(view.get_group('Group one').get_featurelink('testing').get_name(), 'testing 1')
 
   174         g1 = view.get_group('Group one')
 
   213         g1 = view.get_group('Group one')
 
   175         self.assertEquals(g1.list_features(),['feature2'])
 
   214         self.assertEquals(g1.list_features(),['feature2'])
 
   176         self.assertEquals(view.list_all_features(),['Group one.feature2'])
 
   215         self.assertEquals(view.list_all_features(),['Group one.feature2'])
 
   177         view.remove_group("Group one")
 
   216         view.remove_group("Group one")
 
   178 
   217 
   179         self.assertEquals(view.list_groups(),[])
 
   218         self.assertEquals(view.list_groups(),[])
 
   180         self.assertEquals(view.list_features(),[])
 
   219         self.assertEquals(view.list_features(),[])
 
   181 
   220 
       
   221     def test_feature_link_get_overrides(self):
 
       
   222         fl = api.FeatureLink("testing")
 
       
   223         self.assertEquals(fl.get_attributes(), {})
 
       
   224         self.assertEquals(fl.get_attributes(), {})
 
       
   225         fl.override_attributes.append('desc')
 
       
   226         fl.override_attributes.append('name')
 
       
   227         fl.name = None
 
       
   228         fl.desc = "test"
 
       
   229         self.assertEquals(fl.get_attributes(), {'desc': 'test'})
 
       
   230         fl.desc = "bar"
 
       
   231         self.assertEquals(fl.get_attributes(), {'desc': 'bar'})
 
       
   232         fl.desc = ""
 
       
   233         fl.minLength = 2
 
       
   234         fl.override_attributes.append('minLength')
 
       
   235         self.assertEquals(fl.get_attributes(), { 'minLength' : 2, 'desc': ''})
 
       
   236 
       
   237     def test_add_view_to_configuration_and_populate(self):
 
       
   238         config = api.Configuration("foo")
 
       
   239         config.add_feature(api.Feature("testing"))
 
       
   240         view = api.View("view1")
 
       
   241         view.create_group("Group one")
 
       
   242         fl = api.FeatureLink("testing")
 
       
   243         view.get_group('Group one').add(fl)
 
       
   244         config.add_view(view)
 
       
   245         view.populate()
 
       
   246         self.assertEquals(view.get_group('Group one').list_features(),['proxy_testing'])
 
       
   247     
       
   248     def test_view_add_featurelink_with_description_override(self):
 
       
   249         api.FeatureLink.override_attributes.append('dict')
 
       
   250         config = api.Configuration("foo")
 
       
   251         fea = api.Feature("testing")
 
       
   252         fea.desc = "feature desc"
 
       
   253         config.add_feature(fea)
 
       
   254         view = api.View("view1")
 
       
   255         view.create_group("Group one")
 
       
   256         fl = api.FeatureLink("testing")
 
       
   257         fl.desc = "view desc"
 
       
   258         view.get_group('Group one').add(fl)
 
       
   259         config.add_view(view)
 
       
   260         view.populate()
 
       
   261         self.assertEquals(view.get_group('Group one').list_features(),['proxy_testing'])
 
       
   262         self.assertEquals(view.get_group('Group one').get_feature('proxy_testing').desc, "view desc")
 
       
   263     
   182     def compareview(self,view1,view2):
 
   264     def compareview(self,view1,view2):
 
   183         self.assertEquals(view1.ref, view2.ref)
 
   265         self.assertEquals(view1.ref, view2.ref)
 
   184         self.assertEquals(view1.container, view2.container)
 
   266         self.assertEquals(view1.container, view2.container)
 
   185         self.assertEquals(view1.name, view2.name)
 
   267         self.assertEquals(view1.name, view2.name)
 
   186         self.assertEquals(view1.support_data, view2.support_data)
 
   268         self.assertEquals(view1.support_data, view2.support_data)
 
   187 
   269 
   188 
   270 
   189     def test_clone_view_with_featurelink(self):
 
   271     def test_clone_view_with_featurelink(self):
 
   190         view1 = api.View("view1")
 
   272         view1 = api.View("view1")
 
   191         view1.add_group("Group one")
 
   273         view1.create_group("Group one")
 
   192         view1.add_group("Group two")
 
   274         view1.create_group("Group two")
 
   193         view1.get_group('Group one').add(api.FeatureLink("testing"))
 
   275         view1.get_group('Group one').create_featurelink("testing/foo")
 
   194         fea2 = api.Feature("feature2")
 
   276         fea2 = api.Feature("feature2")
 
   195         view1.add_feature(fea2,"Group one")
 
   277         view1.add_feature(fea2,"Group one")
 
   196         view1.add_feature(api.Feature("feature3"),"Group one")
 
   278         view1.add_feature(api.Feature("feature3"),"Group one")
 
   197         self.assertEquals(view1.list_groups(),['Group one',  'Group two'])
 
   279         self.assertEquals(view1.list_groups(),['Group one',  'Group two'])
 
   198         
   280         
   199         view2 = view1._clone(recursion=True)
 
   281         view2 = view1._clone(recursion=True)
 
   200         self.compareview(view1,view2)
 
   282         self.compareview(view1,view2)
 
   201         self.assertEquals(view2.list_groups(),['Group one',  'Group two'])
 
   283         self.assertEquals(view2.list_groups(),['Group one',  'Group two'])
 
   202         self.assertEquals(view2.get_group('Group one')._list(),['testing', 'feature2', 'feature3'])
 
   284         self.assertEquals(view2.get_group('Group one')._list(),['link_testing_foo', 'feature2', 'feature3'])
 
   203         #self.assertEquals(view2.get_group('Group one').feature2._obj, fea2)
 
   285         #self.assertEquals(view2.get_group('Group one').feature2._obj, fea2)
 
   204         
   286     
   205         
   287     
       
   288     def test_populate_group_with_same_name_features(self):
 
       
   289         config = api.Configuration("foo")
 
       
   290         
       
   291         feature = api.Feature("Feature1", name="Some feature")
 
       
   292         feature.add_feature(api.Feature("Setting1", name="Setting 1"))
 
       
   293         feature.add_feature(api.Feature("Setting2", name="Setting 2"))
 
       
   294         config.add_feature(feature)
 
       
   295         
       
   296         feature = api.Feature("Feature2", name="Some feature")
 
       
   297         feature.add_feature(api.Feature("Setting1", name="Setting 1"))
 
       
   298         feature.add_feature(api.Feature("Setting2", name="Setting 2"))
 
       
   299         config.add_feature(feature)
 
       
   300         
       
   301         
       
   302         view = api.View('testview')
 
       
   303         config.add_view(view)
 
       
   304         
       
   305         # Test using explicit links for all settings
 
       
   306         view.create_group('testgroup')
 
       
   307         group = view.get_group('testgroup')
 
       
   308         group.create_featurelink('Feature1.Setting1')
 
       
   309         group.create_featurelink('Feature1.Setting2')
 
       
   310         group.create_featurelink('Feature2.Setting1')
 
       
   311         group.create_featurelink('Feature2.Setting2')
 
       
   312         
       
   313         group.populate()
 
       
   314         self.assertEquals(sorted(group.list_features()),
 
       
   315                           ['proxy_Feature1_Setting1',
 
       
   316                            'proxy_Feature1_Setting2',
 
       
   317                            'proxy_Feature2_Setting1',
 
       
   318                            'proxy_Feature2_Setting2'])
 
       
   319         
       
   320         
       
   321         # Test using wildcards
 
       
   322         view.create_group('testgroup2')
 
       
   323         group = view.get_group('testgroup2')
 
       
   324         group.create_featurelink('Feature1.*')
 
       
   325         group.create_featurelink('Feature2.*')
 
       
   326         
       
   327         group.populate()
 
       
   328         self.assertEquals(sorted(group.list_features()),
 
       
   329                           ['proxy_Feature1_Setting1',
 
       
   330                            'proxy_Feature1_Setting2',
 
       
   331                            'proxy_Feature2_Setting1',
 
       
   332                            'proxy_Feature2_Setting2'])
 
       
   333     
       
   334     def test_readonly_attribute(self):
 
       
   335         p = api.Project(api.Storage.open(os.path.join(ROOT_PATH,'testdata', 'view_tests')))
 
       
   336         root = p.get_configuration('view_tests-cpf.confml')
 
       
   337         views = root.get_view(root.list_views()[0])
 
       
   338         seqs = views.get_group('Sequences')
 
       
   339         japan_car_name = seqs.get_feature('proxy_japan-car-fea_CarSequence_CarName')
 
       
   340         self.assertTrue(japan_car_name.readOnly)
 
       
   341     
   206 if __name__ == '__main__':
 
   342 if __name__ == '__main__':
 
   207       unittest.main()
 
   343       unittest.main()
 
   208 
   344
FCL/sftools/depl/swconfigmdw