def test_series_list_to_result_pbs_megahertz_default(self):
result = ClusterResult(self.scenario, "fake_result",
"CpuUsage.Avg.Megahertz")
timestamps, series_list = self.__fake_timestamps_and_series_list()
result_pbs = result.series_list_to_result_pbs(series_list)
self.assertEqual(len(result_pbs), 4)
for node_index, result_pb in enumerate(result_pbs):
self.assertEqual(type(result_pb), CurieTestResult)
self.assertEqual(result_pb.data_2d.x_unit_type,
CurieTestResult.Data2D.kUnixTimestamp)
self.assertEqual(result_pb.data_2d.y_unit_type,
CurieTestResult.Data2D.kHertz)
self.assertIn("(Node %d)" % node_index, result_pb.name)
def test_series_list_to_result_pbs_bandwidth_default(self):
result = ClusterResult(self.scenario, "fake_result",
"NetReceived.Avg.KilobytesPerSecond")
timestamps, series_list = self.__fake_timestamps_and_series_list()
result_pbs = result.series_list_to_result_pbs(series_list)
self.assertEqual(len(result_pbs), 4)
for node_index, result_pb in enumerate(result_pbs):
self.assertEqual(type(result_pb), CurieTestResult)
self.assertEqual(result_pb.data_2d.x_unit_type,
CurieTestResult.Data2D.kUnixTimestamp)
self.assertEqual(result_pb.data_2d.y_unit_type,
CurieTestResult.Data2D.kBytesPerSecond)
self.assertIn("(Node %d)" % node_index, result_pb.name)
def test_series_list_to_result_pbs_iops_bandwidth_aggregate(self):
result = ClusterResult(self.scenario,
"fake_result",
"NetReceived.Avg.KilobytesPerSecond",
aggregate="sum")
timestamps, series_list = self.__fake_timestamps_and_series_list()
result_pbs = result.series_list_to_result_pbs(series_list)
self.assertEqual(len(result_pbs), 1)
for result_pb in result_pbs:
self.assertEqual(type(result_pb), CurieTestResult)
self.assertEqual(result_pb.data_2d.x_unit_type,
CurieTestResult.Data2D.kUnixTimestamp)
self.assertEqual(result_pb.data_2d.y_unit_type,
CurieTestResult.Data2D.kBytesPerSecond)
self.assertNotIn("(Node", result_pb.name)
def test_parse_experimental_metric(self, mock_metrics):
mock_metrics.return_value = [
CurieMetric(name=CurieMetric.kCpuUsage,
description="This is a fake experimental metric",
instance="Aggregated",
type=CurieMetric.kGauge,
consolidation=CurieMetric.kAvg,
unit=CurieMetric.kMegahertz,
experimental=True)
]
result = ClusterResult.parse(self.scenario, "Experimental Metric", {
"metric": "CpuUsage.Avg.Megahertz",
"aggregate": "sum"
})
self.assertIsNone(result)
self.scenario.enable_experimental_metrics = True
result = ClusterResult.parse(self.scenario, "Experimental Metric", {
"metric": "CpuUsage.Avg.Megahertz",
"aggregate": "sum"
})
self.assertIsInstance(result, ClusterResult)
self.assertEqual(result.metric_name, "CpuUsage.Avg.Megahertz")
def test_pickle_unpickle(self):
result = ClusterResult(self.scenario, "fake_result",
"NetReceived.Avg.KilobytesPerSecond")
result.metric.description = "Why would one modify the description anyway?"
unpickled_result = pickle.loads(pickle.dumps(result))
self.assertEqual(result.scenario, unpickled_result.scenario)
self.assertEqual(result.name, unpickled_result.name)
self.assertEqual(result.aggregate, unpickled_result.aggregate)
self.assertEqual(result.report_metrics,
unpickled_result.report_metrics)
self.assertEqual(result.report_group, unpickled_result.report_group)
self.assertEqual(result.metric_name, unpickled_result.metric_name)
self.assertEqual(result.metric, unpickled_result.metric)
self.assertEqual(result.kwargs, unpickled_result.kwargs)
def test_get_result_pbs_partial(self):
result = ClusterResult(self.scenario, "fake_result",
"NetReceived.Avg.KilobytesPerSecond")
metric = CurieMetric(
name=CurieMetric.kNetReceived,
description="Average network data received across all "
"interfaces.",
instance="Aggregated",
type=CurieMetric.kGauge,
consolidation=CurieMetric.kAvg,
unit=CurieMetric.kKilobytes,
rate=CurieMetric.kPerSecond,
experimental=True)
ScenarioUtil.append_cluster_stats(
{
"169.254.0.0": [metric],
"169.254.0.1": [metric],
"169.254.0.2": [],
"169.254.0.3": [],
}, self.scenario.cluster_stats_dir())
pbs = result.get_result_pbs()
self.assertEqual(2, len(pbs))
self.assertIsInstance(pbs[0], CurieTestResult)
self.assertIsInstance(pbs[1], CurieTestResult)
def test_scenario_results_update_no_netstats_ahv(self, mock_w_and_r,
mock_stc, mock_log):
result = ClusterResult.parse(
self.scenario, "Cluster Network Bandwidth", {
"metric": "NetReceived.Avg.KilobytesPerSecond",
"aggregate": "sum"
})
result.get_result_pbs = mock.Mock()
mock_stc.return_value = ["targets"]
self.scenario.cluster = mock.Mock(spec=AcropolisCluster)
self.scenario.phase = Phase.RUN
self.scenario.results_map = {"Cluster Network Bandwidth": result}
self.scenario._scenario_results_update("/fake/directory/targets.json")
mock_log.debug.assert_has_calls([
mock.call("Skipping result update since AHV API "
"does not return valid results for network statistics")
])
result.get_result_pbs.assert_not_called()
def test_get_metric_not_exist(self):
with self.assertRaises(CurieTestException) as ar:
ClusterResult.get_metric("not_a_real_metric")
self.assertEqual(
"'not_a_real_metric' is not supported - is not collected "
"or does not exist", str(ar.exception))
def test_get_metric_cpu_average_megahertz(self):
metric = ClusterResult.get_metric("CpuUsage.Avg.Megahertz")
self.assertEqual(CurieMetric.kCpuUsage, metric.name)
self.assertEqual(CurieMetric.kAvg, metric.consolidation)
self.assertEqual(CurieMetric.kMegahertz, metric.unit)
def test_construct_unsupported_metric(self):
with self.assertRaises(CurieTestException):
ClusterResult(self.scenario, "fake_result",
"DatastoreWrite.Avg.KilobytesPerSecond")
def test_construct_invalid_metric_name(self):
with self.assertRaises(CurieTestException):
ClusterResult(self.scenario, "fake_result", "invalid_metric_name")
def test_get_result_pbs_before_append(self):
result = ClusterResult(self.scenario, "fake_result",
"NetReceived.Avg.KilobytesPerSecond")
pbs = result.get_result_pbs()
self.assertEqual(0, len(pbs))