OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
| 5 #include "remoting/host/heartbeat_sender.h" |
| 6 |
5 #include "base/memory/ref_counted.h" | 7 #include "base/memory/ref_counted.h" |
6 #include "base/message_loop.h" | 8 #include "base/message_loop.h" |
7 #include "base/message_loop_proxy.h" | 9 #include "base/message_loop_proxy.h" |
8 #include "base/string_number_conversions.h" | 10 #include "base/string_number_conversions.h" |
9 #include "remoting/base/constants.h" | 11 #include "remoting/base/constants.h" |
10 #include "remoting/host/heartbeat_sender.h" | |
11 #include "remoting/host/host_key_pair.h" | 12 #include "remoting/host/host_key_pair.h" |
12 #include "remoting/host/in_memory_host_config.h" | 13 #include "remoting/host/in_memory_host_config.h" |
13 #include "remoting/host/test_key_pair.h" | 14 #include "remoting/host/test_key_pair.h" |
14 #include "remoting/jingle_glue/iq_request.h" | 15 #include "remoting/jingle_glue/iq_sender.h" |
15 #include "remoting/jingle_glue/mock_objects.h" | 16 #include "remoting/jingle_glue/mock_objects.h" |
16 #include "testing/gmock/include/gmock/gmock.h" | 17 #include "testing/gmock/include/gmock/gmock.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
18 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h" | 19 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h" |
19 #include "third_party/libjingle/source/talk/xmpp/constants.h" | 20 #include "third_party/libjingle/source/talk/xmpp/constants.h" |
20 | 21 |
21 using buzz::QName; | 22 using buzz::QName; |
22 using buzz::XmlElement; | 23 using buzz::XmlElement; |
23 | 24 |
24 using testing::_; | 25 using testing::_; |
25 using testing::DeleteArg; | 26 using testing::DeleteArg; |
26 using testing::DoAll; | 27 using testing::DoAll; |
27 using testing::Invoke; | 28 using testing::Invoke; |
28 using testing::NotNull; | 29 using testing::NotNull; |
29 using testing::Return; | 30 using testing::Return; |
30 using testing::SaveArg; | 31 using testing::SaveArg; |
31 | 32 |
32 namespace remoting { | 33 namespace remoting { |
33 | 34 |
34 namespace { | 35 namespace { |
35 const char kHostId[] = "0"; | 36 const char kHostId[] = "0"; |
36 const char kTestJid[] = "user@gmail.com/chromoting123"; | 37 const char kTestJid[] = "user@gmail.com/chromoting123"; |
37 const int64 kTestTime = 123123123; | 38 const int64 kTestTime = 123123123; |
| 39 const char kStanzaId[] = "123"; |
38 } // namespace | 40 } // namespace |
39 | 41 |
40 class HeartbeatSenderTest : public testing::Test { | 42 class HeartbeatSenderTest : public testing::Test { |
41 protected: | 43 protected: |
42 virtual void SetUp() { | 44 virtual void SetUp() { |
43 config_ = new InMemoryHostConfig(); | 45 config_ = new InMemoryHostConfig(); |
44 config_->SetString(kHostIdConfigPath, kHostId); | 46 config_->SetString(kHostIdConfigPath, kHostId); |
45 config_->SetString(kPrivateKeyConfigPath, kTestHostKeyPair); | 47 config_->SetString(kPrivateKeyConfigPath, kTestHostKeyPair); |
46 } | 48 } |
47 | 49 |
48 MockSignalStrategy signal_strategy_; | 50 MockSignalStrategy signal_strategy_; |
49 MessageLoop message_loop_; | 51 MessageLoop message_loop_; |
50 scoped_refptr<InMemoryHostConfig> config_; | 52 scoped_refptr<InMemoryHostConfig> config_; |
51 }; | 53 }; |
52 | 54 |
53 // Call Start() followed by Stop(), and makes sure an Iq stanza is | 55 // Call Start() followed by Stop(), and makes sure an Iq stanza is |
54 // being sent. | 56 // being sent. |
55 TEST_F(HeartbeatSenderTest, DoSendStanza) { | 57 TEST_F(HeartbeatSenderTest, DoSendStanza) { |
56 // |iq_request| is freed by HeartbeatSender. | 58 SignalStrategy::Listener* listener; |
57 MockIqRequest* iq_request = new MockIqRequest(); | 59 EXPECT_CALL(signal_strategy_, AddListener(NotNull())) |
58 iq_request->Init(); | 60 .WillOnce(SaveArg<0>(&listener)); |
59 | |
60 EXPECT_CALL(*iq_request, set_callback(_)).Times(1); | |
61 | 61 |
62 scoped_ptr<HeartbeatSender> heartbeat_sender( | 62 scoped_ptr<HeartbeatSender> heartbeat_sender( |
63 new HeartbeatSender(base::MessageLoopProxy::current(), | 63 new HeartbeatSender(base::MessageLoopProxy::current(), config_)); |
64 config_)); | |
65 ASSERT_TRUE(heartbeat_sender->Init()); | 64 ASSERT_TRUE(heartbeat_sender->Init()); |
66 | 65 |
67 EXPECT_CALL(signal_strategy_, CreateIqRequest()) | |
68 .WillOnce(Return(iq_request)); | |
69 | |
70 XmlElement* sent_iq = NULL; | 66 XmlElement* sent_iq = NULL; |
71 EXPECT_CALL(*iq_request, SendIq(NotNull())) | 67 EXPECT_CALL(signal_strategy_, GetNextId()) |
72 .WillOnce(SaveArg<0>(&sent_iq)); | 68 .WillOnce(Return(kStanzaId)); |
| 69 EXPECT_CALL(signal_strategy_, SendStanza(NotNull())) |
| 70 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
73 | 71 |
74 heartbeat_sender->OnSignallingConnected(&signal_strategy_, kTestJid); | 72 heartbeat_sender->OnSignallingConnected(&signal_strategy_, kTestJid); |
75 message_loop_.RunAllPending(); | 73 message_loop_.RunAllPending(); |
76 | 74 |
77 scoped_ptr<XmlElement> stanza(sent_iq); | 75 scoped_ptr<XmlElement> stanza(sent_iq); |
78 ASSERT_TRUE(stanza != NULL); | 76 ASSERT_TRUE(stanza != NULL); |
79 | 77 |
80 EXPECT_EQ(stanza->Attr(buzz::QName("", "to")), | 78 EXPECT_EQ(stanza->Attr(buzz::QName("", "to")), |
81 std::string(kChromotingBotJid)); | 79 std::string(kChromotingBotJid)); |
82 EXPECT_EQ(stanza->Attr(buzz::QName("", "type")), "set"); | 80 EXPECT_EQ(stanza->Attr(buzz::QName("", "type")), "set"); |
83 | 81 |
| 82 EXPECT_CALL(signal_strategy_, RemoveListener(listener)); |
| 83 |
84 heartbeat_sender->OnSignallingDisconnected(); | 84 heartbeat_sender->OnSignallingDisconnected(); |
85 message_loop_.RunAllPending(); | 85 message_loop_.RunAllPending(); |
86 } | 86 } |
87 | 87 |
88 // Validate format of the heartbeat stanza. | 88 // Validate format of the heartbeat stanza. |
89 TEST_F(HeartbeatSenderTest, CreateHeartbeatMessage) { | 89 TEST_F(HeartbeatSenderTest, CreateHeartbeatMessage) { |
90 scoped_ptr<HeartbeatSender> heartbeat_sender( | 90 scoped_ptr<HeartbeatSender> heartbeat_sender( |
91 new HeartbeatSender(base::MessageLoopProxy::current(), | 91 new HeartbeatSender(base::MessageLoopProxy::current(), |
92 config_)); | 92 config_)); |
93 ASSERT_TRUE(heartbeat_sender->Init()); | 93 ASSERT_TRUE(heartbeat_sender->Init()); |
(...skipping 24 matching lines...) Expand all Loading... |
118 | 118 |
119 HostKeyPair key_pair; | 119 HostKeyPair key_pair; |
120 key_pair.LoadFromString(kTestHostKeyPair); | 120 key_pair.LoadFromString(kTestHostKeyPair); |
121 std::string expected_signature = | 121 std::string expected_signature = |
122 key_pair.GetSignature(std::string(kTestJid) + ' ' + time_str); | 122 key_pair.GetSignature(std::string(kTestJid) + ' ' + time_str); |
123 EXPECT_EQ(expected_signature, signature->BodyText()); | 123 EXPECT_EQ(expected_signature, signature->BodyText()); |
124 } | 124 } |
125 | 125 |
126 // Verify that ProcessResponse parses set-interval result. | 126 // Verify that ProcessResponse parses set-interval result. |
127 TEST_F(HeartbeatSenderTest, ProcessResponse) { | 127 TEST_F(HeartbeatSenderTest, ProcessResponse) { |
128 scoped_ptr<XmlElement> response(new XmlElement(QName("", "iq"))); | 128 scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ)); |
129 response->AddAttr(QName("", "type"), "result"); | 129 response->AddAttr(QName("", "type"), "result"); |
130 | 130 |
131 XmlElement* result = new XmlElement( | 131 XmlElement* result = new XmlElement( |
132 QName(kChromotingXmlNamespace, "heartbeat-result")); | 132 QName(kChromotingXmlNamespace, "heartbeat-result")); |
133 response->AddElement(result); | 133 response->AddElement(result); |
134 | 134 |
135 XmlElement* set_interval = new XmlElement( | 135 XmlElement* set_interval = new XmlElement( |
136 QName(kChromotingXmlNamespace, "set-interval")); | 136 QName(kChromotingXmlNamespace, "set-interval")); |
137 result->AddElement(set_interval); | 137 result->AddElement(set_interval); |
138 | 138 |
139 const int kTestInterval = 123; | 139 const int kTestInterval = 123; |
140 set_interval->AddText(base::IntToString(kTestInterval)); | 140 set_interval->AddText(base::IntToString(kTestInterval)); |
141 | 141 |
142 scoped_ptr<HeartbeatSender> heartbeat_sender( | 142 scoped_ptr<HeartbeatSender> heartbeat_sender( |
143 new HeartbeatSender(base::MessageLoopProxy::current(), | 143 new HeartbeatSender(base::MessageLoopProxy::current(), |
144 config_)); | 144 config_)); |
145 heartbeat_sender->ProcessResponse(response.get()); | 145 heartbeat_sender->ProcessResponse(response.get()); |
146 | 146 |
147 EXPECT_EQ(kTestInterval * 1000, heartbeat_sender->interval_ms_); | 147 EXPECT_EQ(kTestInterval * 1000, heartbeat_sender->interval_ms_); |
148 } | 148 } |
149 | 149 |
150 } // namespace remoting | 150 } // namespace remoting |
OLD | NEW |