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 import copy
  20
  21
  22 class PerformanceProfilesConfigTest(TestCase):
  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                               'tuning': 'low_latency'
  31                               }
  32                     }
  33     hosts_data = {'controller-1': {'service_profiles': ['controller']}}
  34
  35     config = {'cloud.performance_profiles': profile_data,
  36               'cloud.hosts': hosts_data }
  37
  38     fail_profile = 'dpdk_fail_profile'
  39     config_fail = {'cloud.performance_profiles': {fail_profile: {} },
  40                    'cloud.hosts': hosts_data }
  41
  42     def setUp(self):
  43         confman = configmanager.ConfigManager(copy.deepcopy(self.config))
  44         self.pp_handler = confman.get_performance_profiles_config_handler()
  45
  46         confman_fail = configmanager.ConfigManager(self.config_fail)
  47         self.pp_handler_fail = confman_fail.get_performance_profiles_config_handler()
  48
  49     def test_validate(self):
  50         self.pp_handler.validate()
  51
  52     def test_is_valid_profile_raises_error(self):
  53         with self.assertRaisesRegexp(ConfigError, "Invalid profile name foo_profile"):
  54             self.pp_handler.is_valid_profile('foo_profile')
  55
  56     def test_get_performance_profiles(self):
  57         profiles_data = self.pp_handler.get_performance_profiles()
  58         expected_data = [self.profile]
  59         self.assertEqual(profiles_data, expected_data)
  60
  61     def test_get_profile_default_hugepage_size(self):
  62         default_hugepagesz_data = self.pp_handler.get_profile_default_hugepage_size(self.profile)
  63         expected_data = '1M'
  64         self.assertEqual(default_hugepagesz_data, expected_data)
  65
  66     def test_get_profile_default_hugepage_size_raises_error(self):
  67         error_text = "Profile {} does not have default_hugepagesz".format(self.fail_profile)
  68         with self.assertRaisesRegexp(ConfigError, error_text):
  69             self.pp_handler_fail.get_profile_default_hugepage_size(self.fail_profile)
  70
  71     def test_get_profile_hugepage_size(self):
  72         hugepagesz_data = self.pp_handler.get_profile_hugepage_size(self.profile)
  73         expected_data = '1G'
  74         self.assertEqual(hugepagesz_data, expected_data)
  75
  76     def test_get_profile_hugepage_size_raises_error(self):
  77         error_text = "Profile {} does not have hugepagesz".format(self.fail_profile)
  78         with self.assertRaisesRegexp(ConfigError, error_text):
  79             self.pp_handler_fail.get_profile_hugepage_size(self.fail_profile)
  80
  81     def test_get_profile_hugepage_count(self):
  82         hugepages_data = self.pp_handler.get_profile_hugepage_count(self.profile)
  83         expected_data = 192
  84         self.assertEqual(hugepages_data, expected_data)
  85
  86     def test_get_profile_hugepage_count_raises_error(self):
  87         error_text = "Profile {} does not have hugepages".format(self.fail_profile)
  88         with self.assertRaisesRegexp(ConfigError, error_text):
  89             self.pp_handler_fail.get_profile_hugepage_count(self.fail_profile)
  90
  91     def test_get_platform_cpus(self):
  92         platform_cpus_data = self.pp_handler.get_platform_cpus(self.profile)
  93         expected_data = {'numa0': 1, 'numa1': 1}
  94         self.assertEqual(platform_cpus_data, expected_data)
  95
  96     def test_get_platform_cpus_raises(self):
  97         error_text = "Profile {} does not have platform_cpus".format(self.fail_profile)
  98         with self.assertRaisesRegexp(ConfigError, error_text):
  99             self.pp_handler_fail.get_platform_cpus(self.fail_profile)
 100
 101     def test_get_ovs_dpdk_cpus(self):
 102         ovs_dpdk_cpus_data = self.pp_handler.get_ovs_dpdk_cpus(self.profile)
 103         expected_data = {'numa0': 2, 'numa1': 2}
 104         self.assertEqual(ovs_dpdk_cpus_data, expected_data)
 105
 106     def test_get_ovs_dpdk_cpus_raises_error(self):
 107         error_text = "Profile {} does not have ovs_dpdk_cpus".format(self.fail_profile)
 108         with self.assertRaisesRegexp(ConfigError, error_text):
 109             self.pp_handler_fail.get_ovs_dpdk_cpus(self.fail_profile)
 110
 111     def test_tuning(self):
 112         tuning_data = self.pp_handler.get_tuning(self.profile)
 113         expected_data = 'low_latency'
 114         self.assertEqual(tuning_data, expected_data)
 115
 116     def test_tuning_does_not_raises_error(self):
 117         self.assertEqual(self.pp_handler_fail.get_tuning(self.fail_profile), None)
 118
 119     def test_low_latency_kcmd_options(self):
 120         expected_data = ["fancytuning", "thiswillmakeitfast"]
 121         self.pp_handler.set_low_latency_kcmd_options(self.profile, expected_data)
 122         low_latency_kcmd_data = self.pp_handler.get_low_latency_kcmd_options(self.profile)
 123         print self
 124         self.assertEqual(low_latency_kcmd_data, expected_data)
 125
 126     def test_missing_low_latency_kcmd_options(self):
 127         expected_data = None
 128         low_latency_kcmd_data = self.pp_handler.get_low_latency_kcmd_options(self.profile)
 129         self.assertEqual(low_latency_kcmd_data, expected_data)
 130
 131     def test_invalid_low_latency_kcmd_options(self):
 132         error_text = "Profile {} got invalid option low_latency_options".format(
 133             self.profile)
 134         with self.assertRaisesRegexp(ConfigError, error_text):
 135             low_latency_kcmd_data = "this fancytuning is sadly invalid"
 136             self.pp_handler.set_low_latency_kcmd_options(self.profile, low_latency_kcmd_data)
 137
 138     def test__fill_option_value(self):
 139         data = {}
 140         self.pp_handler._fill_option_value(data, self.profile, 'platform_cpus', None)
 141         self.assertEqual(data, {'platform_cpus': {'numa0': 1, 'numa1': 1}})
 142         self.pp_handler._fill_option_value(data, self.profile, 'platform_cpus', {'numa0': 5})
 143         self.assertEqual(data, {'platform_cpus': {'numa0': 5}})
 144
 145     def test_update(self):
 146         cman = configmanager.ConfigManager({'cloud.performance_profiles': {}, 'cloud.hosts': self.hosts_data})
 147         h = cman.get_performance_profiles_config_handler()
 148         profile = 'niksnaks'
 149         platform_cpus = {'numa0': 1, 'numa1': 1}
 150         ovs_dpdk_cpus = {'numa0': 2, 'numa1': 2}
 151         hugepages = 8
 152         h.update(profile, platform_cpus, ovs_dpdk_cpus, hugepages)
 153         self.assertEqual(h.get_performance_profiles(), [profile])
 154         self.assertEqual(h.get_platform_cpus(profile), platform_cpus)
 155         self.assertEqual(h.get_ovs_dpdk_cpus(profile), ovs_dpdk_cpus)
 156         self.assertEqual(h.get_profile_hugepage_count(profile), hugepages)
 157         with self.assertRaisesRegexp(ConfigError, 'Profile niksnaks does not have hugepagesz'):
 158             h.get_profile_hugepage_size(profile)
 159         with self.assertRaisesRegexp(ConfigError, 'Profile niksnaks does not have default_hugepagesz'):
 160             h.get_profile_default_hugepage_size(profile)
 161         self.assertEqual(h.get_tuning(profile), None)
 162
 163     def test_delete(self):
 164         cman = configmanager.ConfigManager({'cloud.performance_profiles': {}, 'cloud.hosts': self.hosts_data})
 165         h = cman.get_performance_profiles_config_handler()
 166         profile = 'nice_profile'
 167         h.update(profile, '1-8', '4', 2)
 168         h.delete(profile)
 169         error_text = 'Invalid profile name {}'.format(profile)
 170         self.assertEqual(h.get_performance_profiles(), [])
 171         with self.assertRaisesRegexp(ConfigError, error_text):
 172             h.delete(profile)
 173
 174     def test_dump(self):
 175         data = self.pp_handler.dump()
 176         self.assertEqual(data, self.profile_data)
 177
 178
 179 if __name__ == '__main__':
 180     unittest.main()