def test_find_prev_sample(self, mock_ensure_ltm, mock_refresh): # Create objects to test with host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') mock_lpar_4A = mock.Mock() mock_lpar_4A.configure_mock(id=4, name='A') mock_lpar_4A.processor = mock.MagicMock( entitled_proc_cycles=500000) mock_lpar_6A = mock.Mock() mock_lpar_6A.configure_mock(id=6, name='A') mock_lpar_6B = mock.Mock() mock_lpar_6A.configure_mock(id=6, name='B') mock_phyp = mock.MagicMock(sample=mock.MagicMock(lpars=[mock_lpar_4A, mock_lpar_6A])) mock_prev_phyp = mock.MagicMock(sample=mock.MagicMock( lpars=[mock_lpar_4A, mock_lpar_6B])) # Sample 6 in the current shouldn't match the previous. It has the # same LPAR ID, but a different name. This is considered different new_elem = self._get_sample(6, mock_phyp.sample) prev = host_stats._find_prev_sample(new_elem, mock_prev_phyp.sample.lpars) self.assertIsNone(prev) # Lpar 4 should be in the old one. Match that up. new_elem = self._get_sample(4, mock_phyp.sample) prev = host_stats._find_prev_sample(new_elem, mock_prev_phyp.sample.lpars) self.assertIsNotNone(prev) self.assertEqual(500000, prev.processor.entitled_proc_cycles) # Test that we get None back if there are no previous samples prev = host_stats._find_prev_sample(new_elem, None) self.assertIsNone(prev)
def test_update_internal_metric_bad_total( self, mock_ensure_ltm, mock_refresh, mock_cpu_freq, mock_user_cycles, mock_tot_cycles, mock_fw_cycles): """Validates that if the total cycles are off, we handle.""" host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') mock_cpu_freq.return_value = 4116 mock_user_cycles.return_value = 30010090000 mock_fw_cycles.return_value = 58599310268 # Mock the total cycles to some really low number. mock_tot_cycles.return_value = 5 # Create mock phyp objects to test with mock_phyp = mock.MagicMock() mock_prev_phyp = mock.MagicMock() mock_phyp.sample.system_firmware.utilized_proc_cycles = 58599310268 # Run the actual test - 'increment' it with a new current/previous host_stats.cur_phyp = mock_phyp host_stats.prev_phyp = mock_prev_phyp host_stats._update_internal_metric() # Validate this dictionary. Note that the idle is now 0...not a # negative number. expect = {'iowait': 0, 'idle': 0, 'kernel': 58599310268, 'user': 30010090000, 'frequency': 4116} self.assertEqual(expect, host_stats.tot_data)
def test_delta_proc_cycles(self, mock_ensure_ltm, mock_refresh): # Create objects to test with host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') mock_phyp, mock_prev_phyp = self._get_mock_phyps() # Test that a previous sample allows us to gather the delta across all # of the VMs. This should take into account the scenario where a LPAR # is deleted and a new one takes its place (LPAR ID 6) delta = host_stats._delta_proc_cycles(mock_phyp.sample.lpars, mock_prev_phyp.sample.lpars) self.assertEqual(10010000000, delta) # Now test as if there is no previous data. This results in 0 as they # could have all been LPMs with months of cycles (rather than 30 # seconds delta). delta2 = host_stats._delta_proc_cycles(mock_phyp.sample.lpars, None) self.assertEqual(0, delta2) self.assertNotEqual(delta2, delta) # Test that if previous sample had 0 values, the sample is not # considered for evaluation, and resultant delta cycles is 0. prev_lpar_sample = mock_prev_phyp.sample.lpars[0].processor prev_lpar_sample.util_cap_proc_cycles = 0 prev_lpar_sample.util_uncap_proc_cycles = 0 prev_lpar_sample.donated_proc_cycles = 0 delta3 = host_stats._delta_proc_cycles(mock_phyp.sample.lpars, mock_prev_phyp.sample.lpars) self.assertEqual(0, delta3)
def test_update_internal_metric_bad_total(self, mock_ensure_ltm, mock_refresh, mock_cpu_freq, mock_tot_cycles): """Validates that if the total cycles are off, we handle.""" host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') mock_cpu_freq.return_value = 4116 # Mock the total cycles to some really low number. mock_tot_cycles.return_value = 5 # Now 'increment' it with a new current/previous host_stats.cur_phyp = self.phyp host_stats.prev_phyp = self.prev_phyp host_stats._update_internal_metric() # Validate this dictionary. Note that the idle is now 0...not a # negative number. expect = { 'iowait': 0, 'idle': 0, 'kernel': 58599310268, 'user': 30010090000, 'frequency': 4116 } self.assertEqual(expect, host_stats.cur_data)
def test_get_total_cycles(self, mock_ensure_ltm, mock_refresh): host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') host_stats.cur_phyp = self.phyp # Make sure we get the full system cycles. max_cycles = host_stats._get_total_cycles() self.assertEqual(1.6125945178663e+16, max_cycles)
def test_get_total_cycles(self, mock_ensure_ltm, mock_refresh): # Mock objects to test with host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') mock_phyp = mock.MagicMock() mock_phyp.sample = mock.MagicMock() mock_phyp.sample.processor.configurable_proc_units = 5 mock_phyp.sample.time_based_cycles = 500 host_stats.cur_phyp = mock_phyp # Make sure we get the full system cycles. max_cycles = host_stats._get_total_cycles_delta() self.assertEqual(2500, max_cycles)
def test_update_internal_metric( self, mock_ensure_ltm, mock_refresh, mock_user_cycles, mock_total_cycles, mock_cpu_freq, mock_fw_cycles): host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') mock_cpu_freq.return_value = 4116 # Make sure None is returned if there is no data. host_stats.cur_phyp = None host_stats._update_internal_metric() expect = {'iowait': 0, 'idle': 0, 'kernel': 0, 'user': 0, 'frequency': 0} self.assertEqual(expect, host_stats.tot_data) # Create mock phyp objects to test with mock_phyp = mock.MagicMock() mock_fw_cycles.return_value = 58599310268 mock_prev_phyp = mock.MagicMock() # Mock methods not currently under test mock_user_cycles.return_value = 50 mock_total_cycles.return_value = 1.6125945178663e+16 # Make the 'prev' the current...for the first pass host_stats.cur_phyp = mock_prev_phyp host_stats.prev_phyp = None host_stats._update_internal_metric() # Validate the dictionary... No user cycles because all of the # previous data is empty. expect = {'iowait': 0, 'idle': 1.6125886579352682e+16, 'kernel': 58599310268, 'user': 50, 'frequency': 4116} self.assertEqual(expect, host_stats.tot_data) # Mock methods not currently under test mock_user_cycles.return_value = 30010090000 mock_total_cycles.return_value = 1.6125945178663e+16 # Now 'increment' it with a new current/previous host_stats.cur_phyp = mock_phyp host_stats.prev_phyp = mock_prev_phyp mock_user_cycles.return_value = 100000 host_stats._update_internal_metric() # Validate this dictionary. Note that these values are 'higher' # because this is a running total. new_kern = 58599310268 * 2 expect = {'iowait': 0, 'idle': 3.2251773158605416e+16, 'kernel': new_kern, 'user': 100050, 'frequency': 4116} self.assertEqual(expect, host_stats.tot_data)
def test_delta_user_cycles(self, mock_ensure_ltm, mock_refresh): host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') # Test that a previous sample allows us to gather just the delta. new_elem = self._get_sample(4, self.phyp.sample) old_elem = self._get_sample(4, self.prev_phyp.sample) delta = host_stats._delta_user_cycles(new_elem, old_elem) self.assertEqual(45000, delta) # Validate the scenario where we don't have a previous. Should default # to 0, given no context of why the previous sample did not have the # data. delta = host_stats._delta_user_cycles(new_elem, None) self.assertEqual(0, delta)
def test_get_firmware_cycles(self, mock_ensure_ltm, mock_refresh): # Mock objects to test with host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') # Latest Sample mock_phyp = mock.MagicMock(sample=mock.MagicMock()) mock_phyp.sample.system_firmware.utilized_proc_cycles = 2000 # Previous Sample prev_phyp = mock.MagicMock(sample=mock.MagicMock()) prev_phyp.sample.system_firmware.utilized_proc_cycles = 1000 host_stats.cur_phyp = mock_phyp host_stats.prev_phyp = prev_phyp # Get delta delta_firmware_cycles = host_stats._get_fw_cycles_delta() self.assertEqual(1000, delta_firmware_cycles)
def test_get_total_cycles_diff_cores(self, mock_ensure_ltm, mock_refresh): # Mock objects to test with host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') # Latest Sample mock_phyp = mock.MagicMock(sample=mock.MagicMock()) mock_phyp.sample.processor.configurable_proc_units = 48 mock_phyp.sample.time_based_cycles = 1000 host_stats.cur_phyp = mock_phyp # Earlier sample. Use a higher proc unit sample mock_phyp = mock.MagicMock(sample=mock.MagicMock()) mock_phyp.sample.processor.configurable_proc_units = 1 mock_phyp.sample.time_based_cycles = 500 host_stats.prev_phyp = mock_phyp # Make sure we get the full system cycles. max_cycles = host_stats._get_total_cycles_delta() self.assertEqual(24000, max_cycles)
def test_find_prev_sample(self, mock_ensure_ltm, mock_refresh): host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') # Sample 6 in the current shouldn't match the previous. It has the # same LPAR ID, but a different name. This is considered different new_elem = self._get_sample(6, self.phyp.sample) prev = host_stats._find_prev_sample(new_elem, self.prev_phyp.sample.lpars) self.assertIsNone(prev) # Lpar 4 should be in the old one. Match that up. new_elem = self._get_sample(4, self.phyp.sample) prev = host_stats._find_prev_sample(new_elem, self.prev_phyp.sample.lpars) self.assertIsNotNone(prev) self.assertEqual(500000, prev.processor.entitled_proc_cycles) # Test that we get None back if there are no previous samples prev = host_stats._find_prev_sample(new_elem, None) self.assertIsNone(prev)
def test_gather_user_cycles(self, mock_ensure_ltm, mock_refresh): host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') # Test that we can run with previous samples and then without. host_stats.cur_phyp = self.phyp host_stats.prev_phyp = self.prev_phyp resp = host_stats._gather_user_cycles() self.assertEqual(30010090000, resp) # Last, test to make sure the previous data is used. host_stats.prev_data = {'user': 1000000} resp = host_stats._gather_user_cycles() self.assertEqual(30011090000, resp) # Now test if there is no previous sample. Since there are no previous # samples, it will be 0 (except it WILL default up to the previous # min cycles, which we just set to 1000000). host_stats.prev_phyp = None resp = host_stats._gather_user_cycles() self.assertEqual(1000000, resp)
def test_update_internal_metric(self, mock_ensure_ltm, mock_refresh, mock_cpu_freq): host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') mock_cpu_freq.return_value = 4116 # Make sure None is returned if there is no data. host_stats.cur_phyp = None host_stats._update_internal_metric() self.assertEqual(None, host_stats.cur_data) # Make the 'prev' the current...for the first pass host_stats.cur_phyp = self.prev_phyp host_stats.prev_phyp = None host_stats._update_internal_metric() # Validate the dictionary... No user cycles because all of the # previous data is empty. expect = { 'iowait': 0, 'idle': 1.6125886579352732e+16, 'kernel': 58599310268, 'user': 0, 'frequency': 4116 } self.assertEqual(expect, host_stats.cur_data) # Now 'increment' it with a new current/previous host_stats.cur_phyp = self.phyp host_stats.prev_phyp = self.prev_phyp host_stats._update_internal_metric() # Validate this dictionary. Note that the values are still higher # overall, even though we add the 'deltas' from each VM. expect = { 'iowait': 0, 'idle': 1.6125856569262732e+16, 'kernel': 58599310268, 'user': 30010090000, 'frequency': 4116 } self.assertEqual(expect, host_stats.cur_data)
def test_delta_proc_cycles(self, mock_ensure_ltm, mock_refresh): host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') # Test that a previous sample allows us to gather the delta across all # of the VMs. This should take into account the scenario where a LPAR # is deleted and a new one takes its place (LPAR ID 6) delta = host_stats._delta_proc_cycles(self.phyp.sample.lpars, self.prev_phyp.sample.lpars) self.assertEqual(10010090000, delta) # Now test as if there is no previous data. This results in 0 as they # could have all been LPMs with months of cycles (rather than 30 # seconds delta). delta2 = host_stats._delta_proc_cycles(self.phyp.sample.lpars, None) self.assertEqual(0, delta2) self.assertNotEqual(delta2, delta) # Test that we can do this with the VIOSes as well. delta = host_stats._delta_proc_cycles(self.phyp.sample.vioses, self.prev_phyp.sample.vioses) self.assertEqual(20000000000, delta)
def test_gather_user_cycles_delta(self, mock_ensure_ltm, mock_refresh, mock_cycles): # Crete objects to test with host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') mock_phyp = mock.MagicMock() mock_prev_phyp = mock.MagicMock() # Mock methods not currently under test mock_cycles.return_value = 15005045000 # Test that we can run with previous samples and then without. host_stats.cur_phyp = mock_phyp host_stats.prev_phyp = mock_prev_phyp resp = host_stats._gather_user_cycles_delta() self.assertEqual(30010090000, resp) # Now test if there is no previous sample. Since there are no previous # samples, it will be 0. host_stats.prev_phyp = None mock_cycles.return_value = 0 resp = host_stats._gather_user_cycles_delta() self.assertEqual(0, resp)
def test_delta_user_cycles(self, mock_ensure_ltm, mock_refresh): # Create objects to test with host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') mock_phyp, mock_prev_phyp = self._get_mock_phyps() mock_phyp.sample.lpars[0].processor.util_cap_proc_cycles = 250000 mock_phyp.sample.lpars[0].processor.util_uncap_proc_cycles = 250000 mock_phyp.sample.lpars[0].processor.donated_proc_cycles = 500 mock_prev_phyp.sample.lpars[0].processor.util_cap_proc_cycles = 0 num = 455000 mock_prev_phyp.sample.lpars[0].processor.util_uncap_proc_cycles = num mock_prev_phyp.sample.lpars[0].processor.donated_proc_cycles = 1000 # Test that a previous sample allows us to gather just the delta. new_elem = self._get_sample(4, mock_phyp.sample) old_elem = self._get_sample(4, mock_prev_phyp.sample) delta = host_stats._delta_user_cycles(new_elem, old_elem) self.assertEqual(45500, delta) # Validate the scenario where we don't have a previous. Should default # to 0, given no context of why the previous sample did not have the # data. delta = host_stats._delta_user_cycles(new_elem, None) self.assertEqual(0, delta)
def test_get_cpu_freq(self, mock_ensure_ltm, mock_refresh, mock_cmd): host_stats = pvm_host.HostCPUStats(self.adpt, 'host_uuid') mock_cmd.return_value = '4116.000000MHz\n' self.assertEqual(4116, host_stats._get_cpu_freq()) self.assertEqual(int, type(host_stats._get_cpu_freq()))