extensions/browser/api/cast_channel/keep_alive_delegate_unittest.cc

   1 // Copyright 2015 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
   5 #include "extensions/browser/api/cast_channel/keep_alive_delegate.h"
   6
   7 #include "base/timer/mock_timer.h"
   8 #include "extensions/browser/api/cast_channel/test_util.h"
   9 #include "net/base/net_errors.h"
  10 #include "testing/gmock/include/gmock/gmock.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 using testing::_;
  14
  15 namespace extensions {
  16 namespace core_api {
  17 namespace cast_channel {
  18 namespace {
  19
  20 const int64 kTestPingTimeoutMillis = 1000;
  21 const int64 kTestLivenessTimeoutMillis = 10000;
  22
  23 // Extends MockTimer with a mockable method ResetTriggered() which permits
  24 // test code to set GMock expectations for Timer::Reset().
  25 class MockTimerWithMonitoredReset : public base::MockTimer {
  26  public:
  27   MockTimerWithMonitoredReset(bool retain_user_task, bool is_repeating)
  28       : base::MockTimer(retain_user_task, is_repeating) {}
  29   ~MockTimerWithMonitoredReset() override {}
  30
  31   // Instrumentation point for determining how many times Reset() was called.
  32   MOCK_METHOD0(ResetTriggered, void(void));
  33
  34   // Passes through the Reset call to the base MockTimer and visits the mock
  35   // ResetTriggered method.
  36   void Reset() override {
  37     base::MockTimer::Reset();
  38     ResetTriggered();
  39   }
  40 };
  41
  42 class KeepAliveDelegateTest : public testing::Test {
  43  public:
  44   KeepAliveDelegateTest() {}
  45   ~KeepAliveDelegateTest() override {}
  46
  47  protected:
  48   void SetUp() override {
  49     inner_delegate_ = new MockCastTransportDelegate;
  50     keep_alive_.reset(new KeepAliveDelegate(
  51         &socket_, make_scoped_ptr(inner_delegate_),
  52         base::TimeDelta::FromMilliseconds(kTestPingTimeoutMillis),
  53         base::TimeDelta::FromMilliseconds(kTestLivenessTimeoutMillis)));
  54     liveness_timer_ = new MockTimerWithMonitoredReset(true, false);
  55     ping_timer_ = new MockTimerWithMonitoredReset(true, false);
  56     keep_alive_->SetTimersForTest(make_scoped_ptr(ping_timer_),
  57                                   make_scoped_ptr(liveness_timer_));
  58   }
  59
  60   MockCastSocket socket_;
  61   scoped_ptr<KeepAliveDelegate> keep_alive_;
  62   MockCastTransportDelegate* inner_delegate_;
  63   MockTimerWithMonitoredReset* liveness_timer_;
  64   MockTimerWithMonitoredReset* ping_timer_;
  65
  66   DISALLOW_COPY_AND_ASSIGN(KeepAliveDelegateTest);
  67 };
  68
  69 TEST_F(KeepAliveDelegateTest, TestPing) {
  70   EXPECT_CALL(*socket_.mock_transport(),
  71               SendMessage(EqualsProto(KeepAliveDelegate::CreateKeepAliveMessage(
  72                               KeepAliveDelegate::kHeartbeatPingType)),
  73                           _)).WillOnce(RunCompletionCallback<1>(net::OK));
  74   EXPECT_CALL(*inner_delegate_, Start());
  75   EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(2);
  76   EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(2);
  77
  78   keep_alive_->Start();
  79   ping_timer_->Fire();
  80   keep_alive_->OnMessage(KeepAliveDelegate::CreateKeepAliveMessage(
  81       KeepAliveDelegate::kHeartbeatPongType));
  82 }
  83
  84 TEST_F(KeepAliveDelegateTest, TestPingFailed) {
  85   EXPECT_CALL(*socket_.mock_transport(),
  86               SendMessage(EqualsProto(KeepAliveDelegate::CreateKeepAliveMessage(
  87                               KeepAliveDelegate::kHeartbeatPingType)),
  88                           _))
  89       .WillOnce(RunCompletionCallback<1>(net::ERR_CONNECTION_RESET));
  90   EXPECT_CALL(*inner_delegate_, Start());
  91   EXPECT_CALL(*inner_delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR, _));
  92   EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(1);
  93   EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(1);
  94
  95   keep_alive_->Start();
  96   ping_timer_->Fire();
  97 }
  98
  99 TEST_F(KeepAliveDelegateTest, TestPingAndLivenessTimeout) {
 100   EXPECT_CALL(*socket_.mock_transport(),
 101               SendMessage(EqualsProto(KeepAliveDelegate::CreateKeepAliveMessage(
 102                               KeepAliveDelegate::kHeartbeatPingType)),
 103                           _)).WillOnce(RunCompletionCallback<1>(net::OK));
 104   EXPECT_CALL(*inner_delegate_, OnError(CHANNEL_ERROR_PING_TIMEOUT, _));
 105   EXPECT_CALL(*inner_delegate_, Start());
 106   EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(1);
 107   EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(1);
 108
 109   keep_alive_->Start();
 110   ping_timer_->Fire();
 111   liveness_timer_->Fire();
 112 }
 113
 114 TEST_F(KeepAliveDelegateTest, TestResetTimersAndPassthroughAllOtherTraffic) {
 115   CastMessage other_message =
 116       KeepAliveDelegate::CreateKeepAliveMessage("NEITHER_PING_NOR_PONG");
 117
 118   EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(other_message)));
 119   EXPECT_CALL(*inner_delegate_, Start());
 120   EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(2);
 121   EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(2);
 122
 123   keep_alive_->Start();
 124   keep_alive_->OnMessage(other_message);
 125 }
 126
 127 }  // namespace
 128 }  // namespace cast_channel
 129 }  // namespace core_api
 130 }  // namespace extensions