Updating the Chromoting Test Driver to target the test environment

remoting/test/host_list_fetcher_unittest.cc

 // Copyright 2015 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/test/host_list_fetcher.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 188 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(HostListFetcherTest);
 };
 
 void HostListFetcherTest::SetUp() {
   DCHECK(!message_loop_);
   message_loop_.reset(new base::MessageLoopForIO);
 
   SetFakeResponse(GURL(kHostListProdRequestUrl),
                   kHostListEmptyResponse, net::HTTP_NOT_FOUND,
                   net::URLRequestStatus::FAILED);
+
+  SetFakeResponse(GURL(kHostListTestRequestUrl), kHostListEmptyResponse,
+                  net::HTTP_NOT_FOUND, net::URLRequestStatus::FAILED);
 }
 
 void HostListFetcherTest::SetFakeResponse(
     const GURL& url,
     const std::string& data,
     net::HttpStatusCode code,
     net::URLRequestStatus::Status status) {
   url_fetcher_factory_.SetFakeResponse(url, data, code, status);
 }
 
 TEST_F(HostListFetcherTest, RetrieveHostListFromProd) {
   SetFakeResponse(GURL(kHostListProdRequestUrl),
                   kHostListReadyResponse, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
 
   std::vector<HostInfo> hostlist;
 
   base::RunLoop run_loop;
   HostListFetcher::HostlistCallback host_list_callback =
       base::Bind(&OnHostlistRetrieved, run_loop.QuitClosure(), &hostlist);
 
   HostListFetcher host_list_fetcher;
-  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, host_list_callback);
+  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, kHostListProdRequestUrl,
+                                     host_list_callback);
 
   run_loop.Run();
 
+  EXPECT_EQ(hostlist.size(), kExpectedHostListSize);
+
+  HostInfo online_host_info = hostlist.at(0);
+  EXPECT_EQ(online_host_info.token_url_patterns.size(), kExpectedPatternsSize);
+  EXPECT_FALSE(online_host_info.host_id.empty());
+  EXPECT_FALSE(online_host_info.host_jid.empty());
+  EXPECT_FALSE(online_host_info.host_name.empty());
+  EXPECT_EQ(online_host_info.status, HostStatus::kHostStatusOnline);
+  EXPECT_TRUE(online_host_info.offline_reason.empty());
+  EXPECT_FALSE(online_host_info.public_key.empty());
+
+  HostInfo offline_host_info = hostlist.at(1);
+  EXPECT_TRUE(offline_host_info.token_url_patterns.empty());
+  EXPECT_FALSE(offline_host_info.host_id.empty());
+  EXPECT_FALSE(offline_host_info.host_jid.empty());
+  EXPECT_FALSE(offline_host_info.host_name.empty());
+  EXPECT_EQ(offline_host_info.status, HostStatus::kHostStatusOffline);
+  EXPECT_FALSE(offline_host_info.offline_reason.empty());
+  EXPECT_FALSE(offline_host_info.public_key.empty());
+}
+
+TEST_F(HostListFetcherTest, RetrieveHostListFromTest) {
+  SetFakeResponse(GURL(kHostListTestRequestUrl), kHostListReadyResponse,
+                  net::HTTP_OK, net::URLRequestStatus::SUCCESS);
+
+  std::vector<HostInfo> hostlist;
+
+  base::RunLoop run_loop;
+  HostListFetcher::HostlistCallback host_list_callback =
+      base::Bind(&OnHostlistRetrieved, run_loop.QuitClosure(), &hostlist);
+
+  HostListFetcher host_list_fetcher;
+  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, kHostListTestRequestUrl,
+                                     host_list_callback);
+
+  run_loop.Run();
+
   EXPECT_EQ(hostlist.size(), kExpectedHostListSize);
 
   HostInfo online_host_info = hostlist.at(0);
   EXPECT_EQ(online_host_info.token_url_patterns.size(), kExpectedPatternsSize);
   EXPECT_FALSE(online_host_info.host_id.empty());
   EXPECT_FALSE(online_host_info.host_jid.empty());
   EXPECT_FALSE(online_host_info.host_name.empty());
   EXPECT_EQ(online_host_info.status, HostStatus::kHostStatusOnline);
   EXPECT_TRUE(online_host_info.offline_reason.empty());
   EXPECT_FALSE(online_host_info.public_key.empty());
@@ skipping 13 matching lines @@
                   kHostListEmptyTokenUrlPatternsResponse, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
 
   std::vector<HostInfo> hostlist;
 
   base::RunLoop run_loop;
   HostListFetcher::HostlistCallback host_list_callback =
       base::Bind(&OnHostlistRetrieved, run_loop.QuitClosure(), &hostlist);
 
   HostListFetcher host_list_fetcher;
