Disconnect all users if too many connection requests are received for It2Me

remoting/host/it2me/it2me_host_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/it2me/it2me_host.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 19 matching lines @@
 namespace remoting {
 
 namespace {
 
 // Shortening some type names for readability.
 typedef protocol::ValidatingAuthenticator::Result ValidationResult;
 typedef It2MeConfirmationDialog::Result DialogResult;
 
 const char kTestClientUserName[] = "ficticious_user@gmail.com";
 const char kTestClientJid[] = "ficticious_user@gmail.com/jid_resource";
+const char kTestClientJid2[] = "ficticious_user_2@gmail.com/jid_resource";
 const char kTestClientUsernameNoJid[] = "completely_ficticious_user@gmail.com";
 const char kTestClientJidWithSlash[] = "fake/user@gmail.com/jid_resource";
 const char kResourceOnly[] = "/jid_resource";
 const char kMatchingDomain[] = "gmail.com";
 const char kMismatchedDomain1[] = "similar_to_gmail.com";
 const char kMismatchedDomain2[] = "gmail_at_the_beginning.com";
 const char kMismatchedDomain3[] = "not_even_close.com";
 
 }  // namespace
 
@@ skipping 51 matching lines @@
   void OnNatPolicyChanged(bool nat_traversal_enabled) override;
   void OnStateChanged(It2MeHostState state,
                       const std::string& error_message) override;
 
   void SetClientDomainPolicy(const std::string& policy_value);
 
   void RunUntilStateChanged(It2MeHostState expected_state);
 
   void SimulateClientConnection();
 
-  void RunValidationCallback(const std::string& remote_jid);
+  void RunIncomingConnectionCallback(const std::string& remote_jid);
+
+  void RunAcceptedConnectionCallback(const std::string& remote_jid);
 
   void DisconnectClient();
 
   ValidationResult validation_result_ = ValidationResult::SUCCESS;
   std::string remote_user_email_;
 
   base::Closure state_change_callback_;
 
   It2MeHostState last_host_state_ = It2MeHostState::kDisconnected;
 
@@ skipping 81 matching lines @@
       FROM_HERE,
       base::Bind(&It2MeHost::SetStateForTesting, it2me_host_.get(),
                  It2MeHostState::kRequestedAccessCode, std::string()));
 
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&It2MeHost::SetStateForTesting, it2me_host_.get(),
                  It2MeHostState::kReceivedAccessCode, std::string()));
 }
 
