Update SignalingAddress to normalize all JIDs.

remoting/protocol/jingle_session_unittest.cc

 // Copyright (c) 2012 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/protocol/jingle_session.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/strings/string_util.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "net/socket/socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/chromium_port_allocator_factory.h"
 #include "remoting/protocol/connection_tester.h"
@@ skipping 112 matching lines @@
     base::RunLoop().RunUntilIdle();
   }
 
   void CloseSessions() {
     host_session_.reset();
     client_session_.reset();
   }
 
   void CreateSessionManagers(int auth_round_trips, int messages_till_start,
                              FakeAuthenticator::Action auth_action) {
-    host_signal_strategy_.reset(new FakeSignalStrategy(kHostJid));
-    client_signal_strategy_.reset(new FakeSignalStrategy(kClientJid));
+    if (!host_signal_strategy_)
+      host_signal_strategy_.reset(new FakeSignalStrategy(kHostJid));
+    if (!client_signal_strategy_)
+      client_signal_strategy_.reset(new FakeSignalStrategy(kClientJid));
     FakeSignalStrategy::Connect(host_signal_strategy_.get(),
                                 client_signal_strategy_.get());
 
     host_server_.reset(new JingleSessionManager(host_signal_strategy_.get()));
     host_server_->AcceptIncoming(
         base::Bind(&MockSessionManagerListener::OnIncomingSession,
                    base::Unretained(&host_server_listener_)));
 
     std::unique_ptr<AuthenticatorFactory> factory(
         new FakeHostAuthenticatorFactory(auth_round_trips, messages_till_start,
@@ skipping 66 matching lines @@
           .Times(1);
       // Expect that the connection will be closed eventually.
       EXPECT_CALL(client_session_event_handler_,
                   OnSessionStateChange(Session::CLOSED))
           .Times(AtMost(1));
     }
   }
 
   void ConnectClient(std::unique_ptr<Authenticator> authenticator) {
     client_session_ =
-        client_server_->Connect(kHostJid, std::move(authenticator));
+        client_server_->Connect(host_jid_, std::move(authenticator));
     client_session_->SetEventHandler(&client_session_event_handler_);
     client_session_->SetTransport(&client_transport_);
     base::RunLoop().RunUntilIdle();
   }
 
   void InitiateConnection(int auth_round_trips,
                           FakeAuthenticator::Action auth_action,
                           bool expect_fail) {
     SetHostExpectation(expect_fail);
     SetClientExpectation(expect_fail);
@@ skipping 10 matching lines @@
         .Times(AtLeast(1));
   }
 
   std::unique_ptr<base::MessageLoopForIO> message_loop_;
 
   NetworkSettings network_settings_;
 
   std::unique_ptr<FakeSignalStrategy> host_signal_strategy_;
   std::unique_ptr<FakeSignalStrategy> client_signal_strategy_;
 
+  std::string host_jid_ = kHostJid;
+
   std::unique_ptr<JingleSessionManager> host_server_;
   MockSessionManagerListener host_server_listener_;
   std::unique_ptr<JingleSessionManager> client_server_;
 
   std::unique_ptr<Session> host_session_;
   MockSessionEventHandler host_session_event_handler_;
   FakeTransport host_transport_;
   std::unique_ptr<Session> client_session_;
   MockSessionEventHandler client_session_event_handler_;
   FakeTransport client_transport_;
@@ skipping 39 matching lines @@
   ASSERT_GT(host_signal_strategy_->received_messages().size(), 0U);
   const buzz::XmlElement* initiate_xml =
       host_signal_strategy_->received_messages().front();
   const buzz::XmlElement* jingle_element =
       initiate_xml->FirstNamed(buzz::QName("urn:xmpp:jingle:1", "jingle"));
   ASSERT_TRUE(jingle_element);
   ASSERT_EQ(kClientJid,
             jingle_element->Attr(buzz::QName(std::string(), "initiator")));
 }
 
+TEST_F(JingleSessionTest, MixedCaseHostJid) {
+  std::string host_jid = std::string("A") + kHostJid;
+  host_signal_strategy_.reset(new FakeSignalStrategy(host_jid));
+
+  // Imitate host JID being lower-cased when stored in the directory.
+  host_jid_ = base::ToLowerASCII(host_jid);
+
+  CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
+  InitiateConnection(1, FakeAuthenticator::ACCEPT, false);
+}
+
+TEST_F(JingleSessionTest, MixedCaseClientJid) {
+  client_signal_strategy_.reset(
+      new FakeSignalStrategy(std::string("A") + kClientJid));
+  CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
+  InitiateConnection(1, FakeAuthenticator::ACCEPT, false);
+}
+
 // Verify that we can connect two endpoints with multi-step authentication.
 TEST_F(JingleSessionTest, ConnectWithMultistep) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
   InitiateConnection(3, FakeAuthenticator::ACCEPT, false);
 }
 
 TEST_F(JingleSessionTest, ConnectWithOutOfOrderIqs) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
   InitiateConnection(1, FakeAuthenticator::ACCEPT, false);
   client_signal_strategy_->SimulateMessageReordering();
@@ skipping 193 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Verify that transport-info that the first transport-info message was
   // received.
   ASSERT_EQ(client_transport_.received_messages().size(), 1U);
   EXPECT_EQ("1", client_transport_.received_messages()[0]->Attr(buzz::QN_ID));
 }
 
 }  // namespace protocol
 }  // namespace remoting