-  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, host_list_callback);
+  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, kHostListProdRequestUrl,
+                                     host_list_callback);
 
   run_loop.Run();
 
   EXPECT_EQ(hostlist.size(), kExpectedEmptyPatternsHostListSize);
 
   // While this is unlikely to happen, empty token url patterns are handled.
   HostInfo online_host_info = hostlist.at(0);
   EXPECT_TRUE(online_host_info.token_url_patterns.empty());
   EXPECT_FALSE(online_host_info.host_id.empty());
   EXPECT_FALSE(online_host_info.host_jid.empty());
   EXPECT_FALSE(online_host_info.host_name.empty());
   EXPECT_EQ(online_host_info.status, HostStatus::kHostStatusOnline);
   EXPECT_TRUE(online_host_info.offline_reason.empty());
   EXPECT_FALSE(online_host_info.public_key.empty());
 }
 
 TEST_F(HostListFetcherTest,
     RetrieveHostListMissingParametersResponse) {
   SetFakeResponse(GURL(kHostListProdRequestUrl),
                   kHostListMissingParametersResponse, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
 
   std::vector<HostInfo> hostlist;
 
   base::RunLoop run_loop;
   HostListFetcher::HostlistCallback host_list_callback =
       base::Bind(&OnHostlistRetrieved, run_loop.QuitClosure(), &hostlist);
 
   HostListFetcher host_list_fetcher;
-  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, host_list_callback);
+  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, kHostListProdRequestUrl,
+                                     host_list_callback);
   run_loop.Run();
 
   EXPECT_EQ(hostlist.size(), kExpectedHostListSize);
 
   HostInfo no_jid_host_info = hostlist.at(0);
   EXPECT_EQ(no_jid_host_info.token_url_patterns.size(), kExpectedPatternsSize);
   EXPECT_FALSE(no_jid_host_info.host_id.empty());
   EXPECT_TRUE(no_jid_host_info.host_jid.empty());
   EXPECT_FALSE(no_jid_host_info.host_name.empty());
   EXPECT_EQ(no_jid_host_info.status, HostStatus::kHostStatusOffline);
@@ skipping 13 matching lines @@
 
 TEST_F(HostListFetcherTest, RetrieveHostListNetworkError) {
   base::RunLoop run_loop;
 
   std::vector<HostInfo> hostlist;
 
   HostListFetcher::HostlistCallback host_list_callback =
       base::Bind(&OnHostlistRetrieved, run_loop.QuitClosure(), &hostlist);
 
   HostListFetcher host_list_fetcher;
-  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, host_list_callback);
+  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, kHostListProdRequestUrl,
+                                     host_list_callback);
   run_loop.Run();
 
   // If there was a network error retrieving the host list, then the host list
   // should be empty.
   EXPECT_TRUE(hostlist.empty());
 }
 
 TEST_F(HostListFetcherTest, RetrieveHostListEmptyItemsResponse) {
   SetFakeResponse(GURL(kHostListProdRequestUrl),
                   kHostListEmptyItemsResponse, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
 
   base::RunLoop run_loop;
 
   std::vector<HostInfo> hostlist;
 
   HostListFetcher::HostlistCallback host_list_callback =
       base::Bind(&OnHostlistRetrieved, run_loop.QuitClosure(), &hostlist);
 
   HostListFetcher host_list_fetcher;
-  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, host_list_callback);
+  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, kHostListProdRequestUrl,
+                                     host_list_callback);
   run_loop.Run();
 
   // If we received an empty items response, then host list should be empty.
   EXPECT_TRUE(hostlist.empty());
 }
 
 TEST_F(HostListFetcherTest, RetrieveHostListEmptyResponse) {
   SetFakeResponse(GURL(kHostListProdRequestUrl),
                   kHostListEmptyResponse, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
 
   base::RunLoop run_loop;
 
   std::vector<HostInfo> hostlist;
 
   HostListFetcher::HostlistCallback host_list_callback =
       base::Bind(&OnHostlistRetrieved, run_loop.QuitClosure(), &hostlist);
 
   HostListFetcher host_list_fetcher;
-  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, host_list_callback);
+  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, kHostListProdRequestUrl,
+                                     host_list_callback);
   run_loop.Run();
 
   // If we received an empty response, then host list should be empty.
   EXPECT_TRUE(hostlist.empty());
 }
 
 TEST_F(HostListFetcherTest, MultipleRetrieveHostListRequests) {
   // First, we will retrieve a valid response from the directory service.
   SetFakeResponse(GURL(kHostListProdRequestUrl),
                   kHostListReadyResponse, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
 
   std::vector<HostInfo> ready_hostlist;
 
   base::RunLoop ready_run_loop;
   HostListFetcher::HostlistCallback ready_host_list_callback =
       base::Bind(&OnHostlistRetrieved,
                  ready_run_loop.QuitClosure(),
                  &ready_hostlist);
 
   HostListFetcher host_list_fetcher;
-  host_list_fetcher.RetrieveHostlist(kAccessTokenValue,
+  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, kHostListProdRequestUrl,
                                      ready_host_list_callback);
 
   ready_run_loop.Run();
 
   EXPECT_EQ(ready_hostlist.size(), kExpectedHostListSize);
 
   HostInfo online_host_info = ready_hostlist.at(0);
   EXPECT_EQ(online_host_info.token_url_patterns.size(), kExpectedPatternsSize);
   EXPECT_FALSE(online_host_info.host_id.empty());
   EXPECT_FALSE(online_host_info.host_jid.empty());
@@ skipping 19 matching lines @@
   std::vector<HostInfo> empty_items_hostlist;
 
   base::RunLoop empty_items_run_loop;
 
   HostListFetcher::HostlistCallback empty_host_list_callback =
       base::Bind(&OnHostlistRetrieved,
                  empty_items_run_loop.QuitClosure(),
                  &empty_items_hostlist);
 
   // Re-use the same host_list_fetcher.
-  host_list_fetcher.RetrieveHostlist(kAccessTokenValue,
+  host_list_fetcher.RetrieveHostlist(kAccessTokenValue, kHostListProdRequestUrl,
                                      empty_host_list_callback);
 
   empty_items_run_loop.Run();
 
   // If we received an empty items response, then host list should be empty.
   EXPECT_TRUE(empty_items_hostlist.empty());
 }
 
 }  // namespace test
 }  // namespace remoting