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

remoting/protocol/validating_authenticator_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 <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 11 matching lines @@
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 using testing::_;
 using testing::Return;
 
 typedef ValidatingAuthenticator::Result ValidationResult;
 
-const char kRemoteTestJid[] = "ficticious_jid_for_testing";
+constexpr char kRemoteTestJid[] = "ficticious_jid_for_testing";
 
 // testing::InvokeArgument<N> does not work with base::Callback, fortunately
 // gmock makes it simple to create action templates that do for the various
 // possible numbers of arguments.
 ACTION_TEMPLATE(InvokeCallbackArgument,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_0_VALUE_PARAMS()) {
   ::std::tr1::get<k>(args).Run();
 }
 
 }  // namespace
 
 class ValidatingAuthenticatorTest : public testing::Test {
  public:
   ValidatingAuthenticatorTest();
   ~ValidatingAuthenticatorTest() override;
 
   void ValidateCallback(
+      ValidationResult* validation_result,
+      bool* callback_called,
       const std::string& remote_jid,
       const ValidatingAuthenticator::ResultCallback& callback);
 
  protected:
   // testing::Test overrides.
   void SetUp() override;
 
   // Calls ProcessMessage() on |validating_authenticator_| and blocks until
   // the result callback is called.
   void SendMessageAndWaitForCallback();
 
   // Used to set up our mock behaviors on the MockAuthenticator object passed
   // to |validating_authenticator_|.  Lifetime of the object is controlled by
   // |validating_authenticator_| so this pointer is no longer valid once
   // the owner is destroyed.
-  MockAuthenticator* mock_authenticator_ = nullptr;
+  testing::NiceMock<MockAuthenticator>* mock_authenticator_ = nullptr;
 
   // This member is used to drive behavior in |validating_authenticator_| when
-  // it's validation complete callback is run.
-  ValidationResult validation_result_ = ValidationResult::SUCCESS;
+  // its incoming validation complete callback is run.
+  ValidationResult incoming_validation_result_ = ValidationResult::SUCCESS;
 
-  // Tracks whether our ValidateCallback has been called or not.
-  bool validate_complete_called_ = false;
+  // Tracks whether our 'incoming' callback has been called or not.
+  bool incoming_complete_called_ = false;
+
+  // This member is used to drive behavior in |validating_authenticator_| when
+  // its accepted validation complete callback is run.
+  ValidationResult accepted_validation_result_ = ValidationResult::SUCCESS;
+
+  // Tracks whether our 'accepted' callback has been called or not.
+  bool accepted_complete_called_ = false;
 
   // The object under test.
   std::unique_ptr<ValidatingAuthenticator> validating_authenticator_;
 
  private:
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(ValidatingAuthenticatorTest);
 };
 
 ValidatingAuthenticatorTest::ValidatingAuthenticatorTest() {}
 
 ValidatingAuthenticatorTest::~ValidatingAuthenticatorTest() {}
 
 void ValidatingAuthenticatorTest::ValidateCallback(
+    ValidationResult* validation_result,
+    bool* callback_called,
     const std::string& remote_jid,
     const ValidatingAuthenticator::ResultCallback& callback) {
-  validate_complete_called_ = true;
-  callback.Run(validation_result_);
+  *callback_called = true;
+  callback.Run(*validation_result);
 }
 
 void ValidatingAuthenticatorTest::SetUp() {
-  mock_authenticator_ = new MockAuthenticator();
+  mock_authenticator_ = new testing::NiceMock<MockAuthenticator>();
   std::unique_ptr<Authenticator> authenticator(mock_authenticator_);
 
   validating_authenticator_.reset(new ValidatingAuthenticator(
-      kRemoteTestJid, base::Bind(&ValidatingAuthenticatorTest::ValidateCallback,
-                                 base::Unretained(this)),
+      kRemoteTestJid,
+      base::Bind(&ValidatingAuthenticatorTest::ValidateCallback,
+                 base::Unretained(this), &incoming_validation_result_,
+                 &incoming_complete_called_),
+      base::Bind(&ValidatingAuthenticatorTest::ValidateCallback,
+                 base::Unretained(this), &accepted_validation_result_,
+                 &accepted_complete_called_),
       std::move(authenticator)));
 }
 
 void ValidatingAuthenticatorTest::SendMessageAndWaitForCallback() {
   base::RunLoop run_loop;
   std::unique_ptr<buzz::XmlElement> first_message(
       Authenticator::CreateEmptyAuthenticatorMessage());
   validating_authenticator_->ProcessMessage(first_message.get(),
                                             run_loop.QuitClosure());
   run_loop.Run();
 }
 
 TEST_F(ValidatingAuthenticatorTest, ValidConnection_SingleMessage) {
   EXPECT_CALL(*mock_authenticator_, ProcessMessage(_, _))
       .Times(1)
       .WillOnce(InvokeCallbackArgument<1>());
 
   ON_CALL(*mock_authenticator_, state())
       .WillByDefault(Return(Authenticator::ACCEPTED));
 
   SendMessageAndWaitForCallback();
-  ASSERT_TRUE(validate_complete_called_);
+  ASSERT_TRUE(incoming_complete_called_);
+  ASSERT_TRUE(accepted_complete_called_);
   ASSERT_EQ(validating_authenticator_->state(), Authenticator::ACCEPTED);
 }
 
 TEST_F(ValidatingAuthenticatorTest, ValidConnection_TwoMessages) {
   // Send the first message to the authenticator, set the mock up to act
   // like it is waiting for a second message.
   EXPECT_CALL(*mock_authenticator_, ProcessMessage(_, _))
       .Times(2)
       .WillRepeatedly(InvokeCallbackArgument<1>());
 
   EXPECT_CALL(*mock_authenticator_, state())
       .WillRepeatedly(Return(Authenticator::MESSAGE_READY));
 
   SendMessageAndWaitForCallback();
-  ASSERT_TRUE(validate_complete_called_);
+  ASSERT_TRUE(incoming_complete_called_);
+  ASSERT_FALSE(accepted_complete_called_);
   ASSERT_EQ(validating_authenticator_->state(), Authenticator::MESSAGE_READY);
 
   // Now 'retrieve' the message for the client which resets the state.
   EXPECT_CALL(*mock_authenticator_, state())
       .WillRepeatedly(Return(Authenticator::WAITING_MESSAGE));
 
   // This dance is needed because GMock doesn't handle unique_ptrs very well.
   // The mock method receives a raw pointer which it wraps and returns when
   // GetNextMessage() is called.
   std::unique_ptr<buzz::XmlElement> next_message(
       Authenticator::CreateEmptyAuthenticatorMessage());
   EXPECT_CALL(*mock_authenticator_, GetNextMessagePtr())
       .Times(1)
       .WillOnce(Return(next_message.release()));
 
   validating_authenticator_->GetNextMessage();
   ASSERT_EQ(validating_authenticator_->state(), Authenticator::WAITING_MESSAGE);
 
   // Now send the second message for processing.
   EXPECT_CALL(*mock_authenticator_, state())
       .WillRepeatedly(Return(Authenticator::ACCEPTED));
 
   // Reset the callback state, we don't expect the validate function to be
-  // called for the second message.
-  validate_complete_called_ = false;
+  // called for the second message, but the accepted callback should.
+  incoming_complete_called_ = false;
   SendMessageAndWaitForCallback();
-  ASSERT_FALSE(validate_complete_called_);
+  ASSERT_FALSE(incoming_complete_called_);
+  ASSERT_TRUE(accepted_complete_called_);
   ASSERT_EQ(validating_authenticator_->state(), Authenticator::ACCEPTED);
 }
 
 TEST_F(ValidatingAuthenticatorTest, InvalidConnection_RejectedByUser) {
   EXPECT_CALL(*mock_authenticator_, ProcessMessage(_, _)).Times(0);
   EXPECT_CALL(*mock_authenticator_, state()).Times(0);
   EXPECT_CALL(*mock_authenticator_, rejection_reason()).Times(0);
 
-  validation_result_ = ValidationResult::ERROR_REJECTED_BY_USER;
+  incoming_validation_result_ = ValidationResult::ERROR_REJECTED_BY_USER;
 
   SendMessageAndWaitForCallback();
-  ASSERT_TRUE(validate_complete_called_);
+  ASSERT_TRUE(incoming_complete_called_);
+  ASSERT_FALSE(accepted_complete_called_);
   ASSERT_EQ(validating_authenticator_->state(), Authenticator::REJECTED);
   ASSERT_EQ(validating_authenticator_->rejection_reason(),
             Authenticator::REJECTED_BY_USER);
 }
 
 TEST_F(ValidatingAuthenticatorTest, InvalidConnection_InvalidCredentials) {
   EXPECT_CALL(*mock_authenticator_, ProcessMessage(_, _)).Times(0);
   EXPECT_CALL(*mock_authenticator_, state()).Times(0);
   EXPECT_CALL(*mock_authenticator_, rejection_reason()).Times(0);
 
-  validation_result_ = ValidationResult::ERROR_INVALID_CREDENTIALS;
+  incoming_validation_result_ = ValidationResult::ERROR_INVALID_CREDENTIALS;
 
   SendMessageAndWaitForCallback();
-  ASSERT_TRUE(validate_complete_called_);
+  ASSERT_TRUE(incoming_complete_called_);
+  ASSERT_FALSE(accepted_complete_called_);
   ASSERT_EQ(validating_authenticator_->state(), Authenticator::REJECTED);
   ASSERT_EQ(validating_authenticator_->rejection_reason(),
             Authenticator::INVALID_CREDENTIALS);
 }
 
 TEST_F(ValidatingAuthenticatorTest, InvalidConnection_InvalidAccount) {
   EXPECT_CALL(*mock_authenticator_, ProcessMessage(_, _)).Times(0);
   EXPECT_CALL(*mock_authenticator_, state()).Times(0);
   EXPECT_CALL(*mock_authenticator_, rejection_reason()).Times(0);
 
-  validation_result_ = ValidationResult::ERROR_INVALID_ACCOUNT;
+  incoming_validation_result_ = ValidationResult::ERROR_INVALID_ACCOUNT;
 
   SendMessageAndWaitForCallback();
-  ASSERT_TRUE(validate_complete_called_);
+  ASSERT_TRUE(incoming_complete_called_);
+  ASSERT_FALSE(accepted_complete_called_);
   ASSERT_EQ(validating_authenticator_->state(), Authenticator::REJECTED);
   ASSERT_EQ(validating_authenticator_->rejection_reason(),
             Authenticator::INVALID_ACCOUNT);
 }
 
