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" | 5 #include "remoting/host/heartbeat_sender.h" |
6 | 6 |
| 7 #include <set> |
| 8 |
7 #include "base/memory/ref_counted.h" | 9 #include "base/memory/ref_counted.h" |
8 #include "base/message_loop.h" | 10 #include "base/message_loop.h" |
9 #include "base/message_loop_proxy.h" | 11 #include "base/message_loop_proxy.h" |
10 #include "base/string_number_conversions.h" | 12 #include "base/string_number_conversions.h" |
11 #include "remoting/base/constants.h" | 13 #include "remoting/base/constants.h" |
12 #include "remoting/host/host_key_pair.h" | 14 #include "remoting/host/host_key_pair.h" |
13 #include "remoting/host/in_memory_host_config.h" | 15 #include "remoting/host/in_memory_host_config.h" |
14 #include "remoting/host/test_key_pair.h" | 16 #include "remoting/host/test_key_pair.h" |
15 #include "remoting/jingle_glue/iq_sender.h" | 17 #include "remoting/jingle_glue/iq_sender.h" |
16 #include "remoting/jingle_glue/mock_objects.h" | 18 #include "remoting/jingle_glue/mock_objects.h" |
(...skipping 15 matching lines...) Expand all Loading... |
32 | 34 |
33 namespace remoting { | 35 namespace remoting { |
34 | 36 |
35 namespace { | 37 namespace { |
36 const char kHostId[] = "0"; | 38 const char kHostId[] = "0"; |
37 const char kTestJid[] = "user@gmail.com/chromoting123"; | 39 const char kTestJid[] = "user@gmail.com/chromoting123"; |
38 const int64 kTestTime = 123123123; | 40 const int64 kTestTime = 123123123; |
39 const char kStanzaId[] = "123"; | 41 const char kStanzaId[] = "123"; |
40 } // namespace | 42 } // namespace |
41 | 43 |
| 44 ACTION_P(AddListener, list) { |
| 45 list->insert(arg0); |
| 46 } |
| 47 ACTION_P(RemoveListener, list) { |
| 48 EXPECT_TRUE(list->find(arg0) != list->end()); |
| 49 list->erase(arg0); |
| 50 } |
| 51 |
42 class HeartbeatSenderTest : public testing::Test { | 52 class HeartbeatSenderTest : public testing::Test { |
43 protected: | 53 protected: |
44 virtual void SetUp() { | 54 virtual void SetUp() OVERRIDE { |
45 config_ = new InMemoryHostConfig(); | 55 config_ = new InMemoryHostConfig(); |
46 config_->SetString(kHostIdConfigPath, kHostId); | 56 config_->SetString(kHostIdConfigPath, kHostId); |
47 config_->SetString(kPrivateKeyConfigPath, kTestHostKeyPair); | 57 config_->SetString(kPrivateKeyConfigPath, kTestHostKeyPair); |
| 58 |
| 59 EXPECT_CALL(signal_strategy_, AddListener(NotNull())) |
| 60 .WillRepeatedly(AddListener(&signal_strategy_listeners_)); |
| 61 EXPECT_CALL(signal_strategy_, RemoveListener(NotNull())) |
| 62 .WillRepeatedly(RemoveListener(&signal_strategy_listeners_)); |
| 63 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
| 64 .WillRepeatedly(Return(kTestJid)); |
| 65 |
| 66 heartbeat_sender_.reset(new HeartbeatSender()); |
| 67 ASSERT_TRUE(heartbeat_sender_->Init(&signal_strategy_, config_)); |
48 } | 68 } |
49 | 69 |
| 70 virtual void TearDown() OVERRIDE { |
| 71 heartbeat_sender_.reset(); |
| 72 EXPECT_TRUE(signal_strategy_listeners_.empty()); |
| 73 } |
| 74 |
| 75 MessageLoop message_loop_; |
50 MockSignalStrategy signal_strategy_; | 76 MockSignalStrategy signal_strategy_; |
51 MessageLoop message_loop_; | 77 std::set<SignalStrategy::Listener*> signal_strategy_listeners_; |
52 scoped_refptr<InMemoryHostConfig> config_; | 78 scoped_refptr<InMemoryHostConfig> config_; |
| 79 scoped_ptr<HeartbeatSender> heartbeat_sender_; |
53 }; | 80 }; |
54 | 81 |
55 // Call Start() followed by Stop(), and makes sure an Iq stanza is | 82 // Call Start() followed by Stop(), and makes sure an Iq stanza is |
56 // being sent. | 83 // being sent. |
57 TEST_F(HeartbeatSenderTest, DoSendStanza) { | 84 TEST_F(HeartbeatSenderTest, DoSendStanza) { |
58 SignalStrategy::Listener* listener; | |
59 EXPECT_CALL(signal_strategy_, AddListener(NotNull())) | |
60 .WillOnce(SaveArg<0>(&listener)); | |
61 | |
62 scoped_ptr<HeartbeatSender> heartbeat_sender( | |
63 new HeartbeatSender(base::MessageLoopProxy::current(), config_)); | |
64 ASSERT_TRUE(heartbeat_sender->Init()); | |
65 | |
66 XmlElement* sent_iq = NULL; | 85 XmlElement* sent_iq = NULL; |
67 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 86 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
68 .WillRepeatedly(Return(kTestJid)); | 87 .WillRepeatedly(Return(kTestJid)); |
69 EXPECT_CALL(signal_strategy_, GetNextId()) | 88 EXPECT_CALL(signal_strategy_, GetNextId()) |
70 .WillOnce(Return(kStanzaId)); | 89 .WillOnce(Return(kStanzaId)); |
71 EXPECT_CALL(signal_strategy_, SendStanza(NotNull())) | 90 EXPECT_CALL(signal_strategy_, SendStanza(NotNull())) |
72 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 91 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
73 | 92 |
74 heartbeat_sender->OnSignallingConnected(&signal_strategy_); | 93 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
75 message_loop_.RunAllPending(); | 94 message_loop_.RunAllPending(); |
76 | 95 |
77 scoped_ptr<XmlElement> stanza(sent_iq); | 96 scoped_ptr<XmlElement> stanza(sent_iq); |
78 ASSERT_TRUE(stanza != NULL); | 97 ASSERT_TRUE(stanza != NULL); |
79 | 98 |
80 EXPECT_EQ(stanza->Attr(buzz::QName("", "to")), | 99 EXPECT_EQ(stanza->Attr(buzz::QName("", "to")), |
81 std::string(kChromotingBotJid)); | 100 std::string(kChromotingBotJid)); |
82 EXPECT_EQ(stanza->Attr(buzz::QName("", "type")), "set"); | 101 EXPECT_EQ(stanza->Attr(buzz::QName("", "type")), "set"); |
83 | 102 |
84 EXPECT_CALL(signal_strategy_, RemoveListener(listener)); | 103 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
85 | |
86 heartbeat_sender->OnSignallingDisconnected(); | |
87 message_loop_.RunAllPending(); | 104 message_loop_.RunAllPending(); |
88 } | 105 } |
89 | 106 |
90 // Validate format of the heartbeat stanza. | 107 // Validate format of the heartbeat stanza. |
91 TEST_F(HeartbeatSenderTest, CreateHeartbeatMessage) { | 108 TEST_F(HeartbeatSenderTest, CreateHeartbeatMessage) { |
92 scoped_ptr<HeartbeatSender> heartbeat_sender( | |
93 new HeartbeatSender(base::MessageLoopProxy::current(), | |
94 config_)); | |
95 ASSERT_TRUE(heartbeat_sender->Init()); | |
96 | |
97 int64 start_time = static_cast<int64>(base::Time::Now().ToDoubleT()); | 109 int64 start_time = static_cast<int64>(base::Time::Now().ToDoubleT()); |
98 | 110 |
99 heartbeat_sender->full_jid_ = kTestJid; | 111 scoped_ptr<XmlElement> stanza(heartbeat_sender_->CreateHeartbeatMessage()); |
100 scoped_ptr<XmlElement> stanza(heartbeat_sender->CreateHeartbeatMessage()); | |
101 ASSERT_TRUE(stanza.get() != NULL); | 112 ASSERT_TRUE(stanza.get() != NULL); |
102 | 113 |
103 EXPECT_TRUE(QName(kChromotingXmlNamespace, "heartbeat") == | 114 EXPECT_TRUE(QName(kChromotingXmlNamespace, "heartbeat") == |
104 stanza->Name()); | 115 stanza->Name()); |
105 EXPECT_EQ(std::string(kHostId), | 116 EXPECT_EQ(std::string(kHostId), |
106 stanza->Attr(QName(kChromotingXmlNamespace, "hostid"))); | 117 stanza->Attr(QName(kChromotingXmlNamespace, "hostid"))); |
107 | 118 |
108 QName signature_tag(kChromotingXmlNamespace, "signature"); | 119 QName signature_tag(kChromotingXmlNamespace, "signature"); |
109 XmlElement* signature = stanza->FirstNamed(signature_tag); | 120 XmlElement* signature = stanza->FirstNamed(signature_tag); |
110 ASSERT_TRUE(signature != NULL); | 121 ASSERT_TRUE(signature != NULL); |
(...skipping 23 matching lines...) Expand all Loading... |
134 QName(kChromotingXmlNamespace, "heartbeat-result")); | 145 QName(kChromotingXmlNamespace, "heartbeat-result")); |
135 response->AddElement(result); | 146 response->AddElement(result); |
136 | 147 |
137 XmlElement* set_interval = new XmlElement( | 148 XmlElement* set_interval = new XmlElement( |
138 QName(kChromotingXmlNamespace, "set-interval")); | 149 QName(kChromotingXmlNamespace, "set-interval")); |
139 result->AddElement(set_interval); | 150 result->AddElement(set_interval); |
140 | 151 |
141 const int kTestInterval = 123; | 152 const int kTestInterval = 123; |
142 set_interval->AddText(base::IntToString(kTestInterval)); | 153 set_interval->AddText(base::IntToString(kTestInterval)); |
143 | 154 |
144 scoped_ptr<HeartbeatSender> heartbeat_sender( | 155 heartbeat_sender_->ProcessResponse(response.get()); |
145 new HeartbeatSender(base::MessageLoopProxy::current(), | |
146 config_)); | |
147 heartbeat_sender->ProcessResponse(response.get()); | |
148 | 156 |
149 EXPECT_EQ(kTestInterval * 1000, heartbeat_sender->interval_ms_); | 157 EXPECT_EQ(kTestInterval * 1000, heartbeat_sender_->interval_ms_); |
150 } | 158 } |
151 | 159 |
152 } // namespace remoting | 160 } // namespace remoting |
OLD | NEW |