Really connect to the same server in FTP network transaction.

net/ftp/ftp_network_transaction_unittest.cc

 // Copyright (c) 2009 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 "net/ftp/ftp_network_transaction.h"
 
 #include "build/build_config.h"
 
 #include "base/ref_counted.h"
 #include "net/base/io_buffer.h"
@@ skipping 592 matching lines @@
     StaticSocketDataProvider data1(data_reads, arraysize(data_reads), NULL, 0);
     StaticSocketDataProvider data2(data_reads, arraysize(data_reads), NULL, 0);
     mock_socket_factory_.AddSocketDataProvider(ctrl_socket);
     mock_socket_factory_.AddSocketDataProvider(&data1);
     mock_socket_factory_.AddSocketDataProvider(&data2);
     FtpRequestInfo request_info = GetRequestInfo(request);
     EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
     ASSERT_EQ(ERR_IO_PENDING,
               transaction_.Start(&request_info, &callback_, NULL));
     EXPECT_NE(LOAD_STATE_IDLE, transaction_.GetLoadState());
-    EXPECT_EQ(expected_result, callback_.WaitForResult());
+    ASSERT_EQ(expected_result, callback_.WaitForResult());
     EXPECT_EQ(FtpSocketDataProvider::QUIT, ctrl_socket->state());
     if (expected_result == OK) {
       scoped_refptr<IOBuffer> io_buffer(new IOBuffer(kBufferSize));
       memset(io_buffer->data(), 0, kBufferSize);
       ASSERT_EQ(ERR_IO_PENDING,
                 transaction_.Read(io_buffer.get(), kBufferSize, &callback_));
-      EXPECT_EQ(static_cast<int>(mock_data.length()),
+      ASSERT_EQ(static_cast<int>(mock_data.length()),
                 callback_.WaitForResult());
       EXPECT_EQ(mock_data, std::string(io_buffer->data(), mock_data.length()));
       if (transaction_.GetResponseInfo()->is_directory_listing) {
         EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size);
       } else {
         // We pass an artificial value of 18 as a response to the SIZE command.
         EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size);
       }
     }
     EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
@@ skipping 15 matching lines @@
   FtpNetworkTransaction transaction_;
   TestCompletionCallback callback_;
 };
 
 TEST_F(FtpNetworkTransactionTest, FailedLookup) {
   FtpRequestInfo request_info = GetRequestInfo("ftp://badhost");
   host_resolver_->rules()->AddSimulatedFailure("badhost");
   EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Start(&request_info, &callback_, NULL));
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
+  ASSERT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
   EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransaction) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host", OK);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionMultilineWelcome) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
@@ skipping 74 matching lines @@
   };
   StaticSocketDataProvider data_socket1(data_reads, arraysize(data_reads),
                                         NULL, 0);
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket);
   mock_socket_factory_.AddSocketDataProvider(&data_socket1);
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   // Start the transaction.
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Start(&request_info, &callback_, NULL));
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  ASSERT_EQ(OK, callback_.WaitForResult());
 
   // The transaction fires the callback when we can start reading data.
   EXPECT_EQ(FtpSocketDataProvider::PRE_QUIT, ctrl_socket.state());
   EXPECT_EQ(LOAD_STATE_SENDING_REQUEST, transaction_.GetLoadState());
   scoped_refptr<IOBuffer> io_buffer(new IOBuffer(kBufferSize));
   memset(io_buffer->data(), 0, kBufferSize);
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Read(io_buffer.get(), kBufferSize, &callback_));
   EXPECT_EQ(LOAD_STATE_READING_RESPONSE, transaction_.GetLoadState());