+TEST_F(ValidatingAuthenticatorTest, InvalidConnection_TooManyConnections) {
+  EXPECT_CALL(*mock_authenticator_, ProcessMessage(_, _)).Times(0);
+  EXPECT_CALL(*mock_authenticator_, state()).Times(0);
+  EXPECT_CALL(*mock_authenticator_, rejection_reason()).Times(0);
+
+  incoming_validation_result_ = ValidationResult::ERROR_TOO_MANY_CONNECTIONS;
+
+  SendMessageAndWaitForCallback();
+  ASSERT_TRUE(incoming_complete_called_);
+  ASSERT_FALSE(accepted_complete_called_);
+  ASSERT_EQ(validating_authenticator_->state(), Authenticator::REJECTED);
+  ASSERT_EQ(validating_authenticator_->rejection_reason(),
+            Authenticator::TOO_MANY_CONNECTIONS);
+}
+
+TEST_F(ValidatingAuthenticatorTest, AcceptedConnection_RejectedByUser) {
+  EXPECT_CALL(*mock_authenticator_, ProcessMessage(_, _))
+      .Times(1)
+      .WillOnce(InvokeCallbackArgument<1>());
+
+  ON_CALL(*mock_authenticator_, state())
+      .WillByDefault(Return(Authenticator::ACCEPTED));
+
+  accepted_validation_result_ = ValidationResult::ERROR_REJECTED_BY_USER;
+
+  SendMessageAndWaitForCallback();
+  ASSERT_TRUE(incoming_complete_called_);
+  ASSERT_TRUE(accepted_complete_called_);
+  ASSERT_EQ(validating_authenticator_->state(), Authenticator::REJECTED);
+  ASSERT_EQ(validating_authenticator_->rejection_reason(),
+            Authenticator::REJECTED_BY_USER);
+}
+
 TEST_F(ValidatingAuthenticatorTest,
        WrappedAuthenticatorRejectsConnection_InvalidCredentials) {
   EXPECT_CALL(*mock_authenticator_, ProcessMessage(_, _))
       .Times(1)
       .WillOnce(InvokeCallbackArgument<1>());
 
   ON_CALL(*mock_authenticator_, state())
       .WillByDefault(Return(Authenticator::REJECTED));
 
   ON_CALL(*mock_authenticator_, rejection_reason())
       .WillByDefault(Return(Authenticator::REJECTED_BY_USER));
 
   SendMessageAndWaitForCallback();
-  ASSERT_TRUE(validate_complete_called_);
+  ASSERT_TRUE(incoming_complete_called_);
+  ASSERT_FALSE(accepted_complete_called_);
   ASSERT_EQ(validating_authenticator_->state(), Authenticator::REJECTED);
   ASSERT_EQ(validating_authenticator_->rejection_reason(),
             Authenticator::REJECTED_BY_USER);
 }
 
 TEST_F(ValidatingAuthenticatorTest,
        WrappedAuthenticatorRejectsConnection_InvalidAccount) {
   EXPECT_CALL(*mock_authenticator_, ProcessMessage(_, _))
       .Times(1)
       .WillOnce(InvokeCallbackArgument<1>());
 
   ON_CALL(*mock_authenticator_, state())
       .WillByDefault(Return(Authenticator::REJECTED));
 
   ON_CALL(*mock_authenticator_, rejection_reason())
       .WillByDefault(Return(Authenticator::INVALID_CREDENTIALS));
 
   SendMessageAndWaitForCallback();
-  ASSERT_TRUE(validate_complete_called_);
+  ASSERT_TRUE(incoming_complete_called_);
+  ASSERT_FALSE(accepted_complete_called_);
   ASSERT_EQ(validating_authenticator_->state(), Authenticator::REJECTED);
   ASSERT_EQ(validating_authenticator_->rejection_reason(),
             Authenticator::INVALID_CREDENTIALS);
 }
 
 TEST_F(ValidatingAuthenticatorTest,
-       WrappedAuthenticatorRejectsConnection_PROTOCOL_ERROR) {
+       WrappedAuthenticatorRejectsConnection_ProtocolError) {
   EXPECT_CALL(*mock_authenticator_, ProcessMessage(_, _))
       .Times(1)
       .WillOnce(InvokeCallbackArgument<1>());
 
   ON_CALL(*mock_authenticator_, state())
       .WillByDefault(Return(Authenticator::REJECTED));
 
   ON_CALL(*mock_authenticator_, rejection_reason())
       .WillByDefault(Return(Authenticator::PROTOCOL_ERROR));
 
   SendMessageAndWaitForCallback();
-  ASSERT_TRUE(validate_complete_called_);
+  ASSERT_TRUE(incoming_complete_called_);
+  ASSERT_FALSE(accepted_complete_called_);
   ASSERT_EQ(validating_authenticator_->state(), Authenticator::REJECTED);
   ASSERT_EQ(validating_authenticator_->rejection_reason(),
             Authenticator::PROTOCOL_ERROR);
 }
 
 }  // namespace protocol
 }  // namespace remoting