metrics_accumulator_test.cc (14439B)
1 /* 2 * Copyright (c) 2022 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 #include "api/test/metrics/metrics_accumulator.h" 11 12 #include <map> 13 #include <optional> 14 #include <string> 15 #include <vector> 16 17 #include "api/test/metrics/metric.h" 18 #include "api/units/timestamp.h" 19 #include "test/gmock.h" 20 #include "test/gtest.h" 21 22 namespace webrtc { 23 namespace test { 24 namespace { 25 26 using ::testing::Eq; 27 using ::testing::IsEmpty; 28 using ::testing::SizeIs; 29 30 TEST(MetricsAccumulatorTest, AddSampleToTheNewMetricWillCreateOne) { 31 MetricsAccumulator accumulator; 32 ASSERT_TRUE(accumulator.AddSample( 33 "metric_name", "test_case_name", 34 /*value=*/10, Timestamp::Seconds(1), 35 /*point_metadata=*/std::map<std::string, std::string>{{"key", "value"}})); 36 37 std::vector<Metric> metrics = accumulator.GetCollectedMetrics(); 38 ASSERT_THAT(metrics, SizeIs(1)); 39 const Metric& metric = metrics[0]; 40 EXPECT_THAT(metric.name, Eq("metric_name")); 41 EXPECT_THAT(metric.test_case, Eq("test_case_name")); 42 EXPECT_THAT(metric.unit, Eq(Unit::kUnitless)); 43 EXPECT_THAT(metric.improvement_direction, 44 Eq(ImprovementDirection::kNeitherIsBetter)); 45 EXPECT_THAT(metric.metric_metadata, IsEmpty()); 46 ASSERT_THAT(metric.time_series.samples, SizeIs(1)); 47 EXPECT_THAT(metric.time_series.samples[0].value, Eq(10.0)); 48 EXPECT_THAT(metric.time_series.samples[0].timestamp, 49 Eq(Timestamp::Seconds(1))); 50 EXPECT_THAT(metric.time_series.samples[0].sample_metadata, 51 Eq(std::map<std::string, std::string>{{"key", "value"}})); 52 ASSERT_THAT(metric.stats.mean, std::optional<double>(10.0)); 53 ASSERT_THAT(metric.stats.stddev, std::optional<double>(0.0)); 54 ASSERT_THAT(metric.stats.min, std::optional<double>(10.0)); 55 ASSERT_THAT(metric.stats.max, std::optional<double>(10.0)); 56 } 57 58 TEST(MetricsAccumulatorTest, AddSamplesToExistingMetricWontCreateNewOne) { 59 MetricsAccumulator accumulator; 60 ASSERT_TRUE(accumulator.AddSample( 61 "metric_name", "test_case_name", 62 /*value=*/10, Timestamp::Seconds(1), 63 /*point_metadata=*/ 64 std::map<std::string, std::string>{{"key1", "value1"}})); 65 ASSERT_FALSE(accumulator.AddSample( 66 "metric_name", "test_case_name", 67 /*value=*/20, Timestamp::Seconds(2), 68 /*point_metadata=*/ 69 std::map<std::string, std::string>{{"key2", "value2"}})); 70 71 std::vector<Metric> metrics = accumulator.GetCollectedMetrics(); 72 ASSERT_THAT(metrics, SizeIs(1)); 73 const Metric& metric = metrics[0]; 74 EXPECT_THAT(metric.name, Eq("metric_name")); 75 EXPECT_THAT(metric.test_case, Eq("test_case_name")); 76 EXPECT_THAT(metric.unit, Eq(Unit::kUnitless)); 77 EXPECT_THAT(metric.improvement_direction, 78 Eq(ImprovementDirection::kNeitherIsBetter)); 79 EXPECT_THAT(metric.metric_metadata, IsEmpty()); 80 ASSERT_THAT(metric.time_series.samples, SizeIs(2)); 81 EXPECT_THAT(metric.time_series.samples[0].value, Eq(10.0)); 82 EXPECT_THAT(metric.time_series.samples[0].timestamp, 83 Eq(Timestamp::Seconds(1))); 84 EXPECT_THAT(metric.time_series.samples[0].sample_metadata, 85 Eq(std::map<std::string, std::string>{{"key1", "value1"}})); 86 EXPECT_THAT(metric.time_series.samples[1].value, Eq(20.0)); 87 EXPECT_THAT(metric.time_series.samples[1].timestamp, 88 Eq(Timestamp::Seconds(2))); 89 EXPECT_THAT(metric.time_series.samples[1].sample_metadata, 90 Eq(std::map<std::string, std::string>{{"key2", "value2"}})); 91 ASSERT_THAT(metric.stats.mean, std::optional<double>(15.0)); 92 ASSERT_THAT(metric.stats.stddev, std::optional<double>(5.0)); 93 ASSERT_THAT(metric.stats.min, std::optional<double>(10.0)); 94 ASSERT_THAT(metric.stats.max, std::optional<double>(20.0)); 95 } 96 97 TEST(MetricsAccumulatorTest, AddSampleToDifferentMetricsWillCreateBoth) { 98 MetricsAccumulator accumulator; 99 ASSERT_TRUE(accumulator.AddSample( 100 "metric_name1", "test_case_name1", 101 /*value=*/10, Timestamp::Seconds(1), 102 /*point_metadata=*/ 103 std::map<std::string, std::string>{{"key1", "value1"}})); 104 ASSERT_TRUE(accumulator.AddSample( 105 "metric_name2", "test_case_name2", 106 /*value=*/20, Timestamp::Seconds(2), 107 /*point_metadata=*/ 108 std::map<std::string, std::string>{{"key2", "value2"}})); 109 110 std::vector<Metric> metrics = accumulator.GetCollectedMetrics(); 111 ASSERT_THAT(metrics, SizeIs(2)); 112 EXPECT_THAT(metrics[0].name, Eq("metric_name1")); 113 EXPECT_THAT(metrics[0].test_case, Eq("test_case_name1")); 114 EXPECT_THAT(metrics[0].unit, Eq(Unit::kUnitless)); 115 EXPECT_THAT(metrics[0].improvement_direction, 116 Eq(ImprovementDirection::kNeitherIsBetter)); 117 EXPECT_THAT(metrics[0].metric_metadata, IsEmpty()); 118 ASSERT_THAT(metrics[0].time_series.samples, SizeIs(1)); 119 EXPECT_THAT(metrics[0].time_series.samples[0].value, Eq(10.0)); 120 EXPECT_THAT(metrics[0].time_series.samples[0].timestamp, 121 Eq(Timestamp::Seconds(1))); 122 EXPECT_THAT(metrics[0].time_series.samples[0].sample_metadata, 123 Eq(std::map<std::string, std::string>{{"key1", "value1"}})); 124 ASSERT_THAT(metrics[0].stats.mean, std::optional<double>(10.0)); 125 ASSERT_THAT(metrics[0].stats.stddev, std::optional<double>(0.0)); 126 ASSERT_THAT(metrics[0].stats.min, std::optional<double>(10.0)); 127 ASSERT_THAT(metrics[0].stats.max, std::optional<double>(10.0)); 128 EXPECT_THAT(metrics[1].name, Eq("metric_name2")); 129 EXPECT_THAT(metrics[1].test_case, Eq("test_case_name2")); 130 EXPECT_THAT(metrics[1].unit, Eq(Unit::kUnitless)); 131 EXPECT_THAT(metrics[1].improvement_direction, 132 Eq(ImprovementDirection::kNeitherIsBetter)); 133 EXPECT_THAT(metrics[1].metric_metadata, IsEmpty()); 134 ASSERT_THAT(metrics[1].time_series.samples, SizeIs(1)); 135 EXPECT_THAT(metrics[1].time_series.samples[0].value, Eq(20.0)); 136 EXPECT_THAT(metrics[1].time_series.samples[0].timestamp, 137 Eq(Timestamp::Seconds(2))); 138 EXPECT_THAT(metrics[1].time_series.samples[0].sample_metadata, 139 Eq(std::map<std::string, std::string>{{"key2", "value2"}})); 140 ASSERT_THAT(metrics[1].stats.mean, std::optional<double>(20.0)); 141 ASSERT_THAT(metrics[1].stats.stddev, std::optional<double>(0.0)); 142 ASSERT_THAT(metrics[1].stats.min, std::optional<double>(20.0)); 143 ASSERT_THAT(metrics[1].stats.max, std::optional<double>(20.0)); 144 } 145 146 TEST(MetricsAccumulatorTest, AddMetadataToTheNewMetricWillCreateOne) { 147 MetricsAccumulator accumulator; 148 ASSERT_TRUE(accumulator.AddMetricMetadata( 149 "metric_name", "test_case_name", Unit::kMilliseconds, 150 ImprovementDirection::kBiggerIsBetter, 151 /*metric_metadata=*/ 152 std::map<std::string, std::string>{{"key", "value"}})); 153 154 std::vector<Metric> metrics = accumulator.GetCollectedMetrics(); 155 ASSERT_THAT(metrics, SizeIs(1)); 156 const Metric& metric = metrics[0]; 157 EXPECT_THAT(metric.name, Eq("metric_name")); 158 EXPECT_THAT(metric.test_case, Eq("test_case_name")); 159 EXPECT_THAT(metric.unit, Eq(Unit::kMilliseconds)); 160 EXPECT_THAT(metric.improvement_direction, 161 Eq(ImprovementDirection::kBiggerIsBetter)); 162 EXPECT_THAT(metric.metric_metadata, 163 Eq(std::map<std::string, std::string>{{"key", "value"}})); 164 ASSERT_THAT(metric.time_series.samples, IsEmpty()); 165 ASSERT_THAT(metric.stats.mean, std::nullopt); 166 ASSERT_THAT(metric.stats.stddev, std::nullopt); 167 ASSERT_THAT(metric.stats.min, std::nullopt); 168 ASSERT_THAT(metric.stats.max, std::nullopt); 169 } 170 171 TEST(MetricsAccumulatorTest, 172 AddMetadataToTheExistingMetricWillOverwriteValues) { 173 MetricsAccumulator accumulator; 174 ASSERT_TRUE(accumulator.AddMetricMetadata( 175 "metric_name", "test_case_name", Unit::kMilliseconds, 176 ImprovementDirection::kBiggerIsBetter, 177 /*metric_metadata=*/ 178 std::map<std::string, std::string>{{"key1", "value1"}})); 179 180 ASSERT_FALSE(accumulator.AddMetricMetadata( 181 "metric_name", "test_case_name", Unit::kBytes, 182 ImprovementDirection::kSmallerIsBetter, 183 /*metric_metadata=*/ 184 std::map<std::string, std::string>{{"key2", "value2"}})); 185 186 std::vector<Metric> metrics = accumulator.GetCollectedMetrics(); 187 ASSERT_THAT(metrics, SizeIs(1)); 188 const Metric& metric = metrics[0]; 189 EXPECT_THAT(metric.name, Eq("metric_name")); 190 EXPECT_THAT(metric.test_case, Eq("test_case_name")); 191 EXPECT_THAT(metric.unit, Eq(Unit::kBytes)); 192 EXPECT_THAT(metric.improvement_direction, 193 Eq(ImprovementDirection::kSmallerIsBetter)); 194 EXPECT_THAT(metric.metric_metadata, 195 Eq(std::map<std::string, std::string>{{"key2", "value2"}})); 196 ASSERT_THAT(metric.time_series.samples, IsEmpty()); 197 ASSERT_THAT(metric.stats.mean, std::nullopt); 198 ASSERT_THAT(metric.stats.stddev, std::nullopt); 199 ASSERT_THAT(metric.stats.min, std::nullopt); 200 ASSERT_THAT(metric.stats.max, std::nullopt); 201 } 202 203 TEST(MetricsAccumulatorTest, AddMetadataToDifferentMetricsWillCreateBoth) { 204 MetricsAccumulator accumulator; 205 ASSERT_TRUE(accumulator.AddMetricMetadata( 206 "metric_name1", "test_case_name1", Unit::kMilliseconds, 207 ImprovementDirection::kBiggerIsBetter, 208 /*metric_metadata=*/ 209 std::map<std::string, std::string>{{"key1", "value1"}})); 210 211 ASSERT_TRUE(accumulator.AddMetricMetadata( 212 "metric_name2", "test_case_name2", Unit::kBytes, 213 ImprovementDirection::kSmallerIsBetter, 214 /*metric_metadata=*/ 215 std::map<std::string, std::string>{{"key2", "value2"}})); 216 217 std::vector<Metric> metrics = accumulator.GetCollectedMetrics(); 218 ASSERT_THAT(metrics, SizeIs(2)); 219 EXPECT_THAT(metrics[0].name, Eq("metric_name1")); 220 EXPECT_THAT(metrics[0].test_case, Eq("test_case_name1")); 221 EXPECT_THAT(metrics[0].unit, Eq(Unit::kMilliseconds)); 222 EXPECT_THAT(metrics[0].improvement_direction, 223 Eq(ImprovementDirection::kBiggerIsBetter)); 224 EXPECT_THAT(metrics[0].metric_metadata, 225 Eq(std::map<std::string, std::string>{{"key1", "value1"}})); 226 ASSERT_THAT(metrics[0].time_series.samples, IsEmpty()); 227 ASSERT_THAT(metrics[0].stats.mean, std::nullopt); 228 ASSERT_THAT(metrics[0].stats.stddev, std::nullopt); 229 ASSERT_THAT(metrics[0].stats.min, std::nullopt); 230 ASSERT_THAT(metrics[0].stats.max, std::nullopt); 231 EXPECT_THAT(metrics[1].name, Eq("metric_name2")); 232 EXPECT_THAT(metrics[1].test_case, Eq("test_case_name2")); 233 EXPECT_THAT(metrics[1].unit, Eq(Unit::kBytes)); 234 EXPECT_THAT(metrics[1].improvement_direction, 235 Eq(ImprovementDirection::kSmallerIsBetter)); 236 EXPECT_THAT(metrics[1].metric_metadata, 237 Eq(std::map<std::string, std::string>{{"key2", "value2"}})); 238 ASSERT_THAT(metrics[1].time_series.samples, IsEmpty()); 239 ASSERT_THAT(metrics[1].stats.mean, std::nullopt); 240 ASSERT_THAT(metrics[1].stats.stddev, std::nullopt); 241 ASSERT_THAT(metrics[1].stats.min, std::nullopt); 242 ASSERT_THAT(metrics[1].stats.max, std::nullopt); 243 } 244 245 TEST(MetricsAccumulatorTest, AddMetadataAfterAddingSampleWontCreateNewMetric) { 246 MetricsAccumulator accumulator; 247 ASSERT_TRUE(accumulator.AddSample( 248 "metric_name", "test_case_name", 249 /*value=*/10, Timestamp::Seconds(1), 250 /*point_metadata=*/ 251 std::map<std::string, std::string>{{"key_s", "value_s"}})); 252 ASSERT_FALSE(accumulator.AddMetricMetadata( 253 "metric_name", "test_case_name", Unit::kMilliseconds, 254 ImprovementDirection::kBiggerIsBetter, 255 /*metric_metadata=*/ 256 std::map<std::string, std::string>{{"key_m", "value_m"}})); 257 258 std::vector<Metric> metrics = accumulator.GetCollectedMetrics(); 259 ASSERT_THAT(metrics, SizeIs(1)); 260 const Metric& metric = metrics[0]; 261 EXPECT_THAT(metric.name, Eq("metric_name")); 262 EXPECT_THAT(metric.test_case, Eq("test_case_name")); 263 EXPECT_THAT(metric.unit, Eq(Unit::kMilliseconds)); 264 EXPECT_THAT(metric.improvement_direction, 265 Eq(ImprovementDirection::kBiggerIsBetter)); 266 EXPECT_THAT(metric.metric_metadata, 267 Eq(std::map<std::string, std::string>{{"key_m", "value_m"}})); 268 ASSERT_THAT(metric.time_series.samples, SizeIs(1)); 269 EXPECT_THAT(metric.time_series.samples[0].value, Eq(10.0)); 270 EXPECT_THAT(metric.time_series.samples[0].timestamp, 271 Eq(Timestamp::Seconds(1))); 272 EXPECT_THAT(metric.time_series.samples[0].sample_metadata, 273 Eq(std::map<std::string, std::string>{{"key_s", "value_s"}})); 274 ASSERT_THAT(metric.stats.mean, std::optional<double>(10.0)); 275 ASSERT_THAT(metric.stats.stddev, std::optional<double>(0.0)); 276 ASSERT_THAT(metric.stats.min, std::optional<double>(10.0)); 277 ASSERT_THAT(metric.stats.max, std::optional<double>(10.0)); 278 } 279 280 TEST(MetricsAccumulatorTest, AddSampleAfterAddingMetadataWontCreateNewMetric) { 281 MetricsAccumulator accumulator; 282 ASSERT_TRUE(accumulator.AddMetricMetadata( 283 "metric_name", "test_case_name", Unit::kMilliseconds, 284 ImprovementDirection::kBiggerIsBetter, 285 /*metric_metadata=*/ 286 std::map<std::string, std::string>{{"key_m", "value_m"}})); 287 ASSERT_FALSE(accumulator.AddSample( 288 "metric_name", "test_case_name", 289 /*value=*/10, Timestamp::Seconds(1), 290 /*point_metadata=*/ 291 std::map<std::string, std::string>{{"key_s", "value_s"}})); 292 293 std::vector<Metric> metrics = accumulator.GetCollectedMetrics(); 294 ASSERT_THAT(metrics, SizeIs(1)); 295 const Metric& metric = metrics[0]; 296 EXPECT_THAT(metric.name, Eq("metric_name")); 297 EXPECT_THAT(metric.test_case, Eq("test_case_name")); 298 EXPECT_THAT(metric.unit, Eq(Unit::kMilliseconds)); 299 EXPECT_THAT(metric.improvement_direction, 300 Eq(ImprovementDirection::kBiggerIsBetter)); 301 EXPECT_THAT(metric.metric_metadata, 302 Eq(std::map<std::string, std::string>{{"key_m", "value_m"}})); 303 ASSERT_THAT(metric.time_series.samples, SizeIs(1)); 304 EXPECT_THAT(metric.time_series.samples[0].value, Eq(10.0)); 305 EXPECT_THAT(metric.time_series.samples[0].timestamp, 306 Eq(Timestamp::Seconds(1))); 307 EXPECT_THAT(metric.time_series.samples[0].sample_metadata, 308 Eq(std::map<std::string, std::string>{{"key_s", "value_s"}})); 309 ASSERT_THAT(metric.stats.mean, std::optional<double>(10.0)); 310 ASSERT_THAT(metric.stats.stddev, std::optional<double>(0.0)); 311 ASSERT_THAT(metric.stats.min, std::optional<double>(10.0)); 312 ASSERT_THAT(metric.stats.max, std::optional<double>(10.0)); 313 } 314 315 } // namespace 316 } // namespace test 317 } // namespace webrtc