src/third_party/libjingle/source/talk/app/webrtc/statscollector_unittest.cc

   1 /*
   2  * libjingle
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  *  1. Redistributions of source code must retain the above copyright notice,
   8  *     this list of conditions and the following disclaimer.
   9  *  2. Redistributions in binary form must reproduce the above copyright notice,
  10  *     this list of conditions and the following disclaimer in the documentation
  11  *     and/or other materials provided with the distribution.
  12  *  3. The name of the author may not be used to endorse or promote products
  13  *     derived from this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  16  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  17  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  18  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  19  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  21  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  22  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  24  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <stdio.h>
  28
  29 #include "talk/app/webrtc/statscollector.h"
  30
  31 #include "talk/app/webrtc/mediastream.h"
  32 #include "talk/app/webrtc/videotrack.h"
  33 #include "talk/base/base64.h"
  34 #include "talk/base/fakesslidentity.h"
  35 #include "talk/base/gunit.h"
  36 #include "talk/media/base/fakemediaengine.h"
  37 #include "talk/media/devices/fakedevicemanager.h"
  38 #include "talk/p2p/base/fakesession.h"
  39 #include "talk/session/media/channelmanager.h"
  40 #include "testing/base/public/gmock.h"
  41
  42 using testing::_;
  43 using testing::DoAll;
  44 using testing::Return;
  45 using testing::ReturnNull;
  46 using testing::SetArgPointee;
  47
  48 namespace cricket {
  49
  50 class ChannelManager;
  51 class FakeDeviceManager;
  52
  53 }  // namespace cricket
  54
  55 namespace {
  56
  57 // Error return values
  58 const char kNotFound[] = "NOT FOUND";
  59 const char kNoReports[] = "NO REPORTS";
  60
  61 // Constant names for track identification.
  62 const char kTrackId[] = "somename";
  63 const uint32 kSsrcOfTrack = 1234;
  64
  65 class MockWebRtcSession : public webrtc::WebRtcSession {
  66  public:
  67   explicit MockWebRtcSession(cricket::ChannelManager* channel_manager)
  68     : WebRtcSession(channel_manager, talk_base::Thread::Current(),
  69                     talk_base::Thread::Current(), NULL, NULL) {
  70   }
  71   MOCK_METHOD0(video_channel, cricket::VideoChannel*());
  72   MOCK_METHOD2(GetTrackIdBySsrc, bool(uint32, std::string*));
  73   MOCK_METHOD1(GetStats, bool(cricket::SessionStats*));
  74   MOCK_METHOD1(GetTransport, cricket::Transport*(const std::string&));
  75 };
  76
  77 class MockVideoMediaChannel : public cricket::FakeVideoMediaChannel {
  78  public:
  79   MockVideoMediaChannel()
  80     : cricket::FakeVideoMediaChannel(NULL) {
  81   }
  82   // MOCK_METHOD0(transport_channel, cricket::TransportChannel*());
  83   MOCK_METHOD1(GetStats, bool(cricket::VideoMediaInfo*));
  84 };
  85
  86 bool GetValue(const webrtc::StatsReport* report,
  87               const std::string& name,
  88               std::string* value) {
  89   webrtc::StatsReport::Values::const_iterator it = report->values.begin();
  90   for (; it != report->values.end(); ++it) {
  91     if (it->name == name) {
  92       *value = it->value;
  93       return true;
  94     }
  95   }
  96   return false;
  97 }
  98
  99 std::string ExtractStatsValue(const std::string& type,
 100                               const webrtc::StatsReports& reports,
 101                               const std::string name) {
 102   if (reports.empty()) {
 103     return kNoReports;
 104   }
 105   for (size_t i = 0; i < reports.size(); ++i) {
 106     if (reports[i].type != type)
 107       continue;
 108     std::string ret;
 109     if (GetValue(&reports[i], name, &ret)) {
 110       return ret;
 111     }
 112   }
 113
 114   return kNotFound;
 115 }
 116
 117 // Finds the |n|-th report of type |type| in |reports|.
 118 // |n| starts from 1 for finding the first report.
 119 const webrtc::StatsReport* FindNthReportByType(
 120     const webrtc::StatsReports& reports, const std::string& type, int n) {
 121   for (size_t i = 0; i < reports.size(); ++i) {
 122     if (reports[i].type == type) {
 123       n--;
 124       if (n == 0)
 125         return &reports[i];
 126     }
 127   }
 128   return NULL;
 129 }
 130
 131 const webrtc::StatsReport* FindReportById(const webrtc::StatsReports& reports,
 132                                           const std::string& id) {
 133   for (size_t i = 0; i < reports.size(); ++i) {
 134     if (reports[i].id == id) {
 135       return &reports[i];
 136     }
 137   }
 138   return NULL;
 139 }
 140
 141 std::string ExtractSsrcStatsValue(webrtc::StatsReports reports,
 142                                   const std::string& name) {
 143   return ExtractStatsValue(
 144       webrtc::StatsReport::kStatsReportTypeSsrc, reports, name);
 145 }
 146
 147 std::string ExtractBweStatsValue(webrtc::StatsReports reports,
 148                                   const std::string& name) {
 149   return ExtractStatsValue(
 150       webrtc::StatsReport::kStatsReportTypeBwe, reports, name);
 151 }
 152
 153 std::string DerToPem(const std::string& der) {
 154   return talk_base::SSLIdentity::DerToPem(
 155         talk_base::kPemTypeCertificate,
 156         reinterpret_cast<const unsigned char*>(der.c_str()),
 157         der.length());
 158 }
 159
 160 std::vector<std::string> DersToPems(
 161     const std::vector<std::string>& ders) {
 162   std::vector<std::string> pems(ders.size());
 163   std::transform(ders.begin(), ders.end(), pems.begin(), DerToPem);
 164   return pems;
 165 }
 166
 167 void CheckCertChainReports(const webrtc::StatsReports& reports,
 168                            const std::vector<std::string>& ders,
 169                            const std::string& start_id) {
 170   std::string certificate_id = start_id;
 171   size_t i = 0;
 172   while (true) {
 173     const webrtc::StatsReport* report = FindReportById(reports, certificate_id);
 174     ASSERT_TRUE(report != NULL);
 175
 176     std::string der_base64;
 177     EXPECT_TRUE(GetValue(
 178         report, webrtc::StatsReport::kStatsValueNameDer, &der_base64));
 179     std::string der = talk_base::Base64::Decode(der_base64,
 180                                                 talk_base::Base64::DO_STRICT);
 181     EXPECT_EQ(ders[i], der);
 182
 183     std::string fingerprint_algorithm;
 184     EXPECT_TRUE(GetValue(
 185         report,
 186         webrtc::StatsReport::kStatsValueNameFingerprintAlgorithm,
 187         &fingerprint_algorithm));
 188     // The digest algorithm for a FakeSSLCertificate is always SHA-1.
 189     std::string sha_1_str = talk_base::DIGEST_SHA_1;
 190     EXPECT_EQ(sha_1_str, fingerprint_algorithm);
 191
 192     std::string dummy_fingerprint;  // Value is not checked.
 193     EXPECT_TRUE(GetValue(
 194         report,
 195         webrtc::StatsReport::kStatsValueNameFingerprint,
 196         &dummy_fingerprint));
 197
 198     ++i;
 199     if (!GetValue(
 200         report, webrtc::StatsReport::kStatsValueNameIssuerId, &certificate_id))
 201       break;
 202   }
 203   EXPECT_EQ(ders.size(), i);
 204 }
 205
 206 class StatsCollectorTest : public testing::Test {
 207  protected:
 208   StatsCollectorTest()
 209     : media_engine_(new cricket::FakeMediaEngine),
 210       channel_manager_(
 211           new cricket::ChannelManager(media_engine_,
 212                                       new cricket::FakeDeviceManager(),
 213                                       talk_base::Thread::Current())),
 214       session_(channel_manager_.get()),
 215       track_id_(kTrackId) {
 216     // By default, we ignore session GetStats calls.
 217     EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Return(false));
 218   }
 219
 220   // This creates a standard setup with a transport called "trspname"
 221   // having one transport channel
 222   // and the specified virtual connection name.
 223   void InitSessionStats(const std::string vc_name) {
 224     const std::string kTransportName("trspname");
 225     cricket::TransportStats transport_stats;
 226     cricket::TransportChannelStats channel_stats;
 227     channel_stats.component = 1;
 228     transport_stats.content_name = kTransportName;
 229     transport_stats.channel_stats.push_back(channel_stats);
 230
 231     session_stats_.transport_stats[kTransportName] = transport_stats;
 232     session_stats_.proxy_to_transport[vc_name] = kTransportName;
 233   }
 234
 235   // Adds a track with a given SSRC into the stats.
 236   void AddVideoTrackStats() {
 237     stream_ = webrtc::MediaStream::Create("streamlabel");
 238     track_= webrtc::VideoTrack::Create(kTrackId, NULL);
 239     stream_->AddTrack(track_);
 240     EXPECT_CALL(session_, GetTrackIdBySsrc(kSsrcOfTrack, _))
 241       .WillRepeatedly(DoAll(SetArgPointee<1>(track_id_),
 242                             Return(true)));
 243   }
 244
 245   void TestCertificateReports(const talk_base::FakeSSLCertificate& local_cert,
 246                               const std::vector<std::string>& local_ders,
 247                               const talk_base::FakeSSLCertificate& remote_cert,
 248                               const std::vector<std::string>& remote_ders) {
 249     webrtc::StatsCollector stats;  // Implementation under test.
 250     webrtc::StatsReports reports;  // returned values.
 251     stats.set_session(&session_);
 252
 253     // Fake stats to process.
 254     cricket::TransportChannelStats channel_stats;
 255     channel_stats.component = 1;
 256
 257     cricket::TransportStats transport_stats;
 258     transport_stats.content_name = "audio";
 259     transport_stats.channel_stats.push_back(channel_stats);
 260
 261     cricket::SessionStats session_stats;
 262     session_stats.transport_stats[transport_stats.content_name] =
 263         transport_stats;
 264
 265     // Fake certificates to report.
 266     talk_base::FakeSSLIdentity local_identity(local_cert);
 267     talk_base::scoped_ptr<talk_base::FakeSSLCertificate> remote_cert_copy(
 268         remote_cert.GetReference());
 269
 270     // Fake transport object.
 271     talk_base::scoped_ptr<cricket::FakeTransport> transport(
 272         new cricket::FakeTransport(
 273             session_.signaling_thread(),
 274             session_.worker_thread(),
 275             transport_stats.content_name));
 276     transport->SetIdentity(&local_identity);
 277     cricket::FakeTransportChannel* channel =
 278         static_cast<cricket::FakeTransportChannel*>(
 279             transport->CreateChannel(channel_stats.component));
 280     EXPECT_FALSE(channel == NULL);
 281     channel->SetRemoteCertificate(remote_cert_copy.get());
 282
 283     // Configure MockWebRtcSession
 284     EXPECT_CALL(session_, GetTransport(transport_stats.content_name))
 285       .WillOnce(Return(transport.get()));
 286     EXPECT_CALL(session_, GetStats(_))
 287       .WillOnce(DoAll(SetArgPointee<0>(session_stats),
 288                       Return(true)));
 289     EXPECT_CALL(session_, video_channel())
 290       .WillRepeatedly(ReturnNull());
 291
 292     stats.UpdateStats();
 293
 294     stats.GetStats(NULL, &reports);
 295
 296     const webrtc::StatsReport* channel_report = FindNthReportByType(
 297         reports, webrtc::StatsReport::kStatsReportTypeComponent, 1);
 298     EXPECT_TRUE(channel_report != NULL);
 299
 300     // Check local certificate chain.
 301     std::string local_certificate_id = ExtractStatsValue(
 302         webrtc::StatsReport::kStatsReportTypeComponent,
 303         reports,
 304         webrtc::StatsReport::kStatsValueNameLocalCertificateId);
 305     EXPECT_NE(kNotFound, local_certificate_id);
 306     CheckCertChainReports(reports, local_ders, local_certificate_id);
 307
 308     // Check remote certificate chain.
 309     std::string remote_certificate_id = ExtractStatsValue(
 310         webrtc::StatsReport::kStatsReportTypeComponent,
 311         reports,
 312         webrtc::StatsReport::kStatsValueNameRemoteCertificateId);
 313     EXPECT_NE(kNotFound, remote_certificate_id);
 314     CheckCertChainReports(reports, remote_ders, remote_certificate_id);
 315   }
 316
 317   cricket::FakeMediaEngine* media_engine_;
 318   talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
 319   MockWebRtcSession session_;
 320   cricket::SessionStats session_stats_;
 321   talk_base::scoped_refptr<webrtc::MediaStream> stream_;
 322   talk_base::scoped_refptr<webrtc::VideoTrack> track_;
 323   std::string track_id_;
 324 };
 325
 326 // This test verifies that 64-bit counters are passed successfully.
 327 TEST_F(StatsCollectorTest, BytesCounterHandles64Bits) {
 328   webrtc::StatsCollector stats;  // Implementation under test.
 329   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel;
 330   cricket::VideoChannel video_channel(talk_base::Thread::Current(),
 331       media_engine_, media_channel, &session_, "", false, NULL);
 332   webrtc::StatsReports reports;  // returned values.
 333   cricket::VideoSenderInfo video_sender_info;
 334   cricket::VideoMediaInfo stats_read;
 335   // The number of bytes must be larger than 0xFFFFFFFF for this test.
 336   const int64 kBytesSent = 12345678901234LL;
 337   const std::string kBytesSentString("12345678901234");
 338
 339   stats.set_session(&session_);
 340   AddVideoTrackStats();
 341   stats.AddStream(stream_);
 342
 343   // Construct a stats value to read.
 344   video_sender_info.add_ssrc(1234);
 345   video_sender_info.bytes_sent = kBytesSent;
 346   stats_read.senders.push_back(video_sender_info);
 347
 348   EXPECT_CALL(session_, video_channel())
 349     .WillRepeatedly(Return(&video_channel));
 350   EXPECT_CALL(*media_channel, GetStats(_))
 351     .WillOnce(DoAll(SetArgPointee<0>(stats_read),
 352                     Return(true)));
 353   stats.UpdateStats();
 354   stats.GetStats(NULL, &reports);
 355   std::string result = ExtractSsrcStatsValue(reports, "bytesSent");
 356   EXPECT_EQ(kBytesSentString, result);
 357 }
 358
 359 // Test that BWE information is reported via stats.
 360 TEST_F(StatsCollectorTest, BandwidthEstimationInfoIsReported) {
 361   webrtc::StatsCollector stats;  // Implementation under test.
 362   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel;
 363   cricket::VideoChannel video_channel(talk_base::Thread::Current(),
 364       media_engine_, media_channel, &session_, "", false, NULL);
 365   webrtc::StatsReports reports;  // returned values.
 366   cricket::VideoSenderInfo video_sender_info;
 367   cricket::VideoMediaInfo stats_read;
 368   // Set up an SSRC just to test that we get both kinds of stats back: SSRC and
 369   // BWE.
 370   const int64 kBytesSent = 12345678901234LL;
 371   const std::string kBytesSentString("12345678901234");
 372
 373   stats.set_session(&session_);
 374   AddVideoTrackStats();
 375   stats.AddStream(stream_);
 376
 377   // Construct a stats value to read.
 378   video_sender_info.add_ssrc(1234);
 379   video_sender_info.bytes_sent = kBytesSent;
 380   stats_read.senders.push_back(video_sender_info);
 381   cricket::BandwidthEstimationInfo bwe;
 382   const int kTargetEncBitrate = 123456;
 383   const std::string kTargetEncBitrateString("123456");
 384   bwe.target_enc_bitrate = kTargetEncBitrate;
 385   stats_read.bw_estimations.push_back(bwe);
 386
 387   EXPECT_CALL(session_, video_channel())
 388     .WillRepeatedly(Return(&video_channel));
 389   EXPECT_CALL(*media_channel, GetStats(_))
 390     .WillOnce(DoAll(SetArgPointee<0>(stats_read),
 391                     Return(true)));
 392
 393   stats.UpdateStats();
 394   stats.GetStats(NULL, &reports);
 395   std::string result = ExtractSsrcStatsValue(reports, "bytesSent");
 396   EXPECT_EQ(kBytesSentString, result);
 397   result = ExtractBweStatsValue(reports, "googTargetEncBitrate");
 398   EXPECT_EQ(kTargetEncBitrateString, result);
 399 }
 400
 401 // This test verifies that an object of type "googSession" always
 402 // exists in the returned stats.
 403 TEST_F(StatsCollectorTest, SessionObjectExists) {
 404   webrtc::StatsCollector stats;  // Implementation under test.
 405   webrtc::StatsReports reports;  // returned values.
 406   stats.set_session(&session_);
 407   EXPECT_CALL(session_, video_channel())
 408     .WillRepeatedly(ReturnNull());
 409   stats.UpdateStats();
 410   stats.GetStats(NULL, &reports);
 411   const webrtc::StatsReport* session_report = FindNthReportByType(
 412       reports, webrtc::StatsReport::kStatsReportTypeSession, 1);
 413   EXPECT_FALSE(session_report == NULL);
 414 }
 415
 416 // This test verifies that only one object of type "googSession" exists
 417 // in the returned stats.
 418 TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
 419   webrtc::StatsCollector stats;  // Implementation under test.
 420   webrtc::StatsReports reports;  // returned values.
 421   stats.set_session(&session_);
 422   EXPECT_CALL(session_, video_channel())
 423     .WillRepeatedly(ReturnNull());
 424   stats.UpdateStats();
 425   stats.UpdateStats();
 426   stats.GetStats(NULL, &reports);
 427   const webrtc::StatsReport* session_report = FindNthReportByType(
 428       reports, webrtc::StatsReport::kStatsReportTypeSession, 1);
 429   EXPECT_FALSE(session_report == NULL);
 430   session_report = FindNthReportByType(
 431       reports, webrtc::StatsReport::kStatsReportTypeSession, 2);
 432   EXPECT_EQ(NULL, session_report);
 433 }
 434
 435 // This test verifies that the empty track report exists in the returned stats
 436 // without calling StatsCollector::UpdateStats.
 437 TEST_F(StatsCollectorTest, TrackObjectExistsWithoutUpdateStats) {
 438   webrtc::StatsCollector stats;  // Implementation under test.
 439   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel;
 440   cricket::VideoChannel video_channel(talk_base::Thread::Current(),
 441       media_engine_, media_channel, &session_, "", false, NULL);
 442   AddVideoTrackStats();
 443   stats.AddStream(stream_);
 444
 445   stats.set_session(&session_);
 446
 447   webrtc::StatsReports reports;
 448
 449   // Verfies the existence of the track report.
 450   stats.GetStats(NULL, &reports);
 451   EXPECT_EQ((size_t)1, reports.size());
 452   EXPECT_EQ(std::string(webrtc::StatsReport::kStatsReportTypeTrack),
 453             reports[0].type);
 454
 455   std::string trackValue =
 456       ExtractStatsValue(webrtc::StatsReport::kStatsReportTypeTrack,
 457                         reports,
 458                         webrtc::StatsReport::kStatsValueNameTrackId);
 459   EXPECT_EQ(kTrackId, trackValue);
 460 }
 461
 462 // This test verifies that the empty track report exists in the returned stats
 463 // when StatsCollector::UpdateStats is called with ssrc stats.
 464 TEST_F(StatsCollectorTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
 465   webrtc::StatsCollector stats;  // Implementation under test.
 466   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel;
 467   cricket::VideoChannel video_channel(talk_base::Thread::Current(),
 468       media_engine_, media_channel, &session_, "", false, NULL);
 469   AddVideoTrackStats();
 470   stats.AddStream(stream_);
 471
 472   stats.set_session(&session_);
 473
 474   webrtc::StatsReports reports;
 475
 476   // Constructs an ssrc stats update.
 477   cricket::VideoSenderInfo video_sender_info;
 478   cricket::VideoMediaInfo stats_read;
 479   const int64 kBytesSent = 12345678901234LL;
 480
 481   // Construct a stats value to read.
 482   video_sender_info.add_ssrc(1234);
 483   video_sender_info.bytes_sent = kBytesSent;
 484   stats_read.senders.push_back(video_sender_info);
 485
 486   EXPECT_CALL(session_, video_channel())
 487     .WillRepeatedly(Return(&video_channel));
 488   EXPECT_CALL(*media_channel, GetStats(_))
 489     .WillOnce(DoAll(SetArgPointee<0>(stats_read),
 490                     Return(true)));
 491
 492   stats.UpdateStats();
 493   stats.GetStats(NULL, &reports);
 494   // |reports| should contain at least one session report, one track report,
 495   // and one ssrc report.
 496   EXPECT_LE((size_t)3, reports.size());
 497   const webrtc::StatsReport* track_report = FindNthReportByType(
 498       reports, webrtc::StatsReport::kStatsReportTypeTrack, 1);
 499   EXPECT_FALSE(track_report == NULL);
 500
 501   stats.GetStats(track_, &reports);
 502   // |reports| should contain at least one session report, one track report,
 503   // and one ssrc report.
 504   EXPECT_LE((size_t)3, reports.size());
 505   track_report = FindNthReportByType(
 506       reports, webrtc::StatsReport::kStatsReportTypeTrack, 1);
 507   EXPECT_FALSE(track_report == NULL);
 508
 509   std::string ssrc_id = ExtractSsrcStatsValue(
 510       reports, webrtc::StatsReport::kStatsValueNameSsrc);
 511   EXPECT_EQ(talk_base::ToString<uint32>(kSsrcOfTrack), ssrc_id);
 512
 513   std::string track_id = ExtractSsrcStatsValue(
 514       reports, webrtc::StatsReport::kStatsValueNameTrackId);
 515   EXPECT_EQ(kTrackId, track_id);
 516 }
 517
 518 // This test verifies that an SSRC object has the identifier of a Transport
 519 // stats object, and that this transport stats object exists in stats.
 520 TEST_F(StatsCollectorTest, TransportObjectLinkedFromSsrcObject) {
 521   webrtc::StatsCollector stats;  // Implementation under test.
 522   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel;
 523   // The content_name known by the video channel.
 524   const std::string kVcName("vcname");
 525   cricket::VideoChannel video_channel(talk_base::Thread::Current(),
 526       media_engine_, media_channel, &session_, kVcName, false, NULL);
 527   AddVideoTrackStats();
 528   stats.AddStream(stream_);
 529
 530   stats.set_session(&session_);
 531
 532   webrtc::StatsReports reports;
 533
 534   // Constructs an ssrc stats update.
 535   cricket::VideoSenderInfo video_sender_info;
 536   cricket::VideoMediaInfo stats_read;
 537   const int64 kBytesSent = 12345678901234LL;
 538
 539   // Construct a stats value to read.
 540   video_sender_info.add_ssrc(1234);
 541   video_sender_info.bytes_sent = kBytesSent;
 542   stats_read.senders.push_back(video_sender_info);
 543
 544   EXPECT_CALL(session_, video_channel())
 545     .WillRepeatedly(Return(&video_channel));
 546   EXPECT_CALL(*media_channel, GetStats(_))
 547     .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),
 548                           Return(true)));
 549
 550   InitSessionStats(kVcName);
 551   EXPECT_CALL(session_, GetStats(_))
 552     .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
 553                           Return(true)));
 554
 555   stats.UpdateStats();
 556   stats.GetStats(NULL, &reports);
 557   std::string transport_id = ExtractStatsValue(
 558       webrtc::StatsReport::kStatsReportTypeSsrc,
 559       reports,
 560       webrtc::StatsReport::kStatsValueNameTransportId);
 561   ASSERT_NE(kNotFound, transport_id);
 562   const webrtc::StatsReport* transport_report = FindReportById(reports,
 563                                                                transport_id);
 564   ASSERT_FALSE(transport_report == NULL);
 565 }
 566
 567 // This test verifies that a remote stats object will not be created for
 568 // an outgoing SSRC where remote stats are not returned.
 569 TEST_F(StatsCollectorTest, RemoteSsrcInfoIsAbsent) {
 570   webrtc::StatsCollector stats;  // Implementation under test.
 571   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel;
 572   // The content_name known by the video channel.
 573   const std::string kVcName("vcname");
 574   cricket::VideoChannel video_channel(talk_base::Thread::Current(),
 575       media_engine_, media_channel, &session_, kVcName, false, NULL);
 576   AddVideoTrackStats();
 577   stats.AddStream(stream_);
 578
 579   stats.set_session(&session_);
 580
 581   EXPECT_CALL(session_, video_channel())
 582     .WillRepeatedly(ReturnNull());
 583
 584   stats.UpdateStats();
 585   webrtc::StatsReports reports;
 586   stats.GetStats(NULL, &reports);
 587   const webrtc::StatsReport* remote_report = FindNthReportByType(reports,
 588       webrtc::StatsReport::kStatsReportTypeRemoteSsrc, 1);
 589   EXPECT_TRUE(remote_report == NULL);
 590 }
 591
 592 // This test verifies that a remote stats object will be created for
 593 // an outgoing SSRC where stats are returned.
 594 TEST_F(StatsCollectorTest, RemoteSsrcInfoIsPresent) {
 595   webrtc::StatsCollector stats;  // Implementation under test.
 596   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel;
 597   // The content_name known by the video channel.
 598   const std::string kVcName("vcname");
 599   cricket::VideoChannel video_channel(talk_base::Thread::Current(),
 600       media_engine_, media_channel, &session_, kVcName, false, NULL);
 601   AddVideoTrackStats();
 602   stats.AddStream(stream_);
 603
 604   stats.set_session(&session_);
 605
 606   webrtc::StatsReports reports;
 607
 608   // Instruct the session to return stats containing the transport channel.
 609   InitSessionStats(kVcName);
 610   EXPECT_CALL(session_, GetStats(_))
 611     .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
 612                           Return(true)));
 613
 614   // Constructs an ssrc stats update.
 615   cricket::VideoMediaInfo stats_read;
 616
 617   cricket::SsrcReceiverInfo remote_ssrc_stats;
 618   remote_ssrc_stats.timestamp = 12345.678;
 619   remote_ssrc_stats.ssrc = kSsrcOfTrack;
 620   cricket::VideoSenderInfo video_sender_info;
 621   video_sender_info.add_ssrc(kSsrcOfTrack);
 622   video_sender_info.remote_stats.push_back(remote_ssrc_stats);
 623   stats_read.senders.push_back(video_sender_info);
 624
 625   EXPECT_CALL(session_, video_channel())
 626     .WillRepeatedly(Return(&video_channel));
 627   EXPECT_CALL(*media_channel, GetStats(_))
 628     .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),
 629                           Return(true)));
 630
 631   stats.UpdateStats();
 632   stats.GetStats(NULL, &reports);
 633   const webrtc::StatsReport* remote_report = FindNthReportByType(reports,
 634       webrtc::StatsReport::kStatsReportTypeRemoteSsrc, 1);
 635   EXPECT_FALSE(remote_report == NULL);
 636   EXPECT_NE(0, remote_report->timestamp);
 637 }
 638
 639 // This test verifies that all chained certificates are correctly
 640 // reported
 641 TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {
 642   // Build local certificate chain.
 643   std::vector<std::string> local_ders(5);
 644   local_ders[0] = "These";
 645   local_ders[1] = "are";
 646   local_ders[2] = "some";
 647   local_ders[3] = "der";
 648   local_ders[4] = "values";
 649   talk_base::FakeSSLCertificate local_cert(DersToPems(local_ders));
 650
 651   // Build remote certificate chain
 652   std::vector<std::string> remote_ders(4);
 653   remote_ders[0] = "A";
 654   remote_ders[1] = "non-";
 655   remote_ders[2] = "intersecting";
 656   remote_ders[3] = "set";
 657   talk_base::FakeSSLCertificate remote_cert(DersToPems(remote_ders));
 658
 659   TestCertificateReports(local_cert, local_ders, remote_cert, remote_ders);
 660 }
 661
 662 // This test verifies that all certificates without chains are correctly
 663 // reported.
 664 TEST_F(StatsCollectorTest, ChainlessCertificateReportsCreated) {
 665   // Build local certificate.
 666   std::string local_der = "This is the local der.";
 667   talk_base::FakeSSLCertificate local_cert(DerToPem(local_der));
 668
 669   // Build remote certificate.
 670   std::string remote_der = "This is somebody else's der.";
 671   talk_base::FakeSSLCertificate remote_cert(DerToPem(remote_der));
 672
 673   TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
 674                          remote_cert, std::vector<std::string>(1, remote_der));
 675 }
 676
 677 // This test verifies that the stats are generated correctly when no
 678 // transport is present.
 679 TEST_F(StatsCollectorTest, NoTransport) {
 680   webrtc::StatsCollector stats;  // Implementation under test.
 681   webrtc::StatsReports reports;  // returned values.
 682   stats.set_session(&session_);
 683
 684   // Fake stats to process.
 685   cricket::TransportChannelStats channel_stats;
 686   channel_stats.component = 1;
 687
 688   cricket::TransportStats transport_stats;
 689   transport_stats.content_name = "audio";
 690   transport_stats.channel_stats.push_back(channel_stats);
 691
 692   cricket::SessionStats session_stats;
 693   session_stats.transport_stats[transport_stats.content_name] =
 694       transport_stats;
 695
 696   // Configure MockWebRtcSession
 697   EXPECT_CALL(session_, GetTransport(transport_stats.content_name))
 698     .WillOnce(ReturnNull());
 699   EXPECT_CALL(session_, GetStats(_))
 700     .WillOnce(DoAll(SetArgPointee<0>(session_stats),
 701                     Return(true)));
 702
 703   EXPECT_CALL(session_, video_channel())
 704     .WillRepeatedly(ReturnNull());
 705
 706   stats.UpdateStats();
 707   stats.GetStats(NULL, &reports);
 708
 709   // Check that the local certificate is absent.
 710   std::string local_certificate_id = ExtractStatsValue(
 711       webrtc::StatsReport::kStatsReportTypeComponent,
 712       reports,
 713       webrtc::StatsReport::kStatsValueNameLocalCertificateId);
 714   ASSERT_EQ(kNotFound, local_certificate_id);
 715
 716   // Check that the remote certificate is absent.
 717   std::string remote_certificate_id = ExtractStatsValue(
 718       webrtc::StatsReport::kStatsReportTypeComponent,
 719       reports,
 720       webrtc::StatsReport::kStatsValueNameRemoteCertificateId);
 721   ASSERT_EQ(kNotFound, remote_certificate_id);
 722 }
 723
 724 // This test verifies that the stats are generated correctly when the transport
 725 // does not have any certificates.
 726 TEST_F(StatsCollectorTest, NoCertificates) {
 727   webrtc::StatsCollector stats;  // Implementation under test.
 728   webrtc::StatsReports reports;  // returned values.
 729   stats.set_session(&session_);
 730
 731   // Fake stats to process.
 732   cricket::TransportChannelStats channel_stats;
 733   channel_stats.component = 1;
 734
 735   cricket::TransportStats transport_stats;
 736   transport_stats.content_name = "audio";
 737   transport_stats.channel_stats.push_back(channel_stats);
 738
 739   cricket::SessionStats session_stats;
 740   session_stats.transport_stats[transport_stats.content_name] =
 741       transport_stats;
 742
 743   // Fake transport object.
 744   talk_base::scoped_ptr<cricket::FakeTransport> transport(
 745       new cricket::FakeTransport(
 746           session_.signaling_thread(),
 747           session_.worker_thread(),
 748           transport_stats.content_name));
 749
 750   // Configure MockWebRtcSession
 751   EXPECT_CALL(session_, GetTransport(transport_stats.content_name))
 752     .WillOnce(Return(transport.get()));
 753   EXPECT_CALL(session_, GetStats(_))
 754     .WillOnce(DoAll(SetArgPointee<0>(session_stats),
 755                     Return(true)));
 756   EXPECT_CALL(session_, video_channel())
 757     .WillRepeatedly(ReturnNull());
 758
 759   stats.UpdateStats();
 760   stats.GetStats(NULL, &reports);
 761
 762   // Check that the local certificate is absent.
 763   std::string local_certificate_id = ExtractStatsValue(
 764       webrtc::StatsReport::kStatsReportTypeComponent,
 765       reports,
 766       webrtc::StatsReport::kStatsValueNameLocalCertificateId);
 767   ASSERT_EQ(kNotFound, local_certificate_id);
 768
 769   // Check that the remote certificate is absent.
 770   std::string remote_certificate_id = ExtractStatsValue(
 771       webrtc::StatsReport::kStatsReportTypeComponent,
 772       reports,
 773       webrtc::StatsReport::kStatsValueNameRemoteCertificateId);
 774   ASSERT_EQ(kNotFound, remote_certificate_id);
 775 }
 776
 777 }  // namespace