keep_alive_delegate_unittest.cc 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270
  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. #include "components/cast_channel/keep_alive_delegate.h"
  5. #include <stdint.h>
  6. #include <memory>
  7. #include "base/json/json_writer.h"
  8. #include "base/memory/ptr_util.h"
  9. #include "base/memory/raw_ptr.h"
  10. #include "base/run_loop.h"
  11. #include "base/test/task_environment.h"
  12. #include "base/test/test_mock_time_task_runner.h"
  13. #include "base/time/tick_clock.h"
  14. #include "base/timer/mock_timer.h"
  15. #include "base/timer/timer.h"
  16. #include "base/values.h"
  17. #include "components/cast_channel/cast_test_util.h"
  18. #include "net/base/net_errors.h"
  19. #include "testing/gmock/include/gmock/gmock.h"
  20. #include "testing/gtest/include/gtest/gtest.h"
  21. using testing::_;
  22. using testing::Sequence;
  23. namespace cast_channel {
  24. namespace {
  25. const int64_t kTestPingTimeoutMillis = 1000;
  26. const int64_t kTestLivenessTimeoutMillis = 10000;
  27. CastMessage CreateNonKeepAliveMessage(const std::string& message_type) {
  28. CastMessage output;
  29. output.set_protocol_version(CastMessage::CASTV2_1_0);
  30. output.set_source_id("source");
  31. output.set_destination_id("receiver");
  32. output.set_namespace_("some.namespace");
  33. output.set_payload_type(
  34. CastMessage::PayloadType::CastMessage_PayloadType_STRING);
  35. base::DictionaryValue type_dict;
  36. type_dict.SetString("type", message_type);
  37. CHECK(base::JSONWriter::Write(type_dict, output.mutable_payload_utf8()));
  38. return output;
  39. }
  40. // Extends MockTimer with a mockable method ResetTriggered() which permits
  41. // test code to set GMock expectations for Timer::Reset().
  42. class MockTimerWithMonitoredReset : public base::MockRetainingOneShotTimer {
  43. public:
  44. MockTimerWithMonitoredReset() {}
  45. ~MockTimerWithMonitoredReset() override {}
  46. // Instrumentation point for determining how many times Reset() was called.
  47. MOCK_METHOD0(ResetTriggered, void(void));
  48. MOCK_METHOD0(StopTriggered, void(void));
  49. // Passes through the Reset call to the base MockTimer and visits the mock
  50. // ResetTriggered method.
  51. void Reset() override {
  52. base::MockRetainingOneShotTimer::Reset();
  53. ResetTriggered();
  54. }
  55. void Stop() override {
  56. base::MockRetainingOneShotTimer::Stop();
  57. StopTriggered();
  58. }
  59. };
  60. class KeepAliveDelegateTest : public testing::Test {
  61. public:
  62. using ChannelError = ::cast_channel::ChannelError;
  63. KeepAliveDelegateTest() {}
  64. KeepAliveDelegateTest(const KeepAliveDelegateTest&) = delete;
  65. KeepAliveDelegateTest& operator=(const KeepAliveDelegateTest&) = delete;
  66. ~KeepAliveDelegateTest() override {}
  67. protected:
  68. void SetUp() override {
  69. inner_delegate_ = new MockCastTransportDelegate;
  70. logger_ = new Logger();
  71. keep_alive_ = std::make_unique<KeepAliveDelegate>(
  72. &socket_, logger_, base::WrapUnique(inner_delegate_.get()),
  73. base::Milliseconds(kTestPingTimeoutMillis),
  74. base::Milliseconds(kTestLivenessTimeoutMillis));
  75. liveness_timer_ = new MockTimerWithMonitoredReset;
  76. ping_timer_ = new MockTimerWithMonitoredReset;
  77. EXPECT_CALL(*liveness_timer_, StopTriggered()).Times(0);
  78. EXPECT_CALL(*ping_timer_, StopTriggered()).Times(0);
  79. keep_alive_->SetTimersForTest(base::WrapUnique(ping_timer_.get()),
  80. base::WrapUnique(liveness_timer_.get()));
  81. }
  82. // Runs all pending tasks in the message loop.
  83. void RunPendingTasks() {
  84. base::RunLoop run_loop;
  85. run_loop.RunUntilIdle();
  86. }
  87. base::test::SingleThreadTaskEnvironment task_environment_;
  88. MockCastSocket socket_;
  89. std::unique_ptr<KeepAliveDelegate> keep_alive_;
  90. scoped_refptr<Logger> logger_;
  91. raw_ptr<MockCastTransportDelegate> inner_delegate_;
  92. raw_ptr<MockTimerWithMonitoredReset> liveness_timer_;
  93. raw_ptr<MockTimerWithMonitoredReset> ping_timer_;
  94. };
  95. TEST_F(KeepAliveDelegateTest, TestErrorHandledBeforeStarting) {
  96. EXPECT_CALL(*inner_delegate_, OnError(ChannelError::CONNECT_ERROR));
  97. keep_alive_->OnError(ChannelError::CONNECT_ERROR);
  98. }
  99. TEST_F(KeepAliveDelegateTest, TestPing) {
  100. EXPECT_CALL(*socket_.mock_transport(),
  101. SendMessage_(EqualsProto(CreateKeepAlivePingMessage()), _))
  102. .WillOnce(PostCompletionCallbackTask<1>(net::OK));
  103. EXPECT_CALL(*inner_delegate_, Start());
  104. EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(2);
  105. EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(3);
  106. EXPECT_CALL(*ping_timer_, StopTriggered());
  107. keep_alive_->Start();
  108. ping_timer_->Fire();
  109. EXPECT_FALSE(ping_timer_->IsRunning());
  110. keep_alive_->OnMessage(CreateKeepAlivePongMessage());
  111. RunPendingTasks();
  112. EXPECT_TRUE(ping_timer_->IsRunning());
  113. }
  114. TEST_F(KeepAliveDelegateTest, TestPingFailed) {
  115. EXPECT_CALL(*socket_.mock_transport(),
  116. SendMessage_(EqualsProto(CreateKeepAlivePingMessage()), _))
  117. .WillOnce(PostCompletionCallbackTask<1>(net::ERR_CONNECTION_RESET));
  118. EXPECT_CALL(*inner_delegate_, Start());
  119. EXPECT_CALL(*inner_delegate_, OnError(ChannelError::CAST_SOCKET_ERROR));
  120. EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(1);
  121. EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(1);
  122. EXPECT_CALL(*liveness_timer_, StopTriggered());
  123. EXPECT_CALL(*ping_timer_, StopTriggered()).Times(2);
  124. keep_alive_->Start();
  125. ping_timer_->Fire();
  126. RunPendingTasks();
  127. EXPECT_EQ(ChannelEvent::PING_WRITE_ERROR,
  128. logger_->GetLastError(socket_.id()).channel_event);
  129. EXPECT_EQ(net::ERR_CONNECTION_RESET,
  130. logger_->GetLastError(socket_.id()).net_return_value);
  131. }
  132. TEST_F(KeepAliveDelegateTest, TestPingAndLivenessTimeout) {
  133. EXPECT_CALL(*socket_.mock_transport(),
  134. SendMessage_(EqualsProto(CreateKeepAlivePingMessage()), _))
  135. .WillOnce(PostCompletionCallbackTask<1>(net::OK));
  136. EXPECT_CALL(*inner_delegate_, OnError(ChannelError::PING_TIMEOUT));
  137. EXPECT_CALL(*inner_delegate_, Start());
  138. EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(1);
  139. EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(2);
  140. EXPECT_CALL(*liveness_timer_, StopTriggered()).Times(2);
  141. EXPECT_CALL(*ping_timer_, StopTriggered()).Times(2);
  142. keep_alive_->Start();
  143. ping_timer_->Fire();
  144. liveness_timer_->Fire();
  145. RunPendingTasks();
  146. }
  147. TEST_F(KeepAliveDelegateTest, TestResetTimersAndPassthroughAllOtherTraffic) {
  148. CastMessage other_message = CreateNonKeepAliveMessage("someMessageType");
  149. EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(other_message)));
  150. EXPECT_CALL(*inner_delegate_, Start());
  151. EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(2);
  152. EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(2);
  153. keep_alive_->Start();
  154. keep_alive_->OnMessage(other_message);
  155. RunPendingTasks();
  156. }
  157. TEST_F(KeepAliveDelegateTest, TestPassthroughMessagesAfterError) {
  158. CastMessage message = CreateNonKeepAliveMessage("someMessageType");
  159. CastMessage message_after_error =
  160. CreateNonKeepAliveMessage("someMessageType2");
  161. CastMessage late_ping_message = CreateKeepAlivePingMessage();
  162. EXPECT_CALL(*inner_delegate_, Start()).Times(1);
  163. EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(2);
  164. EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(2);
  165. EXPECT_CALL(*liveness_timer_, StopTriggered()).Times(1);
  166. EXPECT_CALL(*ping_timer_, StopTriggered()).Times(1);
  167. Sequence message_and_error_sequence;
  168. EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(message)))
  169. .Times(1)
  170. .InSequence(message_and_error_sequence)
  171. .RetiresOnSaturation();
  172. EXPECT_CALL(*inner_delegate_, OnError(ChannelError::INVALID_MESSAGE))
  173. .Times(1)
  174. .InSequence(message_and_error_sequence);
  175. EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(message_after_error)))
  176. .Times(1)
  177. .InSequence(message_and_error_sequence)
  178. .RetiresOnSaturation();
  179. EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(late_ping_message)))
  180. .Times(0)
  181. .InSequence(message_and_error_sequence)
  182. .RetiresOnSaturation();
  183. // Start, process one message, then error-out. KeepAliveDelegate will
  184. // automatically stop itself.
  185. keep_alive_->Start();
  186. keep_alive_->OnMessage(message);
  187. RunPendingTasks();
  188. keep_alive_->OnError(ChannelError::INVALID_MESSAGE);
  189. RunPendingTasks();
  190. // Process a non-PING/PONG message and expect it to pass through.
  191. keep_alive_->OnMessage(message_after_error);
  192. RunPendingTasks();
  193. // Process a late-arriving PING/PONG message, which should have no effect.
  194. keep_alive_->OnMessage(late_ping_message);
  195. RunPendingTasks();
  196. }
  197. TEST_F(KeepAliveDelegateTest, TestLivenessTimerResetAfterSendingMessage) {
  198. scoped_refptr<base::TestMockTimeTaskRunner> mock_time_task_runner(
  199. new base::TestMockTimeTaskRunner());
  200. auto liveness_timer = std::make_unique<base::RetainingOneShotTimer>(
  201. mock_time_task_runner->GetMockTickClock());
  202. auto ping_timer = std::make_unique<base::RetainingOneShotTimer>(
  203. mock_time_task_runner->GetMockTickClock());
  204. ping_timer->SetTaskRunner(mock_time_task_runner);
  205. liveness_timer->SetTaskRunner(mock_time_task_runner);
  206. keep_alive_->SetTimersForTest(std::move(ping_timer),
  207. std::move(liveness_timer));
  208. // At time 0, start.
  209. EXPECT_CALL(*inner_delegate_, Start());
  210. keep_alive_->Start();
  211. EXPECT_CALL(*socket_.mock_transport(),
  212. SendMessage_(EqualsProto(CreateKeepAlivePingMessage()), _))
  213. .WillOnce(PostCompletionCallbackTask<1>(net::OK));
  214. // Forward 1s, at time 1, fire ping timer.
  215. mock_time_task_runner->FastForwardBy(
  216. base::Milliseconds(kTestPingTimeoutMillis));
  217. // Forward 9s, at Time 10, do not fire liveness timer.
  218. EXPECT_CALL(*inner_delegate_, OnError(_)).Times(0);
  219. mock_time_task_runner->FastForwardBy(
  220. base::Milliseconds(kTestLivenessTimeoutMillis - kTestPingTimeoutMillis));
  221. // Forward 1s, at time 11s, fire liveness timer.
  222. EXPECT_CALL(*inner_delegate_, OnError(_));
  223. mock_time_task_runner->FastForwardBy(
  224. base::Milliseconds(kTestPingTimeoutMillis));
  225. }
  226. } // namespace
  227. } // namespace cast_channel