cmdatahandlers/tests/performance_profiles_config_test.py

   1 # Copyright 2019 Nokia
   2
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 from unittest import TestCase
  16 from cmdatahandlers.api import configmanager
  17 import cmdatahandlers.performance_profiles.config
  18 from cmdatahandlers.api.configerror import ConfigError
  19
  20
  21 class PerformanceProfilesConfigTest(TestCase):
  22
  23
  24     profile = 'dpdk_profile'
  25     profile_data = {profile: {'platform_cpus': {'numa0': 1, 'numa1': 1},
  26                               'ovs_dpdk_cpus': {'numa0': 2, 'numa1': 2},
  27                               'default_hugepagesz': '1M',
  28                               'hugepagesz': '1G',
  29                               'hugepages': 192
  30                              }
  31                    }
  32     hosts_data = {'controller-1':{'service_profiles': ['controller']}}
  33
  34     config = {'cloud.performance_profiles': profile_data,
  35               'cloud.hosts': hosts_data }
  36
  37     fail_profile ='dpdk_fail_profile'
  38     config_fail = {'cloud.performance_profiles': {fail_profile: {} },
  39                    'cloud.hosts': hosts_data }
  40
  41     def setUp(self):
  42         confman = configmanager.ConfigManager(self.config)
  43         self.pp_handler = confman.get_performance_profiles_config_handler()
  44
  45         confman_fail = configmanager.ConfigManager(self.config_fail)
  46         self.pp_handler_fail = confman_fail.get_performance_profiles_config_handler()
  47
  48     def test_validate(self):
  49         self.pp_handler.validate()
  50
  51     def test_is_valid_profile_raises_error(self):
  52         with self.assertRaisesRegexp(ConfigError, "Invalid profile name foo_profile"):
  53             self.pp_handler.is_valid_profile('foo_profile')
  54
  55     def test_get_performance_profiles(self):
  56         profiles_data = self.pp_handler.get_performance_profiles()
  57         expected_data = [self.profile]
  58         self.assertEqual(profiles_data, expected_data)
  59
  60     def test_get_profile_default_hugepage_size(self):
  61         default_hugepagesz_data = self.pp_handler.get_profile_default_hugepage_size(self.profile)
  62         expected_data = '1M'
  63         self.assertEqual(default_hugepagesz_data, expected_data)
  64
  65     def test_get_profile_default_hugepage_size_raises_error(self):
  66         error_text = "Profile {} does not have default_hugepagesz".format(self.fail_profile)
  67         with self.assertRaisesRegexp(ConfigError, error_text):
  68             self.pp_handler_fail.get_profile_default_hugepage_size(self.fail_profile)
  69
  70     def test_get_profile_hugepage_size(self):
  71         hugepagesz_data = self.pp_handler.get_profile_hugepage_size(self.profile)
  72         expected_data = '1G'
  73         self.assertEqual(hugepagesz_data, expected_data)
  74
  75     def test_get_profile_hugepage_size_raises_error(self):
  76         error_text = "Profile {} does not have hugepagesz".format(self.fail_profile)
  77         with self.assertRaisesRegexp(ConfigError, error_text):
  78             self.pp_handler_fail.get_profile_hugepage_size(self.fail_profile)
  79
  80     def test_get_profile_hugepage_count(self):
  81         hugepages_data = self.pp_handler.get_profile_hugepage_count(self.profile)
  82         expected_data = 192
  83         self.assertEqual(hugepages_data, expected_data)
  84
  85     def test_get_profile_hugepage_count_raises_error(self):
  86         error_text = "Profile {} does not have hugepages".format(self.fail_profile)
  87         with self.assertRaisesRegexp(ConfigError, error_text):
  88             self.pp_handler_fail.get_profile_hugepage_count(self.fail_profile)
  89
  90     def test_get_platform_cpus(self):
  91         platform_cpus_data = self.pp_handler.get_platform_cpus(self.profile)
  92         expected_data = {'numa0': 1, 'numa1': 1}
  93         self.assertEqual(platform_cpus_data, expected_data)
  94
  95     def test_get_platform_cpus_raises(self):
  96         error_text = "Profile {} does not have platform_cpus".format(self.fail_profile)
  97         with self.assertRaisesRegexp(ConfigError, error_text):
  98             self.pp_handler_fail.get_platform_cpus(self.fail_profile)
  99
 100     def test_get_ovs_dpdk_cpus(self):
 101         ovs_dpdk_cpus_data = self.pp_handler.get_ovs_dpdk_cpus(self.profile)
 102         expected_data = {'numa0': 2, 'numa1': 2}
 103         self.assertEqual(ovs_dpdk_cpus_data, expected_data)
 104
 105     def test_get_ovs_dpdk_cpus_raises_error(self):
 106         error_text = "Profile {} does not have ovs_dpdk_cpus".format(self.fail_profile)
 107         with self.assertRaisesRegexp(ConfigError, error_text):
 108             self.pp_handler_fail.get_ovs_dpdk_cpus(self.fail_profile)
 109
 110     def test__fill_option_value(self):
 111         data = {}
 112         self.pp_handler._fill_option_value(data, self.profile, 'platform_cpus', None)
 113         self.assertEqual(data, {'platform_cpus': {'numa0': 1, 'numa1': 1}})
 114         self.pp_handler._fill_option_value(data, self.profile, 'platform_cpus', {'numa0': 5})
 115         self.assertEqual(data, {'platform_cpus': {'numa0': 5}})
 116
 117     def test_update(self):
 118         cman = configmanager.ConfigManager({'cloud.performance_profiles': {}, 'cloud.hosts': self.hosts_data})
 119         h = cman.get_performance_profiles_config_handler()
 120         profile = 'niksnaks'
 121         platform_cpus = {'numa0': 1, 'numa1': 1}
 122         ovs_dpdk_cpus = {'numa0': 2, 'numa1': 2}
 123         hugepages = 8
 124         h.update(profile, platform_cpus, ovs_dpdk_cpus, hugepages)
 125         self.assertEqual(h.get_performance_profiles(), [profile])
 126         self.assertEqual(h.get_platform_cpus(profile), platform_cpus)
 127         self.assertEqual(h.get_ovs_dpdk_cpus(profile), ovs_dpdk_cpus)
 128         self.assertEqual(h.get_profile_hugepage_count(profile), hugepages)
 129         with self.assertRaisesRegexp(ConfigError, 'Profile niksnaks does not have hugepagesz'):
 130             h.get_profile_hugepage_size(profile)
 131         with self.assertRaisesRegexp(ConfigError, 'Profile niksnaks does not have default_hugepagesz'):
 132             h.get_profile_default_hugepage_size(profile)
 133
 134     def test_delete(self):
 135         cman = configmanager.ConfigManager({'cloud.performance_profiles': {}, 'cloud.hosts': self.hosts_data})
 136         h = cman.get_performance_profiles_config_handler()
 137         profile = 'nice_profile'
 138         h.update(profile, '1-8', '4', 2)
 139         h.delete(profile)
 140         error_text = 'Invalid profile name {}'.format(profile)
 141         self.assertEqual(h.get_performance_profiles(), [])
 142         with self.assertRaisesRegexp(ConfigError, error_text):
 143             h.delete(profile)
 144
 145     def test_dump(self):
 146         data = self.pp_handler.dump()
 147         self.assertEqual(data, self.profile_data)
 148
 149
 150 if __name__ == '__main__':
 151     unittest.main()