metric_data_collector_unittest.cc 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/reporting/metrics/metric_data_collector.h"
  5. #include <memory>
  6. #include <string>
  7. #include <vector>
  8. #include "base/location.h"
  9. #include "base/run_loop.h"
  10. #include "base/test/bind.h"
  11. #include "base/test/task_environment.h"
  12. #include "base/time/time.h"
  13. #include "components/reporting/metrics/fake_metric_report_queue.h"
  14. #include "components/reporting/metrics/fake_reporting_settings.h"
  15. #include "components/reporting/metrics/fake_sampler.h"
  16. #include "components/reporting/metrics/metric_report_queue.h"
  17. #include "components/reporting/proto/synced/metric_data.pb.h"
  18. #include "testing/gmock/include/gmock/gmock.h"
  19. #include "testing/gtest/include/gtest/gtest.h"
  20. #include "third_party/abseil-cpp/absl/types/optional.h"
  21. namespace reporting {
  22. namespace test {
  23. class FakeEventDetector : public EventDetector {
  24. public:
  25. FakeEventDetector() = default;
  26. FakeEventDetector(const FakeEventDetector& other) = delete;
  27. FakeEventDetector& operator=(const FakeEventDetector& other) = delete;
  28. ~FakeEventDetector() override = default;
  29. absl::optional<MetricEventType> DetectEvent(
  30. const MetricData& previous_metric_data,
  31. const MetricData& current_metric_data) override {
  32. previous_metric_list_.emplace_back(
  33. std::make_unique<const MetricData>(previous_metric_data));
  34. if (!has_event_) {
  35. return absl::nullopt;
  36. }
  37. return MetricEventType::NETWORK_HTTPS_LATENCY_CHANGE;
  38. }
  39. void SetHasEvent(bool has_event) { has_event_ = has_event; }
  40. const std::vector<std::unique_ptr<const MetricData>>& GetPreviousMetricList()
  41. const {
  42. return previous_metric_list_;
  43. }
  44. private:
  45. bool has_event_ = false;
  46. std::vector<std::unique_ptr<const MetricData>> previous_metric_list_;
  47. };
  48. } // namespace test
  49. namespace {
  50. class MetricDataCollectorTest : public ::testing::Test {
  51. protected:
  52. void SetUp() override {
  53. settings_ = std::make_unique<test::FakeReportingSettings>();
  54. sampler_ = std::make_unique<test::FakeSampler>();
  55. metric_report_queue_ = std::make_unique<test::FakeMetricReportQueue>();
  56. }
  57. void FlushTasks() {
  58. base::RunLoop run_loop;
  59. task_environment_.GetMainThreadTaskRunner()->PostTask(
  60. FROM_HERE, run_loop.QuitClosure());
  61. run_loop.Run();
  62. }
  63. base::test::SingleThreadTaskEnvironment task_environment_{
  64. base::test::TaskEnvironment::TimeSource::MOCK_TIME};
  65. const std::string kEnableSettingPath = "enable_path";
  66. const std::string kRateSettingPath = "rate_path";
  67. std::unique_ptr<test::FakeReportingSettings> settings_;
  68. std::unique_ptr<test::FakeSampler> sampler_;
  69. std::unique_ptr<test::FakeMetricReportQueue> metric_report_queue_;
  70. };
  71. TEST_F(MetricDataCollectorTest, OneShotCollector_InitiallyEnabled) {
  72. settings_->SetBoolean(kEnableSettingPath, true);
  73. MetricData metric_data;
  74. metric_data.mutable_info_data();
  75. sampler_->SetMetricData(std::move(metric_data));
  76. bool callback_called = false;
  77. OneShotCollector collector(sampler_.get(), metric_report_queue_.get(),
  78. settings_.get(), kEnableSettingPath,
  79. /*setting_enabled_default_value=*/false,
  80. base::BindLambdaForTesting([&callback_called]() {
  81. callback_called = true;
  82. }));
  83. // Setting is initially enabled, data is being collected.
  84. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  85. settings_->SetBoolean(kEnableSettingPath, false);
  86. settings_->SetBoolean(kEnableSettingPath, true);
  87. // No more data should be collected even if the setting was disabled then
  88. // re-enabled.
  89. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  90. FlushTasks();
  91. const auto& metric_data_reported =
  92. metric_report_queue_->GetMetricDataReported();
  93. ASSERT_THAT(metric_data_reported, ::testing::SizeIs(1));
  94. EXPECT_TRUE(callback_called);
  95. EXPECT_TRUE(metric_data_reported[0]->has_timestamp_ms());
  96. EXPECT_TRUE(metric_data_reported[0]->has_info_data());
  97. }
  98. TEST_F(MetricDataCollectorTest, OneShotCollector_NoMetricData) {
  99. settings_->SetBoolean(kEnableSettingPath, true);
  100. sampler_->SetMetricData(absl::nullopt);
  101. bool callback_called = false;
  102. OneShotCollector collector(sampler_.get(), metric_report_queue_.get(),
  103. settings_.get(), kEnableSettingPath,
  104. /*setting_enabled_default_value=*/false,
  105. base::BindLambdaForTesting([&callback_called]() {
  106. callback_called = true;
  107. }));
  108. // Setting is initially enabled, data is being collected.
  109. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  110. FlushTasks();
  111. const auto& metric_data_reported =
  112. metric_report_queue_->GetMetricDataReported();
  113. ASSERT_TRUE(metric_data_reported.empty());
  114. EXPECT_FALSE(callback_called);
  115. }
  116. TEST_F(MetricDataCollectorTest, OneShotCollector_InitiallyDisabled) {
  117. settings_->SetBoolean(kEnableSettingPath, false);
  118. MetricData metric_data;
  119. metric_data.mutable_info_data();
  120. sampler_->SetMetricData(std::move(metric_data));
  121. OneShotCollector collector(sampler_.get(), metric_report_queue_.get(),
  122. settings_.get(), kEnableSettingPath,
  123. /*setting_enabled_default_value=*/false);
  124. // Setting is initially disabled, no data is collected.
  125. EXPECT_EQ(sampler_->GetNumCollectCalls(), 0);
  126. settings_->SetBoolean(kEnableSettingPath, true);
  127. // Setting is enabled, data is being collected.
  128. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  129. settings_->SetBoolean(kEnableSettingPath, false);
  130. settings_->SetBoolean(kEnableSettingPath, true);
  131. // No more data should be collected even if the setting was disabled then
  132. // re-enabled.
  133. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  134. FlushTasks();
  135. const auto& metric_data_reported =
  136. metric_report_queue_->GetMetricDataReported();
  137. ASSERT_THAT(metric_data_reported, ::testing::SizeIs(1));
  138. EXPECT_TRUE(metric_data_reported[0]->has_timestamp_ms());
  139. EXPECT_TRUE(metric_data_reported[0]->has_info_data());
  140. }
  141. TEST_F(MetricDataCollectorTest, OneShotCollector_DefaultEnabled) {
  142. MetricData metric_data;
  143. metric_data.mutable_info_data();
  144. sampler_->SetMetricData(std::move(metric_data));
  145. bool callback_called = false;
  146. OneShotCollector collector(sampler_.get(), metric_report_queue_.get(),
  147. settings_.get(), "invalid/path",
  148. /*setting_enabled_default_value=*/true,
  149. base::BindLambdaForTesting([&callback_called]() {
  150. callback_called = true;
  151. }));
  152. // Setting is enabled by default, data is being collected.
  153. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  154. FlushTasks();
  155. const auto& metric_data_reported =
  156. metric_report_queue_->GetMetricDataReported();
  157. ASSERT_THAT(metric_data_reported, ::testing::SizeIs(1));
  158. EXPECT_TRUE(callback_called);
  159. EXPECT_TRUE(metric_data_reported[0]->has_timestamp_ms());
  160. EXPECT_TRUE(metric_data_reported[0]->has_info_data());
  161. }
  162. TEST_F(MetricDataCollectorTest, OneShotCollector_DefaultDisabled) {
  163. MetricData metric_data;
  164. metric_data.mutable_info_data();
  165. sampler_->SetMetricData(std::move(metric_data));
  166. OneShotCollector collector(sampler_.get(), metric_report_queue_.get(),
  167. settings_.get(), kEnableSettingPath,
  168. /*setting_enabled_default_value=*/false);
  169. FlushTasks();
  170. // Setting is disabled by default, no data is collected.
  171. EXPECT_EQ(sampler_->GetNumCollectCalls(), 0);
  172. EXPECT_TRUE(metric_report_queue_->GetMetricDataReported().empty());
  173. }
  174. TEST_F(MetricDataCollectorTest, PeriodicCollector_InitiallyEnabled) {
  175. constexpr int interval = 10000;
  176. settings_->SetBoolean(kEnableSettingPath, true);
  177. settings_->SetInteger(kRateSettingPath, interval);
  178. MetricData metric_data[5];
  179. metric_data[0].mutable_telemetry_data();
  180. metric_data[1].mutable_info_data();
  181. metric_data[2].mutable_event_data();
  182. metric_data[3].mutable_telemetry_data();
  183. metric_data[3].mutable_event_data();
  184. metric_data[4].mutable_info_data();
  185. metric_data[4].mutable_event_data();
  186. sampler_->SetMetricData(metric_data[0]);
  187. PeriodicCollector collector(
  188. sampler_.get(), metric_report_queue_.get(), settings_.get(),
  189. kEnableSettingPath, /*setting_enabled_default_value=*/false,
  190. kRateSettingPath, base::Milliseconds(interval / 2));
  191. // One initial collection at startup.
  192. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  193. FlushTasks();
  194. // Expected calls count initialized to 1 to reflect the initial collection.
  195. int expected_collect_calls = 1;
  196. for (int i = 0; i < 2; ++i) {
  197. sampler_->SetMetricData(metric_data[i + 1]);
  198. // 5 secs elapsed, no new data collected.
  199. task_environment_.FastForwardBy(base::Milliseconds(interval / 2));
  200. EXPECT_EQ(sampler_->GetNumCollectCalls(), expected_collect_calls);
  201. ++expected_collect_calls;
  202. // 10 secs elapsed, data should be collected.
  203. task_environment_.FastForwardBy(base::Milliseconds(interval / 2));
  204. EXPECT_EQ(sampler_->GetNumCollectCalls(), expected_collect_calls);
  205. FlushTasks();
  206. }
  207. sampler_->SetMetricData(metric_data[3]);
  208. settings_->SetBoolean(kEnableSettingPath, false);
  209. // Setting disabled, no data should be collected.
  210. task_environment_.FastForwardBy(base::Milliseconds(interval));
  211. EXPECT_EQ(sampler_->GetNumCollectCalls(), expected_collect_calls);
  212. FlushTasks();
  213. settings_->SetBoolean(kEnableSettingPath, true);
  214. // Initial collection at policy enablement.
  215. ++expected_collect_calls;
  216. EXPECT_EQ(sampler_->GetNumCollectCalls(), expected_collect_calls);
  217. FlushTasks();
  218. sampler_->SetMetricData(metric_data[4]);
  219. // Setting enabled, data should be collected after interval.
  220. task_environment_.FastForwardBy(base::Milliseconds(interval / 2));
  221. EXPECT_EQ(sampler_->GetNumCollectCalls(), expected_collect_calls);
  222. ++expected_collect_calls;
  223. task_environment_.FastForwardBy(base::Milliseconds(interval / 2));
  224. EXPECT_EQ(sampler_->GetNumCollectCalls(), expected_collect_calls);
  225. FlushTasks();
  226. const auto& metric_data_reported =
  227. metric_report_queue_->GetMetricDataReported();
  228. ASSERT_THAT(metric_data_reported, ::testing::SizeIs(5));
  229. for (int i = 0; i < 5; ++i) {
  230. EXPECT_TRUE(metric_data_reported[i]->has_timestamp_ms());
  231. EXPECT_EQ(metric_data_reported[i]->has_telemetry_data(),
  232. metric_data[i].has_telemetry_data());
  233. EXPECT_EQ(metric_data_reported[i]->has_info_data(),
  234. metric_data[i].has_info_data());
  235. EXPECT_EQ(metric_data_reported[i]->has_event_data(),
  236. metric_data[i].has_event_data());
  237. }
  238. }
  239. TEST_F(MetricDataCollectorTest, PeriodicCollector_NoMetricData) {
  240. constexpr int interval = 10000;
  241. settings_->SetBoolean(kEnableSettingPath, true);
  242. settings_->SetInteger(kRateSettingPath, interval);
  243. sampler_->SetMetricData(absl::nullopt);
  244. PeriodicCollector collector(
  245. sampler_.get(), metric_report_queue_.get(), settings_.get(),
  246. kEnableSettingPath, /*setting_enabled_default_value=*/false,
  247. kRateSettingPath, base::Milliseconds(interval / 2));
  248. // One initial collection at startup.
  249. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  250. FlushTasks();
  251. const auto& metric_data_reported =
  252. metric_report_queue_->GetMetricDataReported();
  253. ASSERT_TRUE(metric_data_reported.empty());
  254. }
  255. TEST_F(MetricDataCollectorTest, PeriodicCollector_InitiallyDisabled) {
  256. constexpr int interval = 10000;
  257. settings_->SetBoolean(kEnableSettingPath, false);
  258. settings_->SetInteger(kRateSettingPath, interval);
  259. MetricData metric_data;
  260. metric_data.mutable_telemetry_data();
  261. sampler_->SetMetricData(std::move(metric_data));
  262. PeriodicCollector collector(
  263. sampler_.get(), metric_report_queue_.get(), settings_.get(),
  264. kEnableSettingPath, /*setting_enabled_default_value=*/false,
  265. kRateSettingPath, base::Milliseconds(interval / 2));
  266. task_environment_.FastForwardBy(base::Milliseconds(interval));
  267. // Setting is disabled, no data collected.
  268. EXPECT_EQ(sampler_->GetNumCollectCalls(), 0);
  269. settings_->SetBoolean(kEnableSettingPath, true);
  270. // One initial collection at policy enablement.
  271. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  272. FlushTasks();
  273. task_environment_.FastForwardBy(base::Milliseconds(interval));
  274. // 1 collection at policy enablement + 1 collection after interval.
  275. EXPECT_EQ(sampler_->GetNumCollectCalls(), 2);
  276. FlushTasks();
  277. const auto& metric_data_reported =
  278. metric_report_queue_->GetMetricDataReported();
  279. ASSERT_THAT(metric_data_reported, ::testing::SizeIs(2));
  280. EXPECT_TRUE(metric_data_reported[0]->has_timestamp_ms());
  281. EXPECT_TRUE(metric_data_reported[0]->has_telemetry_data());
  282. EXPECT_TRUE(metric_data_reported[1]->has_timestamp_ms());
  283. EXPECT_TRUE(metric_data_reported[1]->has_telemetry_data());
  284. }
  285. TEST_F(MetricDataCollectorTest, PeriodicCollector_DefaultEnabled) {
  286. constexpr int interval = 10000;
  287. settings_->SetInteger(kRateSettingPath, interval);
  288. MetricData metric_data;
  289. metric_data.mutable_telemetry_data();
  290. sampler_->SetMetricData(std::move(metric_data));
  291. PeriodicCollector collector(
  292. sampler_.get(), metric_report_queue_.get(), settings_.get(),
  293. "invalid/path", /*setting_enabled_default_value=*/true, kRateSettingPath,
  294. base::Milliseconds(interval / 2));
  295. // One initial collection at startup.
  296. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  297. FlushTasks();
  298. metric_data.Clear();
  299. metric_data.mutable_event_data();
  300. sampler_->SetMetricData(std::move(metric_data));
  301. // 10 secs elapsed, data should be collected.
  302. task_environment_.FastForwardBy(base::Milliseconds(interval));
  303. // 1 collection at startup + 1 collection after interval.
  304. EXPECT_EQ(sampler_->GetNumCollectCalls(), 2);
  305. FlushTasks();
  306. const auto& metric_data_reported =
  307. metric_report_queue_->GetMetricDataReported();
  308. ASSERT_THAT(metric_data_reported, ::testing::SizeIs(2));
  309. EXPECT_TRUE(metric_data_reported[0]->has_timestamp_ms());
  310. EXPECT_TRUE(metric_data_reported[0]->has_telemetry_data());
  311. EXPECT_TRUE(metric_data_reported[1]->has_timestamp_ms());
  312. EXPECT_FALSE(metric_data_reported[1]->has_telemetry_data());
  313. EXPECT_TRUE(metric_data_reported[1]->has_event_data());
  314. }
  315. TEST_F(MetricDataCollectorTest, PeriodicCollector_DefaultDisabled) {
  316. constexpr int interval = 10000;
  317. settings_->SetInteger(kRateSettingPath, interval);
  318. MetricData metric_data;
  319. metric_data.mutable_telemetry_data();
  320. PeriodicCollector collector(
  321. sampler_.get(), metric_report_queue_.get(), settings_.get(),
  322. "invalid/path", /*setting_enabled_default_value=*/false, kRateSettingPath,
  323. base::Milliseconds(interval / 2));
  324. sampler_->SetMetricData(std::move(metric_data));
  325. task_environment_.FastForwardBy(base::Milliseconds(interval));
  326. FlushTasks();
  327. // Setting is disabled by default, no data collected.
  328. EXPECT_EQ(sampler_->GetNumCollectCalls(), 0);
  329. EXPECT_TRUE(metric_report_queue_->GetMetricDataReported().empty());
  330. }
  331. TEST_F(MetricDataCollectorTest, PeriodicEventCollector_NoAdditionalSamplers) {
  332. constexpr int interval = 10000;
  333. settings_->SetBoolean(kEnableSettingPath, true);
  334. settings_->SetInteger(kRateSettingPath, interval);
  335. MetricData metric_data[3];
  336. metric_data[0].mutable_info_data();
  337. metric_data[1].mutable_telemetry_data();
  338. metric_data[2].mutable_info_data();
  339. auto event_detector = std::make_unique<test::FakeEventDetector>();
  340. auto* event_detector_ptr = event_detector.get();
  341. sampler_->SetMetricData(metric_data[0]);
  342. PeriodicEventCollector collector(sampler_.get(), std::move(event_detector),
  343. {}, metric_report_queue_.get(),
  344. settings_.get(), kEnableSettingPath,
  345. /*setting_enabled_default_value=*/false,
  346. kRateSettingPath, base::Milliseconds(15000));
  347. // One initial collection at startup, data collected but not reported.
  348. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  349. FlushTasks();
  350. sampler_->SetMetricData(std::move(metric_data[1]));
  351. event_detector_ptr->SetHasEvent(true);
  352. task_environment_.FastForwardBy(base::Milliseconds(interval));
  353. // Data collected and reported.
  354. EXPECT_EQ(sampler_->GetNumCollectCalls(), 2);
  355. FlushTasks();
  356. sampler_->SetMetricData(std::move(metric_data[2]));
  357. event_detector_ptr->SetHasEvent(false);
  358. task_environment_.FastForwardBy(base::Milliseconds(interval));
  359. // Data collected but not reported.
  360. EXPECT_EQ(sampler_->GetNumCollectCalls(), 3);
  361. FlushTasks();
  362. const auto& previous_metric_list =
  363. event_detector_ptr->GetPreviousMetricList();
  364. ASSERT_THAT(previous_metric_list, ::testing::SizeIs(3));
  365. EXPECT_FALSE(previous_metric_list[0]->has_timestamp_ms());
  366. EXPECT_FALSE(previous_metric_list[0]->has_info_data());
  367. EXPECT_FALSE(previous_metric_list[0]->has_telemetry_data());
  368. EXPECT_FALSE(previous_metric_list[0]->has_event_data());
  369. EXPECT_TRUE(previous_metric_list[1]->has_timestamp_ms());
  370. EXPECT_TRUE(previous_metric_list[1]->has_info_data());
  371. EXPECT_FALSE(previous_metric_list[1]->has_telemetry_data());
  372. EXPECT_FALSE(previous_metric_list[1]->has_event_data());
  373. EXPECT_TRUE(previous_metric_list[2]->has_timestamp_ms());
  374. EXPECT_FALSE(previous_metric_list[2]->has_info_data());
  375. EXPECT_TRUE(previous_metric_list[2]->has_telemetry_data());
  376. EXPECT_TRUE(previous_metric_list[2]->has_event_data());
  377. const auto& metric_data_reported =
  378. metric_report_queue_->GetMetricDataReported();
  379. ASSERT_THAT(metric_data_reported, ::testing::SizeIs(1));
  380. EXPECT_TRUE(metric_data_reported[0]->has_timestamp_ms());
  381. EXPECT_FALSE(metric_data_reported[0]->has_info_data());
  382. EXPECT_TRUE(metric_data_reported[0]->has_telemetry_data());
  383. EXPECT_TRUE(metric_data_reported[0]->has_event_data());
  384. }
  385. TEST_F(MetricDataCollectorTest, PeriodicEventCollector_WithAdditionalSamplers) {
  386. settings_->SetBoolean(kEnableSettingPath, true);
  387. MetricData metric_data;
  388. metric_data.mutable_telemetry_data();
  389. MetricData additional_metric_data[3];
  390. additional_metric_data[0]
  391. .mutable_telemetry_data()
  392. ->mutable_networks_telemetry()
  393. ->mutable_https_latency_data()
  394. ->set_verdict(RoutineVerdict::PROBLEM);
  395. additional_metric_data[1]
  396. .mutable_telemetry_data()
  397. ->mutable_networks_telemetry()
  398. ->mutable_https_latency_data()
  399. ->set_problem(HttpsLatencyProblem::HIGH_LATENCY);
  400. additional_metric_data[2]
  401. .mutable_telemetry_data()
  402. ->mutable_networks_telemetry()
  403. ->mutable_https_latency_data()
  404. ->set_latency_ms(1500);
  405. test::FakeSampler additional_samplers[3];
  406. std::vector<Sampler*> additional_sampler_ptrs;
  407. for (int i = 0; i < 3; ++i) {
  408. additional_samplers[i].SetMetricData(additional_metric_data[i]);
  409. additional_sampler_ptrs.emplace_back(additional_samplers + i);
  410. }
  411. test::FakeSampler empty_additional_sampler;
  412. additional_sampler_ptrs.emplace_back(&empty_additional_sampler);
  413. auto event_detector = std::make_unique<test::FakeEventDetector>();
  414. sampler_->SetMetricData(std::move(metric_data));
  415. event_detector->SetHasEvent(true);
  416. PeriodicEventCollector collector(sampler_.get(), std::move(event_detector),
  417. std::move(additional_sampler_ptrs),
  418. metric_report_queue_.get(), settings_.get(),
  419. kEnableSettingPath,
  420. /*setting_enabled_default_value=*/false,
  421. kRateSettingPath, base::Milliseconds(15000));
  422. // Data collected and reported.
  423. EXPECT_EQ(sampler_->GetNumCollectCalls(), 1);
  424. task_environment_.RunUntilIdle();
  425. const auto& metric_data_reported =
  426. metric_report_queue_->GetMetricDataReported();
  427. ASSERT_THAT(metric_data_reported, ::testing::SizeIs(1));
  428. EXPECT_TRUE(metric_data_reported[0]->has_timestamp_ms());
  429. EXPECT_TRUE(metric_data_reported[0]->has_event_data());
  430. ASSERT_TRUE(metric_data_reported[0]->has_telemetry_data());
  431. ASSERT_TRUE(
  432. metric_data_reported[0]->telemetry_data().has_networks_telemetry());
  433. ASSERT_TRUE(metric_data_reported[0]
  434. ->telemetry_data()
  435. .networks_telemetry()
  436. .has_https_latency_data());
  437. auto https_latency_data = metric_data_reported[0]
  438. ->telemetry_data()
  439. .networks_telemetry()
  440. .https_latency_data();
  441. EXPECT_EQ(https_latency_data.verdict(), additional_metric_data[0]
  442. .telemetry_data()
  443. .networks_telemetry()
  444. .https_latency_data()
  445. .verdict());
  446. EXPECT_EQ(https_latency_data.problem(), additional_metric_data[1]
  447. .telemetry_data()
  448. .networks_telemetry()
  449. .https_latency_data()
  450. .problem());
  451. EXPECT_EQ(https_latency_data.latency_ms(), additional_metric_data[2]
  452. .telemetry_data()
  453. .networks_telemetry()
  454. .https_latency_data()
  455. .latency_ms());
  456. }
  457. } // namespace
  458. } // namespace reporting