OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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/it2me/it2me_host.h" | 5 #include "remoting/host/it2me/it2me_host.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <string> | 8 #include <string> |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
(...skipping 19 matching lines...) Expand all Loading... |
30 namespace remoting { | 30 namespace remoting { |
31 | 31 |
32 namespace { | 32 namespace { |
33 | 33 |
34 // Shortening some type names for readability. | 34 // Shortening some type names for readability. |
35 typedef protocol::ValidatingAuthenticator::Result ValidationResult; | 35 typedef protocol::ValidatingAuthenticator::Result ValidationResult; |
36 typedef It2MeConfirmationDialog::Result DialogResult; | 36 typedef It2MeConfirmationDialog::Result DialogResult; |
37 | 37 |
38 const char kTestClientUserName[] = "ficticious_user@gmail.com"; | 38 const char kTestClientUserName[] = "ficticious_user@gmail.com"; |
39 const char kTestClientJid[] = "ficticious_user@gmail.com/jid_resource"; | 39 const char kTestClientJid[] = "ficticious_user@gmail.com/jid_resource"; |
| 40 const char kTestClientJid2[] = "ficticious_user_2@gmail.com/jid_resource"; |
40 const char kTestClientUsernameNoJid[] = "completely_ficticious_user@gmail.com"; | 41 const char kTestClientUsernameNoJid[] = "completely_ficticious_user@gmail.com"; |
41 const char kTestClientJidWithSlash[] = "fake/user@gmail.com/jid_resource"; | 42 const char kTestClientJidWithSlash[] = "fake/user@gmail.com/jid_resource"; |
42 const char kResourceOnly[] = "/jid_resource"; | 43 const char kResourceOnly[] = "/jid_resource"; |
43 const char kMatchingDomain[] = "gmail.com"; | 44 const char kMatchingDomain[] = "gmail.com"; |
44 const char kMismatchedDomain1[] = "similar_to_gmail.com"; | 45 const char kMismatchedDomain1[] = "similar_to_gmail.com"; |
45 const char kMismatchedDomain2[] = "gmail_at_the_beginning.com"; | 46 const char kMismatchedDomain2[] = "gmail_at_the_beginning.com"; |
46 const char kMismatchedDomain3[] = "not_even_close.com"; | 47 const char kMismatchedDomain3[] = "not_even_close.com"; |
47 | 48 |
48 } // namespace | 49 } // namespace |
49 | 50 |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
101 void OnNatPolicyChanged(bool nat_traversal_enabled) override; | 102 void OnNatPolicyChanged(bool nat_traversal_enabled) override; |
102 void OnStateChanged(It2MeHostState state, | 103 void OnStateChanged(It2MeHostState state, |
103 const std::string& error_message) override; | 104 const std::string& error_message) override; |
104 | 105 |
105 void SetClientDomainPolicy(const std::string& policy_value); | 106 void SetClientDomainPolicy(const std::string& policy_value); |
106 | 107 |
107 void RunUntilStateChanged(It2MeHostState expected_state); | 108 void RunUntilStateChanged(It2MeHostState expected_state); |
108 | 109 |
109 void SimulateClientConnection(); | 110 void SimulateClientConnection(); |
110 | 111 |
111 void RunValidationCallback(const std::string& remote_jid); | 112 void RunIncomingConnectionCallback(const std::string& remote_jid); |
| 113 |
| 114 void RunAcceptedConnectionCallback(const std::string& remote_jid); |
112 | 115 |
113 void DisconnectClient(); | 116 void DisconnectClient(); |
114 | 117 |
115 ValidationResult validation_result_ = ValidationResult::SUCCESS; | 118 ValidationResult validation_result_ = ValidationResult::SUCCESS; |
116 std::string remote_user_email_; | 119 std::string remote_user_email_; |
117 | 120 |
118 base::Closure state_change_callback_; | 121 base::Closure state_change_callback_; |
119 | 122 |
120 It2MeHostState last_host_state_ = It2MeHostState::kDisconnected; | 123 It2MeHostState last_host_state_ = It2MeHostState::kDisconnected; |
121 | 124 |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
203 FROM_HERE, | 206 FROM_HERE, |
204 base::Bind(&It2MeHost::SetStateForTesting, it2me_host_.get(), | 207 base::Bind(&It2MeHost::SetStateForTesting, it2me_host_.get(), |
205 It2MeHostState::kRequestedAccessCode, std::string())); | 208 It2MeHostState::kRequestedAccessCode, std::string())); |
206 | 209 |
207 network_task_runner_->PostTask( | 210 network_task_runner_->PostTask( |
208 FROM_HERE, | 211 FROM_HERE, |
209 base::Bind(&It2MeHost::SetStateForTesting, it2me_host_.get(), | 212 base::Bind(&It2MeHost::SetStateForTesting, it2me_host_.get(), |
210 It2MeHostState::kReceivedAccessCode, std::string())); | 213 It2MeHostState::kReceivedAccessCode, std::string())); |
211 } | 214 } |
212 | 215 |
213 void It2MeHostTest::RunValidationCallback(const std::string& remote_jid) { | 216 void It2MeHostTest::RunIncomingConnectionCallback( |
| 217 const std::string& remote_jid) { |
214 base::RunLoop run_loop; | 218 base::RunLoop run_loop; |
215 | 219 |
216 network_task_runner_->PostTask( | 220 network_task_runner_->PostTask( |
217 FROM_HERE, | 221 FROM_HERE, |
218 base::Bind(it2me_host_->GetValidationCallbackForTesting(), remote_jid, | 222 base::Bind(it2me_host_->GetIncomingConnectionCallbackForTesting(), |
| 223 remote_jid, |
219 base::Bind(&It2MeHostTest::OnValidationComplete, | 224 base::Bind(&It2MeHostTest::OnValidationComplete, |
220 base::Unretained(this), run_loop.QuitClosure()))); | 225 base::Unretained(this), run_loop.QuitClosure()))); |
221 | 226 |
| 227 run_loop.Run(); |
| 228 } |
| 229 |
| 230 void It2MeHostTest::RunAcceptedConnectionCallback( |
| 231 const std::string& remote_jid) { |
| 232 base::RunLoop run_loop; |
| 233 |
| 234 network_task_runner_->PostTask( |
| 235 FROM_HERE, |
| 236 base::Bind(it2me_host_->GetAcceptedConnectionCallbackForTesting(), |
| 237 remote_jid, |
| 238 base::Bind(&It2MeHostTest::OnValidationComplete, |
| 239 base::Unretained(this), run_loop.QuitClosure()))); |
| 240 |
222 run_loop.Run(); | 241 run_loop.Run(); |
223 } | 242 } |
224 | 243 |
225 void It2MeHostTest::OnClientAuthenticated(const std::string& client_username) {} | 244 void It2MeHostTest::OnClientAuthenticated(const std::string& client_username) {} |
226 | 245 |
227 void It2MeHostTest::OnStoreAccessCode(const std::string& access_code, | 246 void It2MeHostTest::OnStoreAccessCode(const std::string& access_code, |
228 base::TimeDelta access_code_lifetime) {} | 247 base::TimeDelta access_code_lifetime) {} |
229 | 248 |
230 void It2MeHostTest::OnNatPolicyChanged(bool nat_traversal_enabled) {} | 249 void It2MeHostTest::OnNatPolicyChanged(bool nat_traversal_enabled) {} |
231 | 250 |
232 void It2MeHostTest::OnStateChanged(It2MeHostState state, | 251 void It2MeHostTest::OnStateChanged(It2MeHostState state, |
233 const std::string& error_message) { | 252 const std::string& error_message) { |
234 last_host_state_ = state; | 253 last_host_state_ = state; |
235 | 254 |
236 if (state_change_callback_) { | 255 if (state_change_callback_) { |
237 base::ThreadTaskRunnerHandle::Get()->PostTask( | 256 base::ThreadTaskRunnerHandle::Get()->PostTask( |
238 FROM_HERE, base::ResetAndReturn(&state_change_callback_)); | 257 FROM_HERE, base::ResetAndReturn(&state_change_callback_)); |
239 } | 258 } |
240 } | 259 } |
241 | 260 |
242 void It2MeHostTest::DisconnectClient() { | 261 void It2MeHostTest::DisconnectClient() { |
243 if (it2me_host_) { | 262 if (it2me_host_) { |
244 it2me_host_->Disconnect(); | 263 it2me_host_->Disconnect(); |
245 RunUntilStateChanged(It2MeHostState::kDisconnected); | 264 RunUntilStateChanged(It2MeHostState::kDisconnected); |
246 } | 265 } |
247 } | 266 } |
248 | 267 |
249 TEST_F(It2MeHostTest, ConnectionValidation_NoClientDomainPolicy_ValidJid) { | 268 TEST_F(It2MeHostTest, ConnectionValidation_NoClientDomainPolicy_ValidJid) { |
250 SimulateClientConnection(); | 269 SimulateClientConnection(); |
251 RunValidationCallback(kTestClientJid); | 270 RunIncomingConnectionCallback(kTestClientJid); |
252 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); | 271 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); |
253 ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_); | 272 ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_); |
254 DisconnectClient(); | 273 DisconnectClient(); |
255 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 274 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
256 } | 275 } |
257 | 276 |
258 TEST_F(It2MeHostTest, ConnectionValidation_NoClientDomainPolicy_InvalidJid) { | 277 TEST_F(It2MeHostTest, ConnectionValidation_NoClientDomainPolicy_InvalidJid) { |
259 SimulateClientConnection(); | 278 SimulateClientConnection(); |
260 RunValidationCallback(kTestClientUsernameNoJid); | 279 RunIncomingConnectionCallback(kTestClientUsernameNoJid); |
261 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); | 280 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); |
262 RunUntilStateChanged(It2MeHostState::kDisconnected); | 281 RunUntilStateChanged(It2MeHostState::kDisconnected); |
263 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 282 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
264 } | 283 } |
265 | 284 |
266 TEST_F(It2MeHostTest, | 285 TEST_F(It2MeHostTest, |
267 ConnectionValidation_NoClientDomainPolicy_InvalidUsername) { | 286 ConnectionValidation_NoClientDomainPolicy_InvalidUsername) { |
268 SimulateClientConnection(); | 287 SimulateClientConnection(); |
269 RunValidationCallback(kTestClientJidWithSlash); | 288 RunIncomingConnectionCallback(kTestClientJidWithSlash); |
270 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); | 289 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); |
271 ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_); | 290 ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_); |
272 DisconnectClient(); | 291 DisconnectClient(); |
273 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 292 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
274 } | 293 } |
275 | 294 |
276 TEST_F(It2MeHostTest, ConnectionValidation_NoClientDomainPolicy_ResourceOnly) { | 295 TEST_F(It2MeHostTest, ConnectionValidation_NoClientDomainPolicy_ResourceOnly) { |
277 SimulateClientConnection(); | 296 SimulateClientConnection(); |
278 RunValidationCallback(kResourceOnly); | 297 RunIncomingConnectionCallback(kResourceOnly); |
279 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); | 298 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); |
280 RunUntilStateChanged(It2MeHostState::kDisconnected); | 299 RunUntilStateChanged(It2MeHostState::kDisconnected); |
281 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 300 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
282 } | 301 } |
283 | 302 |
284 TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_MatchingDomain) { | 303 TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_MatchingDomain) { |
285 SetClientDomainPolicy(kMatchingDomain); | 304 SetClientDomainPolicy(kMatchingDomain); |
286 SimulateClientConnection(); | 305 SimulateClientConnection(); |
287 RunValidationCallback(kTestClientJid); | 306 RunIncomingConnectionCallback(kTestClientJid); |
288 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); | 307 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); |
289 ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_); | 308 ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_); |
290 DisconnectClient(); | 309 DisconnectClient(); |
291 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 310 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
292 } | 311 } |
293 | 312 |
294 TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_InvalidUserName) { | 313 TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_InvalidUserName) { |
295 SetClientDomainPolicy(kMatchingDomain); | 314 SetClientDomainPolicy(kMatchingDomain); |
296 SimulateClientConnection(); | 315 SimulateClientConnection(); |
297 RunValidationCallback(kTestClientJidWithSlash); | 316 RunIncomingConnectionCallback(kTestClientJidWithSlash); |
298 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); | 317 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); |
299 RunUntilStateChanged(It2MeHostState::kDisconnected); | 318 RunUntilStateChanged(It2MeHostState::kDisconnected); |
300 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 319 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
301 } | 320 } |
302 | 321 |
303 TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_NoJid) { | 322 TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_NoJid) { |
304 SetClientDomainPolicy(kMatchingDomain); | 323 SetClientDomainPolicy(kMatchingDomain); |
305 SimulateClientConnection(); | 324 SimulateClientConnection(); |
306 RunValidationCallback(kTestClientUsernameNoJid); | 325 RunIncomingConnectionCallback(kTestClientUsernameNoJid); |
307 RunUntilStateChanged(It2MeHostState::kDisconnected); | 326 RunUntilStateChanged(It2MeHostState::kDisconnected); |
308 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 327 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
309 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); | 328 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); |
310 } | 329 } |
311 | 330 |
312 TEST_F(It2MeHostTest, ConnectionValidation_WrongClientDomain_NoMatch) { | 331 TEST_F(It2MeHostTest, ConnectionValidation_WrongClientDomain_NoMatch) { |
313 SetClientDomainPolicy(kMismatchedDomain3); | 332 SetClientDomainPolicy(kMismatchedDomain3); |
314 SimulateClientConnection(); | 333 SimulateClientConnection(); |
315 RunValidationCallback(kTestClientJid); | 334 RunIncomingConnectionCallback(kTestClientJid); |
316 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); | 335 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); |
317 RunUntilStateChanged(It2MeHostState::kDisconnected); | 336 RunUntilStateChanged(It2MeHostState::kDisconnected); |
318 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 337 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
319 } | 338 } |
320 | 339 |
321 TEST_F(It2MeHostTest, ConnectionValidation_WrongClientDomain_MatchStart) { | 340 TEST_F(It2MeHostTest, ConnectionValidation_WrongClientDomain_MatchStart) { |
322 SetClientDomainPolicy(kMismatchedDomain2); | 341 SetClientDomainPolicy(kMismatchedDomain2); |
323 SimulateClientConnection(); | 342 SimulateClientConnection(); |
324 RunValidationCallback(kTestClientJid); | 343 RunIncomingConnectionCallback(kTestClientJid); |
325 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); | 344 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); |
326 RunUntilStateChanged(It2MeHostState::kDisconnected); | 345 RunUntilStateChanged(It2MeHostState::kDisconnected); |
327 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 346 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
328 } | 347 } |
329 | 348 |
330 TEST_F(It2MeHostTest, ConnectionValidation_WrongClientDomain_MatchEnd) { | 349 TEST_F(It2MeHostTest, ConnectionValidation_WrongClientDomain_MatchEnd) { |
331 SetClientDomainPolicy(kMismatchedDomain1); | 350 SetClientDomainPolicy(kMismatchedDomain1); |
332 SimulateClientConnection(); | 351 SimulateClientConnection(); |
333 RunValidationCallback(kTestClientJid); | 352 RunIncomingConnectionCallback(kTestClientJid); |
334 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); | 353 ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_); |
335 RunUntilStateChanged(It2MeHostState::kDisconnected); | 354 RunUntilStateChanged(It2MeHostState::kDisconnected); |
336 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 355 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
337 } | 356 } |
338 | 357 |
339 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Accept) { | 358 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Accept) { |
340 SimulateClientConnection(); | 359 SimulateClientConnection(); |
341 RunValidationCallback(kTestClientJid); | 360 RunIncomingConnectionCallback(kTestClientJid); |
| 361 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); |
| 362 ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_); |
| 363 |
| 364 RunAcceptedConnectionCallback(kTestClientJid); |
342 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); | 365 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); |
343 ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str()); | 366 ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str()); |
344 ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_); | 367 ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_); |
| 368 |
345 DisconnectClient(); | 369 DisconnectClient(); |
346 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 370 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
347 } | 371 } |
348 | 372 |
349 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Reject) { | 373 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Reject) { |
350 dialog_->set_dialog_result(DialogResult::CANCEL); | 374 dialog_->set_dialog_result(DialogResult::CANCEL); |
351 SimulateClientConnection(); | 375 SimulateClientConnection(); |
352 RunValidationCallback(kTestClientJid); | 376 |
| 377 RunIncomingConnectionCallback(kTestClientJid); |
| 378 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); |
| 379 ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_); |
| 380 |
| 381 RunAcceptedConnectionCallback(kTestClientJid); |
353 ASSERT_EQ(ValidationResult::ERROR_REJECTED_BY_USER, validation_result_); | 382 ASSERT_EQ(ValidationResult::ERROR_REJECTED_BY_USER, validation_result_); |
354 RunUntilStateChanged(It2MeHostState::kDisconnected); | 383 RunUntilStateChanged(It2MeHostState::kDisconnected); |
355 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); | 384 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
356 ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str()); | 385 ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str()); |
357 } | 386 } |
358 | 387 |
| 388 TEST_F(It2MeHostTest, MultipleConnectionsTriggerDisconnect) { |
| 389 SimulateClientConnection(); |
| 390 RunIncomingConnectionCallback(kTestClientJid); |
| 391 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); |
| 392 ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_); |
| 393 |
| 394 RunAcceptedConnectionCallback(kTestClientJid); |
| 395 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); |
| 396 ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_); |
| 397 ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str()); |
| 398 |
| 399 RunIncomingConnectionCallback(kTestClientJid2); |
| 400 ASSERT_EQ(ValidationResult::SUCCESS, validation_result_); |
| 401 ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_); |
| 402 |
| 403 RunAcceptedConnectionCallback(kTestClientJid2); |
| 404 ASSERT_EQ(ValidationResult::ERROR_TOO_MANY_CONNECTIONS, validation_result_); |
| 405 RunUntilStateChanged(It2MeHostState::kDisconnected); |
| 406 ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_); |
| 407 } |
| 408 |
359 } // namespace remoting | 409 } // namespace remoting |
OLD | NEW |