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_, GetState()) |
| 60 .WillOnce(Return(SignalStrategy::DISCONNECTED)); |
| 61 EXPECT_CALL(signal_strategy_, AddListener(NotNull())) |
| 62 .WillRepeatedly(AddListener(&signal_strategy_listeners_)); |
| 63 EXPECT_CALL(signal_strategy_, RemoveListener(NotNull())) |
| 64 .WillRepeatedly(RemoveListener(&signal_strategy_listeners_)); |
| 65 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
| 66 .WillRepeatedly(Return(kTestJid)); |
| 67 |
| 68 heartbeat_sender_.reset(new HeartbeatSender()); |
| 69 ASSERT_TRUE(heartbeat_sender_->Init(&signal_strategy_, config_)); |
48 } | 70 } |
49 | 71 |
| 72 virtual void TearDown() OVERRIDE { |
| 73 heartbeat_sender_.reset(); |
| 74 EXPECT_TRUE(signal_strategy_listeners_.empty()); |
| 75 } |
| 76 |
| 77 MessageLoop message_loop_; |
50 MockSignalStrategy signal_strategy_; | 78 MockSignalStrategy signal_strategy_; |
51 MessageLoop message_loop_; | 79 std::set<SignalStrategy::Listener*> signal_strategy_listeners_; |
52 scoped_refptr<InMemoryHostConfig> config_; | 80 scoped_refptr<InMemoryHostConfig> config_; |
| 81 scoped_ptr<HeartbeatSender> heartbeat_sender_; |
53 }; | 82 }; |
54 | 83 |
55 // Call Start() followed by Stop(), and makes sure an Iq stanza is | 84 // Call Start() followed by Stop(), and makes sure an Iq stanza is |
56 // being sent. | 85 // being sent. |
57 TEST_F(HeartbeatSenderTest, DoSendStanza) { | 86 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; | 87 XmlElement* sent_iq = NULL; |
67 EXPECT_CALL(signal_strategy_, GetLocalJid()) | 88 EXPECT_CALL(signal_strategy_, GetLocalJid()) |
68 .WillRepeatedly(Return(kTestJid)); | 89 .WillRepeatedly(Return(kTestJid)); |
69 EXPECT_CALL(signal_strategy_, GetNextId()) | 90 EXPECT_CALL(signal_strategy_, GetNextId()) |
70 .WillOnce(Return(kStanzaId)); | 91 .WillOnce(Return(kStanzaId)); |
71 EXPECT_CALL(signal_strategy_, SendStanza(NotNull())) | 92 EXPECT_CALL(signal_strategy_, SendStanza(NotNull())) |
72 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); | 93 .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true))); |
73 | 94 |
74 heartbeat_sender->OnSignallingConnected(&signal_strategy_); | 95 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED); |
75 message_loop_.RunAllPending(); | 96 message_loop_.RunAllPending(); |
76 | 97 |
77 scoped_ptr<XmlElement> stanza(sent_iq); | 98 scoped_ptr<XmlElement> stanza(sent_iq); |
78 ASSERT_TRUE(stanza != NULL); | 99 ASSERT_TRUE(stanza != NULL); |
79 | 100 |
80 EXPECT_EQ(stanza->Attr(buzz::QName("", "to")), | 101 EXPECT_EQ(stanza->Attr(buzz::QName("", "to")), |
81 std::string(kChromotingBotJid)); | 102 std::string(kChromotingBotJid)); |
82 EXPECT_EQ(stanza->Attr(buzz::QName("", "type")), "set"); | 103 EXPECT_EQ(stanza->Attr(buzz::QName("", "type")), "set"); |
83 | 104 |
84 EXPECT_CALL(signal_strategy_, RemoveListener(listener)); | 105 heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED); |
85 | |
86 heartbeat_sender->OnSignallingDisconnected(); | |
87 message_loop_.RunAllPending(); | 106 message_loop_.RunAllPending(); |
88 } | 107 } |
89 | 108 |
90 // Validate format of the heartbeat stanza. | 109 // Validate format of the heartbeat stanza. |
91 TEST_F(HeartbeatSenderTest, CreateHeartbeatMessage) { | 110 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()); | 111 int64 start_time = static_cast<int64>(base::Time::Now().ToDoubleT()); |
98 | 112 |
99 heartbeat_sender->full_jid_ = kTestJid; | 113 scoped_ptr<XmlElement> stanza(heartbeat_sender_->CreateHeartbeatMessage()); |
100 scoped_ptr<XmlElement> stanza(heartbeat_sender->CreateHeartbeatMessage()); | |
101 ASSERT_TRUE(stanza.get() != NULL); | 114 ASSERT_TRUE(stanza.get() != NULL); |
102 | 115 |
103 EXPECT_TRUE(QName(kChromotingXmlNamespace, "heartbeat") == | 116 EXPECT_TRUE(QName(kChromotingXmlNamespace, "heartbeat") == |
104 stanza->Name()); | 117 stanza->Name()); |
105 EXPECT_EQ(std::string(kHostId), | 118 EXPECT_EQ(std::string(kHostId), |
106 stanza->Attr(QName(kChromotingXmlNamespace, "hostid"))); | 119 stanza->Attr(QName(kChromotingXmlNamespace, "hostid"))); |
107 | 120 |
108 QName signature_tag(kChromotingXmlNamespace, "signature"); | 121 QName signature_tag(kChromotingXmlNamespace, "signature"); |
109 XmlElement* signature = stanza->FirstNamed(signature_tag); | 122 XmlElement* signature = stanza->FirstNamed(signature_tag); |
110 ASSERT_TRUE(signature != NULL); | 123 ASSERT_TRUE(signature != NULL); |
(...skipping 23 matching lines...) Expand all Loading... |
134 QName(kChromotingXmlNamespace, "heartbeat-result")); | 147 QName(kChromotingXmlNamespace, "heartbeat-result")); |
135 response->AddElement(result); | 148 response->AddElement(result); |
136 | 149 |
137 XmlElement* set_interval = new XmlElement( | 150 XmlElement* set_interval = new XmlElement( |
138 QName(kChromotingXmlNamespace, "set-interval")); | 151 QName(kChromotingXmlNamespace, "set-interval")); |
139 result->AddElement(set_interval); | 152 result->AddElement(set_interval); |
140 | 153 |
141 const int kTestInterval = 123; | 154 const int kTestInterval = 123; |
142 set_interval->AddText(base::IntToString(kTestInterval)); | 155 set_interval->AddText(base::IntToString(kTestInterval)); |
143 | 156 |
144 scoped_ptr<HeartbeatSender> heartbeat_sender( | 157 heartbeat_sender_->ProcessResponse(response.get()); |
145 new HeartbeatSender(base::MessageLoopProxy::current(), | |
146 config_)); | |
147 heartbeat_sender->ProcessResponse(response.get()); | |
148 | 158 |
149 EXPECT_EQ(kTestInterval * 1000, heartbeat_sender->interval_ms_); | 159 EXPECT_EQ(kTestInterval * 1000, heartbeat_sender_->interval_ms_); |
150 } | 160 } |
151 | 161 |
152 } // namespace remoting | 162 } // namespace remoting |
OLD | NEW |