Clean up remoting project

remoting/host/chromoting_host_unittest.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "remoting/host/capturer_fake.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/host/in_memory_host_config.h"
-#include "remoting/host/user_authenticator_fake.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "remoting/protocol/session_config.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::remoting::protocol::LocalLoginCredentials;
 using ::remoting::protocol::MockClientStub;
 using ::remoting::protocol::MockConnectionToClient;
 using ::remoting::protocol::MockConnectionToClientEventHandler;
 using ::remoting::protocol::MockHostStub;
-using ::remoting::protocol::MockInputStub;
 using ::remoting::protocol::MockSession;
 using ::remoting::protocol::MockVideoStub;
 using ::remoting::protocol::SessionConfig;
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::CreateFunctor;
 using testing::DeleteArg;
 using testing::DoAll;
 using testing::InSequence;
 using testing::InvokeWithoutArgs;
 using testing::Return;
 using testing::Sequence;
 
 namespace remoting {
 
 namespace {
 
-UserAuthenticator* MakeUserAuthenticator() {
-  return new UserAuthenticatorFake();
-}
-
 void PostQuitTask(MessageLoop* message_loop) {
   message_loop->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
 // Run the task and delete it afterwards. This action is used to deal with
 // done callbacks.
 ACTION(RunDoneTask) {
   arg1->Run();
   delete arg1;
 }
@@ skipping 23 matching lines @@
     EXPECT_CALL(context_, main_message_loop())
         .Times(AnyNumber());
     EXPECT_CALL(context_, encode_message_loop())
         .Times(AnyNumber());
     EXPECT_CALL(context_, network_message_loop())
         .Times(AnyNumber());
 
     Capturer* capturer = new CapturerFake();
     host_stub_ = new MockHostStub();
     host_stub2_ = new MockHostStub();
-    input_stub_ = new MockInputStub();
-    input_stub2_ = new MockInputStub();
+    event_executor_ = new MockEventExecutor();
+    event_executor2_ = new MockEventExecutor();
     curtain_ = new MockCurtain();
+    user_authenticator_ = new MockUserAuthenticator();
     DesktopEnvironment* desktop =
-        new DesktopEnvironment(capturer, input_stub_, curtain_);
+        new DesktopEnvironment(capturer, event_executor_, curtain_);
     host_ = ChromotingHost::Create(&context_, config_, desktop);
-    credentials_good_.set_type(protocol::PASSWORD);
-    credentials_good_.set_username("user");
-    credentials_good_.set_credential("password");
-    credentials_bad_.set_type(protocol::PASSWORD);
-    credentials_bad_.set_username(UserAuthenticatorFake::fail_username());
-    credentials_bad_.set_credential(UserAuthenticatorFake::fail_password());
-    connection_ = new MockConnectionToClient(
-        &message_loop_, &handler_, host_stub_, input_stub_);
+    credentials_.set_type(protocol::PASSWORD);
+    credentials_.set_username("user");
+    credentials_.set_credential("password");
+     connection_ = new MockConnectionToClient(

[Lambros, 2011/04/01 15:54:00]

Nit: indentation

[dmac, 2011/04/01 21:15:07]

Done.

+        &message_loop_, &handler_, host_stub_, event_executor_);
     connection2_ = new MockConnectionToClient(
-        &message_loop_, &handler_, host_stub2_, input_stub2_);
+        &message_loop_, &handler_, host_stub2_, event_executor2_);
     session_ = new MockSession();
     session2_ = new MockSession();
     session_config_.reset(SessionConfig::CreateDefault());
     session_config2_.reset(SessionConfig::CreateDefault());
 
     ON_CALL(video_stub_, ProcessVideoPacket(_, _))
         .WillByDefault(
             DoAll(DeleteArg<0>(), DeleteArg<1>()));
     ON_CALL(video_stub2_, ProcessVideoPacket(_, _))
         .WillByDefault(
@@ skipping 25 matching lines @@
     EXPECT_CALL(*connection2_.get(), client_stub())
         .Times(AnyNumber());
     EXPECT_CALL(*connection2_.get(), session())
         .Times(AnyNumber());
     EXPECT_CALL(*session_.get(), config())
         .Times(AnyNumber());
     EXPECT_CALL(*session2_.get(), config())
         .Times(AnyNumber());
   }
 
-  virtual void TearDown() {
-  }
-
   // Helper method to pretend a client is connected to ChromotingHost.
-  void SimulateClientConnection(int connection_index, bool authenticate) {
+  void SimulateClientConnection(int connection_index) {
     scoped_refptr<MockConnectionToClient> connection =
         (connection_index == 0) ? connection_ : connection2_;
-    protocol::LocalLoginCredentials& credentials =
-        authenticate ? credentials_good_ : credentials_bad_;
     scoped_refptr<ClientSession> client = new ClientSession(
         host_.get(),
-        base::Bind(MakeUserAuthenticator),
+        base::Bind(&ChromotingHostTest::user_authenticator,
+                   base::Unretained(this)),
         connection,
-        input_stub_);
+        event_executor_);
     connection->set_host_stub(client.get());
 
     context_.network_message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(host_.get(),
                           &ChromotingHost::AddClient,
                           client));
     context_.network_message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(host_.get(),
                           &ChromotingHost::OnClientConnected,
                           connection));
+

[simonmorris, 2011/04/01 10:29:34]

Nit: extra line.

[dmac, 2011/04/01 21:15:07]

Done.

     context_.network_message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(client.get(),
                           &ClientSession::BeginSessionRequest,
-                          &credentials,
+                          &credentials_,
                           NewRunnableFunction(&DummyDoneTask)));
   }
 
   // Helper method to remove a client connection from ChromotingHost.
   void RemoveClientConnection() {
     context_.network_message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(host_.get(),
                           &ChromotingHost::OnClientDisconnected,
                           connection_));
   }
 
+  UserAuthenticator* user_authenticator() {
+    return user_authenticator_.get();
+  }
+
  protected:
   MessageLoop message_loop_;
   MockConnectionToClientEventHandler handler_;
   scoped_refptr<ChromotingHost> host_;
   scoped_refptr<InMemoryHostConfig> config_;
   MockChromotingHostContext context_;
-  protocol::LocalLoginCredentials credentials_good_;
-  protocol::LocalLoginCredentials credentials_bad_;
+  protocol::LocalLoginCredentials credentials_;
   scoped_refptr<MockConnectionToClient> connection_;
   scoped_refptr<MockSession> session_;
   scoped_ptr<SessionConfig> session_config_;
   MockVideoStub video_stub_;
   MockClientStub client_stub_;
   MockHostStub* host_stub_;
-  MockInputStub* input_stub_;
+  MockEventExecutor* event_executor_;
   MockCurtain* curtain_;
   scoped_refptr<MockConnectionToClient> connection2_;
   scoped_refptr<MockSession> session2_;
+  scoped_refptr<MockUserAuthenticator> user_authenticator_;

[simonmorris, 2011/04/01 10:29:34]

It's sad to scatter refcounts throughout the code just to
make the unit test a little simpler. Maybe have functions
such as user_authenticator_pass_then_fail(), which
each return a differently tailored MockUserAuthenticator?

[simonmorris, 2011/04/01 10:52:43]

After a chat with Jamie, I realise that wouldn't work.
Maybe we need a UserAuthenticatorFactory class, with mocks?
Maybe in a different CL?

   scoped_ptr<SessionConfig> session_config2_;
   MockVideoStub video_stub2_;
   MockClientStub client_stub2_;
   MockHostStub* host_stub2_;
-  MockInputStub* input_stub2_;
+  MockEventExecutor* event_executor2_;
 };
 
 TEST_F(ChromotingHostTest, StartAndShutdown) {
   host_->Start(NewRunnableFunction(&PostQuitTask, &message_loop_));
 
   message_loop_.PostTask(FROM_HERE,
                          NewRunnableMethod(host_.get(),
                                            &ChromotingHost::Shutdown));
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, Connect) {
   host_->Start(NewRunnableFunction(&PostQuitTask, &message_loop_));
 
   EXPECT_CALL(client_stub_, BeginSessionResponse(_, _))
       .WillOnce(RunDoneTask());
+  EXPECT_CALL(*user_authenticator_, Authenticate(_, _))
+      .WillOnce(Return(true));
 
   // When the video packet is received we first shutdown ChromotingHost
   // then execute the done task.
   InSequence s;
   EXPECT_CALL(*curtain_, EnableCurtainMode(true))
       .Times(1);
   EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
       .WillOnce(DoAll(
           InvokeWithoutArgs(host_.get(), &ChromotingHost::Shutdown),
           RunDoneTask()))
       .RetiresOnSaturation();
   EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
       .Times(AnyNumber());
   EXPECT_CALL(*connection_.get(), Disconnect())
       .RetiresOnSaturation();
-
-  SimulateClientConnection(0, true);
+  SimulateClientConnection(0);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, Reconnect) {
   host_->Start(NewRunnableFunction(&PostQuitTask, &message_loop_));
 
   EXPECT_CALL(client_stub_, BeginSessionResponse(_, _))
       .Times(2)
       .WillRepeatedly(RunDoneTask());
+  EXPECT_CALL(*user_authenticator_, Authenticate(_, _))
+      .Times(2)
+      .WillRepeatedly(Return(true));
 
   // When the video packet is received we first disconnect the mock
   // connection.
   {
     InSequence s;
     // Ensure that curtain mode is activated before the first video packet.
     EXPECT_CALL(*curtain_, EnableCurtainMode(true))
         .Times(1);
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(this,
                               &ChromotingHostTest::RemoveClientConnection),
             RunDoneTask()))
         .RetiresOnSaturation();
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .Times(AnyNumber());
     EXPECT_CALL(*curtain_, EnableCurtainMode(false))
         .Times(1);
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .Times(AnyNumber());
   }
 
   // If Disconnect() is called we can break the main message loop.
   EXPECT_CALL(*connection_.get(), Disconnect())
       .WillOnce(QuitMainMessageLoop(&message_loop_))
       .RetiresOnSaturation();
 
-  SimulateClientConnection(0, true);
+  SimulateClientConnection(0);
   message_loop_.Run();
 
   // Connect the client again.
   {
     InSequence s;
     EXPECT_CALL(*curtain_, EnableCurtainMode(true))
         .Times(1);
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(host_.get(), &ChromotingHost::Shutdown),
             RunDoneTask()))
         .RetiresOnSaturation();
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .Times(AnyNumber());
   }
   EXPECT_CALL(*connection_.get(), Disconnect())
       .RetiresOnSaturation();
 
-  SimulateClientConnection(0, true);
+  SimulateClientConnection(0);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, ConnectTwice) {
   host_->Start(NewRunnableFunction(&PostQuitTask, &message_loop_));
 
   EXPECT_CALL(client_stub_, BeginSessionResponse(_, _))
       .Times(1)
       .WillRepeatedly(RunDoneTask());
 
   EXPECT_CALL(client_stub2_, BeginSessionResponse(_, _))
       .Times(1)
       .WillRepeatedly(RunDoneTask());
 
+  EXPECT_CALL(*user_authenticator_, Authenticate(_, _))
+      .Times(2)
+      .WillRepeatedly(Return(true));
+
   // When a video packet is received we connect the second mock
   // connection.
   {
     InSequence s;
     EXPECT_CALL(*curtain_, EnableCurtainMode(true))
         .Times(1)
         .WillOnce(QuitMainMessageLoop(&message_loop_));
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(
                 CreateFunctor(
                     this,
-                    &ChromotingHostTest::SimulateClientConnection, 1, true)),
+                    &ChromotingHostTest::SimulateClientConnection, 1)),
             RunDoneTask()))
         .RetiresOnSaturation();
     // Check that the second connection does not affect curtain mode.
     EXPECT_CALL(*curtain_, EnableCurtainMode(_))
         .Times(0);
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .Times(AnyNumber());
     EXPECT_CALL(video_stub2_, ProcessVideoPacket(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(host_.get(), &ChromotingHost::Shutdown),
             RunDoneTask()))
         .RetiresOnSaturation();
     EXPECT_CALL(video_stub2_, ProcessVideoPacket(_, _))
         .Times(AnyNumber());
   }
 
   EXPECT_CALL(*connection_.get(), Disconnect())
       .RetiresOnSaturation();
   EXPECT_CALL(*connection2_.get(), Disconnect())
       .RetiresOnSaturation();
 
-  SimulateClientConnection(0, true);
+  SimulateClientConnection(0);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, CurtainModeFail) {
   host_->Start(NewRunnableFunction(&PostQuitTask, &message_loop_));
 
   EXPECT_CALL(client_stub_, BeginSessionResponse(_, _))
-      .Times(1)
-      .WillRepeatedly(RunDoneTask());
+      .WillOnce(RunDoneTask());
+  EXPECT_CALL(*user_authenticator_, Authenticate(_, _))
+      .WillOnce(Return(false));
 
   // Ensure that curtain mode is not activated if a connection does not
   // authenticate.
   EXPECT_CALL(*curtain_, EnableCurtainMode(_))
       .Times(0);
   EXPECT_CALL(*connection_.get(), Disconnect())
       .WillOnce(QuitMainMessageLoop(&message_loop_));
-  SimulateClientConnection(0, false);
+  SimulateClientConnection(0);
   RemoveClientConnection();
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, CurtainModeFailSecond) {
   host_->Start(NewRunnableFunction(&PostQuitTask, &message_loop_));
 
   EXPECT_CALL(client_stub_, BeginSessionResponse(_, _))
-      .Times(1)
-      .WillRepeatedly(RunDoneTask());
+      .WillOnce(RunDoneTask());
 
   EXPECT_CALL(client_stub2_, BeginSessionResponse(_, _))
-      .Times(1)
-      .WillRepeatedly(RunDoneTask());
+      .WillOnce(RunDoneTask());
+
+  EXPECT_CALL(*user_authenticator_, Authenticate(_, _))
+      .WillOnce(Return(true))
+      .WillOnce(Return(false));
 
   // When a video packet is received we connect the second mock
   // connection.
   {
     InSequence s;
     EXPECT_CALL(*curtain_, EnableCurtainMode(true))
-        .Times(1)
         .WillOnce(QuitMainMessageLoop(&message_loop_));
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(
                 CreateFunctor(
                     this,
-                    &ChromotingHostTest::SimulateClientConnection, 1, false)),
+                    &ChromotingHostTest::SimulateClientConnection, 1)),
             RunDoneTask()))
         .RetiresOnSaturation();
     // Check that the second connection does not affect curtain mode.
     EXPECT_CALL(*curtain_, EnableCurtainMode(_))
         .Times(0);
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .Times(AnyNumber());
     EXPECT_CALL(video_stub2_, ProcessVideoPacket(_, _))
         .Times(0);
   }
 
-  SimulateClientConnection(0, true);
+  SimulateClientConnection(0);
   message_loop_.Run();
 }
 
 }  // namespace remoting