-void It2MeHostTest::RunValidationCallback(const std::string& remote_jid) {
+void It2MeHostTest::RunIncomingConnectionCallback(
+    const std::string& remote_jid) {
   base::RunLoop run_loop;
 
   network_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(it2me_host_->GetValidationCallbackForTesting(), remote_jid,
+      base::Bind(it2me_host_->GetIncomingConnectionCallbackForTesting(),
+                 remote_jid,
                  base::Bind(&It2MeHostTest::OnValidationComplete,
                             base::Unretained(this), run_loop.QuitClosure())));
 
+  run_loop.Run();
+}
+
+void It2MeHostTest::RunAcceptedConnectionCallback(
+    const std::string& remote_jid) {
+  base::RunLoop run_loop;
+
+  network_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(it2me_host_->GetAcceptedConnectionCallbackForTesting(),
+                 remote_jid,
+                 base::Bind(&It2MeHostTest::OnValidationComplete,
+                            base::Unretained(this), run_loop.QuitClosure())));
+
   run_loop.Run();
 }
 
 void It2MeHostTest::OnClientAuthenticated(const std::string& client_username) {}
 
 void It2MeHostTest::OnStoreAccessCode(const std::string& access_code,
                                       base::TimeDelta access_code_lifetime) {}
 
 void It2MeHostTest::OnNatPolicyChanged(bool nat_traversal_enabled) {}
 
 void It2MeHostTest::OnStateChanged(It2MeHostState state,
                                    const std::string& error_message) {
   last_host_state_ = state;
 
   if (state_change_callback_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::ResetAndReturn(&state_change_callback_));
   }
 }
 
 void It2MeHostTest::DisconnectClient() {
   if (it2me_host_) {
     it2me_host_->Disconnect();
     RunUntilStateChanged(It2MeHostState::kDisconnected);
   }
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_NoClientDomainPolicy_ValidJid) {
   SimulateClientConnection();
-  RunValidationCallback(kTestClientJid);
+  RunIncomingConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
-  ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
+  ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_);
   DisconnectClient();
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_NoClientDomainPolicy_InvalidJid) {
   SimulateClientConnection();
-  RunValidationCallback(kTestClientUsernameNoJid);
+  RunIncomingConnectionCallback(kTestClientUsernameNoJid);
   ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest,
        ConnectionValidation_NoClientDomainPolicy_InvalidUsername) {
   SimulateClientConnection();
-  RunValidationCallback(kTestClientJidWithSlash);
+  RunIncomingConnectionCallback(kTestClientJidWithSlash);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
-  ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
+  ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_);
   DisconnectClient();
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_NoClientDomainPolicy_ResourceOnly) {
   SimulateClientConnection();
-  RunValidationCallback(kResourceOnly);
+  RunIncomingConnectionCallback(kResourceOnly);
   ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_MatchingDomain) {
   SetClientDomainPolicy(kMatchingDomain);
   SimulateClientConnection();
-  RunValidationCallback(kTestClientJid);
+  RunIncomingConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
-  ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
+  ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_);
   DisconnectClient();
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_InvalidUserName) {
   SetClientDomainPolicy(kMatchingDomain);
   SimulateClientConnection();
-  RunValidationCallback(kTestClientJidWithSlash);
+  RunIncomingConnectionCallback(kTestClientJidWithSlash);
   ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_NoJid) {
   SetClientDomainPolicy(kMatchingDomain);
   SimulateClientConnection();
-  RunValidationCallback(kTestClientUsernameNoJid);
+  RunIncomingConnectionCallback(kTestClientUsernameNoJid);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
   ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_WrongClientDomain_NoMatch) {
   SetClientDomainPolicy(kMismatchedDomain3);
   SimulateClientConnection();
-  RunValidationCallback(kTestClientJid);
+  RunIncomingConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_WrongClientDomain_MatchStart) {
   SetClientDomainPolicy(kMismatchedDomain2);
   SimulateClientConnection();
-  RunValidationCallback(kTestClientJid);
+  RunIncomingConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_WrongClientDomain_MatchEnd) {
   SetClientDomainPolicy(kMismatchedDomain1);
   SimulateClientConnection();
-  RunValidationCallback(kTestClientJid);
+  RunIncomingConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Accept) {
   SimulateClientConnection();
-  RunValidationCallback(kTestClientJid);
+  RunIncomingConnectionCallback(kTestClientJid);
+  ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
+  ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_);
+
+  RunAcceptedConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
   ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str());
   ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
+
   DisconnectClient();
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Reject) {
   dialog_->set_dialog_result(DialogResult::CANCEL);
   SimulateClientConnection();
-  RunValidationCallback(kTestClientJid);
+
+  RunIncomingConnectionCallback(kTestClientJid);
+  ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
+  ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_);
+
+  RunAcceptedConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::ERROR_REJECTED_BY_USER, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
   ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str());
 }
 
+TEST_F(It2MeHostTest, MultipleConnectionsTriggerDisconnect) {
+  SimulateClientConnection();
+  RunIncomingConnectionCallback(kTestClientJid);
+  ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
+  ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_);
+
+  RunAcceptedConnectionCallback(kTestClientJid);
+  ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
+  ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
+  ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str());
+
+  RunIncomingConnectionCallback(kTestClientJid2);
+  ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
+  ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
+
+  RunAcceptedConnectionCallback(kTestClientJid2);
+  ASSERT_EQ(ValidationResult::ERROR_TOO_MANY_CONNECTIONS, validation_result_);
+  RunUntilStateChanged(It2MeHostState::kDisconnected);
+  ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
+}
+
 }  // namespace remoting