-  EXPECT_EQ(static_cast<int>(mock_data.length()),
+  ASSERT_EQ(static_cast<int>(mock_data.length()),
             callback_.WaitForResult());
   EXPECT_EQ(LOAD_STATE_READING_RESPONSE, transaction_.GetLoadState());
   EXPECT_EQ(mock_data, std::string(io_buffer->data(), mock_data.length()));
 
   // FTP server should disconnect the data socket. It is also a signal for the
   // FtpNetworkTransaction that the data transfer is finished.
   ClientSocket* data_socket = mock_socket_factory_.GetMockTCPClientSocket(1);
   ASSERT_TRUE(data_socket);
   data_socket->Disconnect();
 
   // We should issue Reads until one returns EOF...
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Read(io_buffer.get(), kBufferSize, &callback_));
 
   // Make sure the transaction finishes cleanly.
   EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  ASSERT_EQ(OK, callback_.WaitForResult());
   EXPECT_EQ(FtpSocketDataProvider::QUIT, ctrl_socket.state());
   EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionTransferStarting) {
   FtpSocketDataProviderFileDownloadTransferStarting ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionInvalidResponse) {
@@ skipping 37 matching lines @@
   };
   StaticSocketDataProvider data_socket1(data_reads, arraysize(data_reads),
                                         NULL, 0);
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket);
   mock_socket_factory_.AddSocketDataProvider(&data_socket1);
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   // Start the transaction.
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Start(&request_info, &callback_, NULL));
-  EXPECT_EQ(OK, callback_.WaitForResult());
+  ASSERT_EQ(OK, callback_.WaitForResult());
 
   // The transaction fires the callback when we can start reading data. That
   // means that the data socket should be open.
   MockTCPClientSocket* data_socket =
       mock_socket_factory_.GetMockTCPClientSocket(1);
   ASSERT_TRUE(data_socket);
   ASSERT_TRUE(data_socket->IsConnected());
 
   // Even if the PASV response specified some other address, we connect
-  // to the address we used for control connection.
-  EXPECT_EQ("127.0.0.1", NetAddressToString(data_socket->addresses().head()));
-
-  // Make sure we have only one host entry in the AddressList.
-  EXPECT_FALSE(data_socket->addresses().head()->ai_next);
+  // to the address we used for control connection (which could be 127.0.0.1
+  // or ::1 depending on whether we use IPv6).
+  const struct addrinfo* addrinfo = data_socket->addresses().head();
+  while (addrinfo) {
+    EXPECT_NE("1.2.3.4", NetAddressToString(addrinfo));
+    addrinfo = addrinfo->ai_next;
+  }
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilLoginBadUsername) {
   FtpSocketDataProviderEvilLogin ctrl_socket("hello%0Aworld", "test");
   ExecuteTransaction(&ctrl_socket, "ftp://hello%0Aworld:test@host/file", OK);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilLoginBadPassword) {
   FtpSocketDataProviderEvilLogin ctrl_socket("test", "hello%0Dworld");
   ExecuteTransaction(&ctrl_socket, "ftp://test:hello%0Dworld@host/file", OK);
@@ skipping 13 matching lines @@
   FtpSocketDataProvider ctrl_socket1;
   ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD,
                              FtpSocketDataProvider::PRE_QUIT,
                              "530 Login authentication failed\r\n");
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1);
 
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Start(&request_info, &callback_, NULL));
-  EXPECT_EQ(ERR_FAILED, callback_.WaitForResult());
+  ASSERT_EQ(ERR_FAILED, callback_.WaitForResult());
 
   MockRead ctrl_reads[] = {
     MockRead("220 host TestFTPd\r\n"),
     MockRead("221 Goodbye!\r\n"),
     MockRead(false, OK),
   };
   MockWrite ctrl_writes[] = {
     MockWrite("QUIT\r\n"),
   };
   StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads),
                                         ctrl_writes, arraysize(ctrl_writes));
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2);
   ASSERT_EQ(ERR_IO_PENDING, transaction_.RestartWithAuth(L"foo\nownz0red",
                                                          L"innocent",
                                                          &callback_));
   EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult());
 }
 
 TEST_F(FtpNetworkTransactionTest, EvilRestartPassword) {
   FtpSocketDataProvider ctrl_socket1;
   ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD,
                              FtpSocketDataProvider::PRE_QUIT,
                              "530 Login authentication failed\r\n");
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1);
 
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Start(&request_info, &callback_, NULL));
-  EXPECT_EQ(ERR_FAILED, callback_.WaitForResult());
+  ASSERT_EQ(ERR_FAILED, callback_.WaitForResult());
 
   MockRead ctrl_reads[] = {
     MockRead("220 host TestFTPd\r\n"),
     MockRead("331 User okay, send password\r\n"),
     MockRead("221 Goodbye!\r\n"),
     MockRead(false, OK),
   };
   MockWrite ctrl_writes[] = {
     MockWrite("USER innocent\r\n"),
     MockWrite("QUIT\r\n"),
@@ skipping 242 matching lines @@
   FtpSocketDataProviderFileDownloadRetrFail ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_RETR,
                         FtpSocketDataProvider::PRE_PASV2,
                         "550 cannot open file\r\n",
                         ERR_FILE_NOT_FOUND);
 }
 
 }  // namespace net