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/global_metrics_logger_and_exporter.h"
11
12 #include <map>
13 #include <memory>
14 #include <string>
15 #include <utility>
16 #include <vector>
17
18 #include "absl/types/optional.h"
19 #include "api/test/metrics/metric.h"
20 #include "api/test/metrics/metrics_exporter.h"
21 #include "api/test/metrics/metrics_logger.h"
22 #include "system_wrappers/include/clock.h"
23 #include "test/gmock.h"
24 #include "test/gtest.h"
25
26 namespace webrtc {
27 namespace test {
28 namespace {
29
30 using ::testing::Eq;
31 using ::testing::IsEmpty;
32
DefaultMetadata()33 std::map<std::string, std::string> DefaultMetadata() {
34 return std::map<std::string, std::string>{{"key", "value"}};
35 }
36
37 struct TestMetricsExporterFactory {
38 public:
CreateExporterwebrtc::test::__anon5b8d9ede0111::TestMetricsExporterFactory39 std::unique_ptr<MetricsExporter> CreateExporter() {
40 return std::make_unique<TestMetricsExporter>(this, /*export_result=*/true);
41 }
42
CreateFailureExporterwebrtc::test::__anon5b8d9ede0111::TestMetricsExporterFactory43 std::unique_ptr<MetricsExporter> CreateFailureExporter() {
44 return std::make_unique<TestMetricsExporter>(this, /*export_result=*/false);
45 }
46
47 std::vector<Metric> exported_metrics;
48
49 private:
50 class TestMetricsExporter : public MetricsExporter {
51 public:
TestMetricsExporter(TestMetricsExporterFactory * factory,bool export_result)52 TestMetricsExporter(TestMetricsExporterFactory* factory, bool export_result)
53 : factory_(factory), export_result_(export_result) {}
54 ~TestMetricsExporter() override = default;
55
Export(rtc::ArrayView<const Metric> metrics)56 bool Export(rtc::ArrayView<const Metric> metrics) override {
57 factory_->exported_metrics =
58 std::vector<Metric>(metrics.begin(), metrics.end());
59 return export_result_;
60 }
61
62 TestMetricsExporterFactory* factory_;
63 bool export_result_;
64 };
65 };
66
TEST(ExportPerfMetricTest,CollectedMetricsAreExporter)67 TEST(ExportPerfMetricTest, CollectedMetricsAreExporter) {
68 TestMetricsExporterFactory exporter_factory;
69
70 DefaultMetricsLogger logger(Clock::GetRealTimeClock());
71 logger.LogSingleValueMetric(
72 "metric_name", "test_case_name",
73 /*value=*/10, Unit::kMilliseconds, ImprovementDirection::kBiggerIsBetter,
74 std::map<std::string, std::string>{{"key", "value"}});
75
76 std::vector<std::unique_ptr<MetricsExporter>> exporters;
77 exporters.push_back(exporter_factory.CreateExporter());
78 ASSERT_TRUE(ExportPerfMetric(logger, std::move(exporters)));
79
80 std::vector<Metric> metrics = exporter_factory.exported_metrics;
81 ASSERT_THAT(metrics.size(), Eq(1lu));
82 const Metric& metric = metrics[0];
83 EXPECT_THAT(metric.name, Eq("metric_name"));
84 EXPECT_THAT(metric.test_case, Eq("test_case_name"));
85 EXPECT_THAT(metric.unit, Eq(Unit::kMilliseconds));
86 EXPECT_THAT(metric.improvement_direction,
87 Eq(ImprovementDirection::kBiggerIsBetter));
88 EXPECT_THAT(metric.metric_metadata,
89 Eq(std::map<std::string, std::string>{{"key", "value"}}));
90 ASSERT_THAT(metric.time_series.samples.size(), Eq(1lu));
91 EXPECT_THAT(metric.time_series.samples[0].value, Eq(10.0));
92 EXPECT_THAT(metric.time_series.samples[0].sample_metadata,
93 Eq(std::map<std::string, std::string>{}));
94 ASSERT_THAT(metric.stats.mean, absl::optional<double>(10.0));
95 ASSERT_THAT(metric.stats.stddev, absl::nullopt);
96 ASSERT_THAT(metric.stats.min, absl::optional<double>(10.0));
97 ASSERT_THAT(metric.stats.max, absl::optional<double>(10.0));
98 }
99
TEST(ExportPerfMetricTest,OneFailedExporterDoesNotPreventExportToOthers)100 TEST(ExportPerfMetricTest, OneFailedExporterDoesNotPreventExportToOthers) {
101 TestMetricsExporterFactory exporter_factory1;
102 TestMetricsExporterFactory exporter_factory2;
103 TestMetricsExporterFactory exporter_factory3;
104
105 DefaultMetricsLogger logger(Clock::GetRealTimeClock());
106 logger.LogSingleValueMetric("metric_name", "test_case_name",
107 /*value=*/10, Unit::kMilliseconds,
108 ImprovementDirection::kBiggerIsBetter,
109 DefaultMetadata());
110
111 std::vector<std::unique_ptr<MetricsExporter>> exporters;
112 exporters.push_back(exporter_factory1.CreateExporter());
113 exporters.push_back(exporter_factory2.CreateFailureExporter());
114 exporters.push_back(exporter_factory3.CreateExporter());
115 ASSERT_FALSE(ExportPerfMetric(logger, std::move(exporters)));
116
117 std::vector<Metric> metrics1 = exporter_factory1.exported_metrics;
118 std::vector<Metric> metrics2 = exporter_factory2.exported_metrics;
119 std::vector<Metric> metrics3 = exporter_factory3.exported_metrics;
120 ASSERT_THAT(metrics1.size(), Eq(1lu))
121 << metrics1[0].name << "; " << metrics1[1].name;
122 EXPECT_THAT(metrics1[0].name, Eq("metric_name"));
123 ASSERT_THAT(metrics2.size(), Eq(1lu));
124 EXPECT_THAT(metrics2[0].name, Eq("metric_name"));
125 ASSERT_THAT(metrics3.size(), Eq(1lu));
126 EXPECT_THAT(metrics3[0].name, Eq("metric_name"));
127 }
128
129 } // namespace
130 } // namespace test
131 } // namespace webrtc
132