RTCStatsCollectorTest: ExpectReportContainsCertificateInfo /w EXPECT_EQ

webrtc/api/rtcstatscollector_unittest.cc

 /*
  *  Copyright 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 500 matching lines @@
     EXPECT_EQ(*candidate_stats->protocol, candidate.protocol());
     EXPECT_EQ(*candidate_stats->candidate_type,
               CandidateTypeToRTCIceCandidateTypeForTesting(candidate.type()));
     EXPECT_EQ(*candidate_stats->priority,
               static_cast<int32_t>(candidate.priority()));
     // TODO(hbos): Define candidate_stats->url. crbug.com/632723
     EXPECT_FALSE(candidate_stats->url.is_defined());
     return candidate_stats;
   }
 
-  void ExpectReportContainsCertificateInfo(
-      const rtc::scoped_refptr<const RTCStatsReport>& report,
-      const CertificateInfo& cert_info) {
-    for (size_t i = 0; i < cert_info.fingerprints.size(); ++i) {
-      const RTCStats* stats = report->Get(
-          "RTCCertificate_" + cert_info.fingerprints[i]);
-      ASSERT_TRUE(stats);
-      const RTCCertificateStats& cert_stats =
-          stats->cast_to<const RTCCertificateStats>();
-      EXPECT_EQ(*cert_stats.fingerprint, cert_info.fingerprints[i]);
-      EXPECT_EQ(*cert_stats.fingerprint_algorithm, "sha-1");
-      EXPECT_EQ(*cert_stats.base64_certificate, cert_info.pems[i]);
-      if (i + 1 < cert_info.fingerprints.size()) {
-        EXPECT_EQ(*cert_stats.issuer_certificate_id,
-                  "RTCCertificate_" + cert_info.fingerprints[i + 1]);
-      } else {
-        EXPECT_FALSE(cert_stats.issuer_certificate_id.is_defined());
-      }
-    }
-  }
-
   void ExpectReportContainsDataChannel(
       const rtc::scoped_refptr<const RTCStatsReport>& report,
       const DataChannel& data_channel) {
     const RTCStats* stats = report->Get("RTCDataChannel_" +
                                         rtc::ToString<>(data_channel.id()));
     EXPECT_TRUE(stats);
     const RTCDataChannelStats& data_channel_stats =
         stats->cast_to<const RTCDataChannelStats>();
     EXPECT_EQ(*data_channel_stats.label, data_channel.label());
     EXPECT_EQ(*data_channel_stats.protocol, data_channel.protocol());
@@ skipping 93 matching lines @@
       }));
   EXPECT_CALL(test_->session(),
       GetRemoteSSLCertificate_ReturnsRawPointer(_)).WillRepeatedly(Invoke(
       [this, &remote_certinfo](const std::string& transport_name) {
         if (transport_name == "transport")
           return remote_certinfo->certificate->ssl_certificate().GetReference();
         return static_cast<rtc::SSLCertificate*>(nullptr);
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
-  ExpectReportContainsCertificateInfo(report, *local_certinfo.get());
-  ExpectReportContainsCertificateInfo(report, *remote_certinfo.get());
+
+  RTCCertificateStats expected_local_certificate(
+      "RTCCertificate_" + local_certinfo->fingerprints[0],
+      report->timestamp_us());
+  expected_local_certificate.fingerprint = local_certinfo->fingerprints[0];
+  expected_local_certificate.fingerprint_algorithm = "sha-1";
+  expected_local_certificate.base64_certificate = local_certinfo->pems[0];
+  ASSERT(report->Get(expected_local_certificate.id()));

[Taylor Brandstetter, 2016/12/20 19:49:49]

Should this use ASSERT_TRUE, so it's a gtest assert?

[hbos, 2016/12/21 09:59:11]

Ah, yes!

+  EXPECT_EQ(expected_local_certificate,
+            report->Get(expected_local_certificate.id())->cast_to<
+                  RTCCertificateStats>());

[Taylor Brandstetter, 2016/12/20 19:49:49]

Each of these blocks of code is effectively the same as
ExpectReportContainsCertificateInfo, but uses EXPECT_EQ. So I think it would
make more sense to keep ExpectReportContainsCertificateInfo around and just
change it to use EXPECT_EQ.

[hbos, 2016/12/21 09:59:11]

Yeah that makes sense :) Done.

+
+  RTCCertificateStats expected_remote_certificate(
+      "RTCCertificate_" + remote_certinfo->fingerprints[0],
+      report->timestamp_us());
+  expected_remote_certificate.fingerprint = remote_certinfo->fingerprints[0];
+  expected_remote_certificate.fingerprint_algorithm = "sha-1";
+  expected_remote_certificate.base64_certificate = remote_certinfo->pems[0];
+  ASSERT(report->Get(expected_remote_certificate.id()));
+  EXPECT_EQ(expected_remote_certificate,
+            report->Get(expected_remote_certificate.id())->cast_to<
+                  RTCCertificateStats>());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCCodecStats) {
   MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
   cricket::VoiceChannel voice_channel(
       test_->worker_thread(), test_->network_thread(), test_->media_engine(),
       voice_media_channel, nullptr, "VoiceContentName", kDefaultRtcpEnabled,
       kDefaultSrtpRequired);
 
   MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
@@ skipping 157 matching lines @@
               .GetReference();
         }
         if (transport_name == "video") {
           return video_remote_certinfo->certificate->ssl_certificate()
               .GetReference();
         }
         return static_cast<rtc::SSLCertificate*>(nullptr);
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
-  ExpectReportContainsCertificateInfo(report, *audio_local_certinfo.get());
-  ExpectReportContainsCertificateInfo(report, *audio_remote_certinfo.get());
-  ExpectReportContainsCertificateInfo(report, *video_local_certinfo.get());
-  ExpectReportContainsCertificateInfo(report, *video_remote_certinfo.get());
+
+  RTCCertificateStats expected_local_audio_certificate(
+      "RTCCertificate_" + audio_local_certinfo->fingerprints[0],
+      report->timestamp_us());
+  expected_local_audio_certificate.fingerprint =
+      audio_local_certinfo->fingerprints[0];
+  expected_local_audio_certificate.fingerprint_algorithm = "sha-1";
+  expected_local_audio_certificate.base64_certificate =
+      audio_local_certinfo->pems[0];
+  ASSERT(report->Get(expected_local_audio_certificate.id()));
+  EXPECT_EQ(expected_local_audio_certificate,
+            report->Get(expected_local_audio_certificate.id())->cast_to<
+                  RTCCertificateStats>());
+
+  RTCCertificateStats expected_remote_audio_certificate(
+      "RTCCertificate_" + audio_remote_certinfo->fingerprints[0],
+      report->timestamp_us());
+  expected_remote_audio_certificate.fingerprint =
+      audio_remote_certinfo->fingerprints[0];
+  expected_remote_audio_certificate.fingerprint_algorithm = "sha-1";
+  expected_remote_audio_certificate.base64_certificate =
+      audio_remote_certinfo->pems[0];
+  ASSERT(report->Get(expected_remote_audio_certificate.id()));
+  EXPECT_EQ(expected_remote_audio_certificate,
+            report->Get(expected_remote_audio_certificate.id())->cast_to<
+                  RTCCertificateStats>());
+
+  RTCCertificateStats expected_local_video_certificate(
+      "RTCCertificate_" + video_local_certinfo->fingerprints[0],
+      report->timestamp_us());
+  expected_local_video_certificate.fingerprint =
+      video_local_certinfo->fingerprints[0];
+  expected_local_video_certificate.fingerprint_algorithm = "sha-1";
+  expected_local_video_certificate.base64_certificate =
+      video_local_certinfo->pems[0];
+  ASSERT(report->Get(expected_local_video_certificate.id()));
+  EXPECT_EQ(expected_local_video_certificate,
+            report->Get(expected_local_video_certificate.id())->cast_to<
+                  RTCCertificateStats>());
+
+  RTCCertificateStats expected_remote_video_certificate(
+      "RTCCertificate_" + video_remote_certinfo->fingerprints[0],
+      report->timestamp_us());
+  expected_remote_video_certificate.fingerprint =
+      video_remote_certinfo->fingerprints[0];
+  expected_remote_video_certificate.fingerprint_algorithm = "sha-1";
+  expected_remote_video_certificate.base64_certificate =
+      video_remote_certinfo->pems[0];
+  ASSERT(report->Get(expected_remote_video_certificate.id()));
+  EXPECT_EQ(expected_remote_video_certificate,
+            report->Get(expected_remote_video_certificate.id())->cast_to<
+                  RTCCertificateStats>());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsChain) {
   std::vector<std::string> local_ders;
   local_ders.push_back("(local) this");
   local_ders.push_back("(local) is");
   local_ders.push_back("(local) a");
   local_ders.push_back("(local) chain");
   std::unique_ptr<CertificateInfo> local_certinfo =
       CreateFakeCertificateAndInfoFromDers(local_ders);
@@ skipping 23 matching lines @@
       }));
   EXPECT_CALL(test_->session(),
       GetRemoteSSLCertificate_ReturnsRawPointer(_)).WillRepeatedly(Invoke(
       [this, &remote_certinfo](const std::string& transport_name) {
         if (transport_name == "transport")
           return remote_certinfo->certificate->ssl_certificate().GetReference();
         return static_cast<rtc::SSLCertificate*>(nullptr);
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
-  ExpectReportContainsCertificateInfo(report, *local_certinfo.get());
-  ExpectReportContainsCertificateInfo(report, *remote_certinfo.get());
+
+  for (size_t i = 0; i < local_certinfo->fingerprints.size(); ++i) {
+      RTCCertificateStats expected_local_certificate(
+          "RTCCertificate_" + local_certinfo->fingerprints[i],
+          report->timestamp_us());
+      expected_local_certificate.fingerprint =
+          local_certinfo->fingerprints[i];
+      expected_local_certificate.fingerprint_algorithm = "sha-1";
+      expected_local_certificate.base64_certificate =
+          local_certinfo->pems[i];
+      if (i + 1 < local_certinfo->fingerprints.size()) {
+        expected_local_certificate.issuer_certificate_id =
+          "RTCCertificate_" + local_certinfo->fingerprints[i + 1];
+      }
+      ASSERT(report->Get(expected_local_certificate.id()));
+      EXPECT_EQ(expected_local_certificate,
+                report->Get(expected_local_certificate.id())->cast_to<
+                      RTCCertificateStats>());
+  }
+
+  for (size_t i = 0; i < remote_certinfo->fingerprints.size(); ++i) {
+      RTCCertificateStats expected_remote_certificate(
+          "RTCCertificate_" + remote_certinfo->fingerprints[i],
+          report->timestamp_us());
+      expected_remote_certificate.fingerprint =
+          remote_certinfo->fingerprints[i];
+      expected_remote_certificate.fingerprint_algorithm = "sha-1";
+      expected_remote_certificate.base64_certificate =
+          remote_certinfo->pems[i];
+      if (i + 1 < remote_certinfo->fingerprints.size()) {
+        expected_remote_certificate.issuer_certificate_id =
+          "RTCCertificate_" + remote_certinfo->fingerprints[i + 1];
+      }
+      ASSERT(report->Get(expected_remote_certificate.id()));
+      EXPECT_EQ(expected_remote_certificate,
+                report->Get(expected_remote_certificate.id())->cast_to<
+                      RTCCertificateStats>());
+  }
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
   test_->data_channels().push_back(
       new MockDataChannel(0, DataChannelInterface::kConnecting));
   test_->data_channels().push_back(
       new MockDataChannel(1, DataChannelInterface::kOpen));
   test_->data_channels().push_back(
       new MockDataChannel(2, DataChannelInterface::kClosing));
   test_->data_channels().push_back(
@@ skipping 1014 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc