Multi-step authentication support in JingleSession.

remoting/protocol/jingle_session_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/message_loop_proxy.h"
 #include "base/time.h"
 #include "net/socket/socket.h"
 #include "net/socket/stream_socket.h"
 #include "remoting/base/constants.h"
@@ skipping 153 matching lines @@
                           bool expect_fail) {
     EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
         .WillOnce(DoAll(
             WithArg<0>(Invoke(
                 this, &JingleSessionTest::SetHostSession)),
             SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
 
     {
       InSequence dummy;
 
+      EXPECT_CALL(host_connection_callback_,
+                  OnStateChange(Session::CONNECTED))
+          .Times(AtMost(1));
       if (expect_fail) {
         EXPECT_CALL(host_connection_callback_,
                     OnStateChange(Session::FAILED))
             .Times(1);
       } else {
         EXPECT_CALL(host_connection_callback_,
-                    OnStateChange(Session::CONNECTED))
-            .Times(1);
-        EXPECT_CALL(host_connection_callback_,
                     OnStateChange(Session::AUTHENTICATED))
             .Times(1);
       }
     }
 
     {
       InSequence dummy;
 
       EXPECT_CALL(client_connection_callback_,
                   OnStateChange(Session::CONNECTING))
           .Times(1);
+      EXPECT_CALL(client_connection_callback_,
+                  OnStateChange(Session::CONNECTED))
+          .Times(AtMost(1));
       if (expect_fail) {
         EXPECT_CALL(client_connection_callback_,
                     OnStateChange(Session::FAILED))
             .Times(1);
       } else {
         EXPECT_CALL(client_connection_callback_,
-                    OnStateChange(Session::CONNECTED))
-            .Times(1);
-        EXPECT_CALL(client_connection_callback_,
                     OnStateChange(Session::AUTHENTICATED))
             .Times(1);
       }
     }
 
     Authenticator* authenticator = new FakeAuthenticator(
         FakeAuthenticator::CLIENT, auth_round_trips, auth_action, true);
 
     client_session_.reset(client_server_->Connect(
         kHostJid, authenticator,
@@ skipping 106 matching lines @@
 
   message_loop_.RunAllPending();
 }
 
 // Verify that we can connect two endpoints.
 TEST_F(JingleSessionTest, Connect) {
   CreateServerPair(1, FakeAuthenticator::ACCEPT);
   InitiateConnection(1, FakeAuthenticator::ACCEPT, false);
 }
 
-// Verify that we can't connect two endpoints with mismatched secrets.
+// Verify that we can connect two endpoints with multi-step authentication.
+TEST_F(JingleSessionTest, ConnectMultistep) {
+  CreateServerPair(3, FakeAuthenticator::ACCEPT);
+  InitiateConnection(3, FakeAuthenticator::ACCEPT, false);
+}
+
+// Verify that connection is terminated when auth fails.
 TEST_F(JingleSessionTest, ConnectBadAuth) {
   CreateServerPair(1, FakeAuthenticator::REJECT);
   InitiateConnection(1, FakeAuthenticator::ACCEPT, true);
 }
 
+// Verify that connection is terminted when multi-step auth fails.
+TEST_F(JingleSessionTest, ConnectBadMultistepAuth) {
+  CreateServerPair(3, FakeAuthenticator::REJECT);
+  InitiateConnection(3, FakeAuthenticator::ACCEPT, true);
+}
+
 TEST_F(JingleSessionTest, ConnectBadChannelAuth) {
   CreateServerPair(1, FakeAuthenticator::REJECT_CHANNEL);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
 
   MockStreamChannelCallback client_callback;
   MockStreamChannelCallback host_callback;
 
   client_session_->CreateStreamChannel(kChannelName, base::Bind(
       &MockStreamChannelCallback::OnDone,
@@ skipping 22 matching lines @@
 
   ASSERT_NO_FATAL_FAILURE(CreateChannel());
 
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, kMessages);
   tester.Start();
   message_loop_.Run();
   tester.CheckResults();
 }
 
+// Verify that we can connect channels with multistep auth.
+TEST_F(JingleSessionTest, TestMultistepAuthTcpChannel) {
+  CreateServerPair(3, FakeAuthenticator::ACCEPT);
+  ASSERT_NO_FATAL_FAILURE(
+      InitiateConnection(3, FakeAuthenticator::ACCEPT, false));
+
+  ASSERT_NO_FATAL_FAILURE(CreateChannel());
+
+  StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
+                                kMessageSize, kMessages);
+  tester.Start();
+  message_loop_.Run();
+  tester.CheckResults();
+}
+
 // Verify that data can be transmitted over the video RTP channel.
 TEST_F(JingleSessionTest, TestUdpChannel) {
   CreateServerPair(1, FakeAuthenticator::ACCEPT);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
 
   MockDatagramChannelCallback client_callback;
   MockDatagramChannelCallback host_callback;
 
   int counter = 2;
@@ skipping 23 matching lines @@
 
   DatagramConnectionTester tester(
       client_socket, host_socket, kMessageSize, kMessages, kUdpWriteDelayMs);
   tester.Start();
   message_loop_.Run();
   tester.CheckResults();
 }
 
 }  // namespace protocol
 }  // namespace remoting