src/chrome/browser/ui/app_list/search/webstore/webstore_provider_browsertest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/command_line.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/run_loop.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "chrome/browser/profiles/profile_manager.h"
  14 #include "chrome/browser/ui/app_list/search/chrome_search_result.h"
  15 #include "chrome/browser/ui/app_list/search/webstore/webstore_provider.h"
  16 #include "chrome/browser/ui/app_list/search/webstore/webstore_result.h"
  17 #include "chrome/common/chrome_switches.h"
  18 #include "chrome/test/base/in_process_browser_test.h"
  19 #include "content/public/browser/browser_thread.h"
  20 #include "extensions/common/extension.h"
  21 #include "net/test/embedded_test_server/embedded_test_server.h"
  22 #include "net/test/embedded_test_server/http_request.h"
  23 #include "net/test/embedded_test_server/http_response.h"
  24
  25 using content::BrowserThread;
  26 using extensions::Manifest;
  27 using net::test_server::BasicHttpResponse;
  28 using net::test_server::HttpRequest;
  29 using net::test_server::HttpResponse;
  30 using net::test_server::EmbeddedTestServer;
  31
  32 namespace app_list {
  33 namespace test {
  34 namespace {
  35
  36 // Mock results.
  37 const char kOneResult[] = "{"
  38     "\"search_url\": \"http://host/search\","
  39     "\"results\":["
  40       "{"
  41         "\"id\": \"app1_id\","
  42         "\"localized_name\": \"app1 name\","
  43         "\"icon_url\": \"http://host/icon\","
  44         "\"is_paid\": false"
  45       "}"
  46     "]}";
  47
  48 const char kThreeResults[] = "{"
  49     "\"search_url\": \"http://host/search\","
  50     "\"results\":["
  51       "{"
  52         "\"id\": \"app1_id\","
  53         "\"localized_name\": \"one\","
  54         "\"icon_url\": \"http://host/icon1\","
  55         "\"is_paid\": true,"
  56         "\"item_type\": \"PLATFORM_APP\""
  57       "},"
  58       "{"
  59         "\"id\": \"app2_id\","
  60         "\"localized_name\": \"two\","
  61         "\"icon_url\": \"http://host/icon2\","
  62         "\"is_paid\": false,"
  63         "\"item_type\": \"HOSTED_APP\""
  64       "},"
  65       "{"
  66         "\"id\": \"app3_id\","
  67         "\"localized_name\": \"three\","
  68         "\"icon_url\": \"http://host/icon3\","
  69         "\"is_paid\": false,"
  70         "\"item_type\": \"LEGACY_PACKAGED_APP\""
  71       "}"
  72     "]}";
  73
  74 struct ParsedSearchResult {
  75   const char* id;
  76   const char* title;
  77   const char* icon_url;
  78   bool is_paid;
  79   Manifest::Type item_type;
  80   size_t num_actions;
  81 };
  82
  83 ParsedSearchResult kParsedOneResult[] = {{"app1_id", "app1 name",
  84                                           "http://host/icon", false,
  85                                           Manifest::TYPE_UNKNOWN, 1}};
  86
  87 ParsedSearchResult kParsedThreeResults[] = {
  88     {"app1_id", "one", "http://host/icon1", true, Manifest::TYPE_PLATFORM_APP,
  89      1},
  90     {"app2_id", "two", "http://host/icon2", false, Manifest::TYPE_HOSTED_APP,
  91      2},
  92     {"app3_id", "three", "http://host/icon3", false,
  93      Manifest::TYPE_LEGACY_PACKAGED_APP, 1}};
  94
  95 }  // namespace
  96
  97 class WebstoreProviderTest : public InProcessBrowserTest {
  98  public:
  99   WebstoreProviderTest() {}
 100   virtual ~WebstoreProviderTest() {}
 101
 102   // InProcessBrowserTest overrides:
 103   virtual void SetUpOnMainThread() OVERRIDE {
 104     test_server_.reset(new EmbeddedTestServer);
 105
 106     ASSERT_TRUE(test_server_->InitializeAndWaitUntilReady());
 107     test_server_->RegisterRequestHandler(
 108         base::Bind(&WebstoreProviderTest::HandleRequest,
 109                    base::Unretained(this)));
 110     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 111         switches::kAppsGalleryURL, test_server_->base_url().spec());
 112     CommandLine::ForCurrentProcess()->AppendSwitch(
 113         switches::kEnableEphemeralApps);
 114
 115     webstore_provider_.reset(new WebstoreProvider(
 116         ProfileManager::GetActiveUserProfile(), NULL));
 117     webstore_provider_->set_webstore_search_fetched_callback(
 118         base::Bind(&WebstoreProviderTest::OnSearchResultsFetched,
 119                    base::Unretained(this)));
 120     // TODO(mukai): add test cases for throttling.
 121     webstore_provider_->set_use_throttling(false);
 122   }
 123
 124   virtual void TearDownOnMainThread() OVERRIDE {
 125     EXPECT_TRUE(test_server_->ShutdownAndWaitUntilComplete());
 126     test_server_.reset();
 127   }
 128
 129   void RunQuery(const std::string& query,
 130                 const std::string& mock_server_response) {
 131     webstore_provider_->Start(base::UTF8ToUTF16(query));
 132
 133     if (webstore_provider_->webstore_search_ && !mock_server_response.empty()) {
 134       mock_server_response_ = mock_server_response;
 135
 136       DCHECK(!run_loop_);
 137       run_loop_.reset(new base::RunLoop);
 138       run_loop_->Run();
 139       run_loop_.reset();
 140
 141       mock_server_response_.clear();
 142     }
 143
 144     webstore_provider_->Stop();
 145   }
 146
 147   std::string GetResultTitles() const {
 148     std::string results;
 149     for (SearchProvider::Results::const_iterator it =
 150              webstore_provider_->results().begin();
 151          it != webstore_provider_->results().end();
 152          ++it) {
 153       if (!results.empty())
 154         results += ',';
 155       results += base::UTF16ToUTF8((*it)->title());
 156     }
 157     return results;
 158   }
 159
 160   void VerifyResults(const ParsedSearchResult* expected_results,
 161                      size_t expected_result_size) {
 162     ASSERT_EQ(expected_result_size, webstore_provider_->results().size());
 163     for (size_t i = 0; i < expected_result_size; ++i) {
 164       const SearchResult* result = webstore_provider_->results()[i];
 165       ASSERT_EQ(extensions::Extension::GetBaseURLFromExtensionId(
 166                     expected_results[i].id).spec(),
 167                 result->id());
 168       EXPECT_EQ(std::string(expected_results[i].title),
 169                 base::UTF16ToUTF8(result->title()));
 170
 171       // Ensure the number of action buttons is appropriate for the item type.
 172       EXPECT_EQ(expected_results[i].num_actions, result->actions().size());
 173
 174       const WebstoreResult* webstore_result =
 175           static_cast<const WebstoreResult*>(result);
 176       EXPECT_EQ(expected_results[i].id, webstore_result->app_id());
 177       EXPECT_EQ(expected_results[i].icon_url,
 178                 webstore_result->icon_url().spec());
 179       EXPECT_EQ(expected_results[i].is_paid, webstore_result->is_paid());
 180       EXPECT_EQ(expected_results[i].item_type, webstore_result->item_type());
 181     }
 182   }
 183
 184   void RunQueryAndVerify(const std::string& query,
 185                          const std::string& mock_server_response,
 186                          const ParsedSearchResult* expected_results,
 187                          size_t expected_result_size) {
 188     RunQuery(query, mock_server_response);
 189     VerifyResults(expected_results, expected_result_size);
 190   }
 191
 192   WebstoreProvider* webstore_provider() { return webstore_provider_.get(); }
 193
 194  private:
 195   scoped_ptr<HttpResponse> HandleRequest(const HttpRequest& request) {
 196     scoped_ptr<BasicHttpResponse> response(new BasicHttpResponse);
 197
 198     if (request.relative_url.find("/jsonsearch?") != std::string::npos) {
 199       if (mock_server_response_ == "404") {
 200         response->set_code(net::HTTP_NOT_FOUND);
 201       } else if (mock_server_response_ == "500") {
 202         response->set_code(net::HTTP_INTERNAL_SERVER_ERROR);
 203       } else {
 204         response->set_code(net::HTTP_OK);
 205         response->set_content(mock_server_response_);
 206       }
 207     }
 208
 209     return response.PassAs<HttpResponse>();
 210   }
 211
 212   void OnSearchResultsFetched() {
 213     if (run_loop_)
 214       run_loop_->Quit();
 215   }
 216
 217   scoped_ptr<EmbeddedTestServer> test_server_;
 218   scoped_ptr<base::RunLoop> run_loop_;
 219
 220   std::string mock_server_response_;
 221
 222   scoped_ptr<WebstoreProvider> webstore_provider_;
 223
 224   DISALLOW_COPY_AND_ASSIGN(WebstoreProviderTest);
 225 };
 226
 227 // Flaky on CrOS and Windows: http://crbug.com/246136.
 228 // TODO(erg): linux_aura bringup: http://crbug.com/163931
 229 #if defined(OS_WIN) || defined(OS_LINUX)
 230 #define MAYBE_Basic DISABLED_Basic
 231 #else
 232 #define MAYBE_Basic Basic
 233 #endif
 234 IN_PROC_BROWSER_TEST_F(WebstoreProviderTest, MAYBE_Basic) {
 235   struct {
 236     const char* query;
 237     const char* mock_server_response;
 238     const char* expected_result_titles;
 239     const ParsedSearchResult* expected_results;
 240     size_t expected_result_size;
 241   } kTestCases[] = {
 242     // "Search in web store" result with query text itself is used for
 243     // synchronous placeholder, bad server response etc.
 244     {"synchronous", "", "synchronous", NULL, 0 },
 245     {"404", "404", "404", NULL, 0 },
 246     {"500", "500", "500", NULL, 0 },
 247     {"bad json", "invalid json", "bad json", NULL, 0 },
 248     // Good results.
 249     {"1 result", kOneResult, "app1 name", kParsedOneResult, 1 },
 250     {"3 result", kThreeResults, "one,two,three", kParsedThreeResults, 3 },
 251   };
 252
 253   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
 254     if (kTestCases[i].expected_result_titles) {
 255       RunQuery(kTestCases[i].query, kTestCases[i].mock_server_response);
 256       ASSERT_EQ(kTestCases[i].expected_result_titles, GetResultTitles())
 257           << "Case " << i << ": q=" << kTestCases[i].query;
 258
 259       if (kTestCases[i].expected_results) {
 260         VerifyResults(kTestCases[i].expected_results,
 261                       kTestCases[i].expected_result_size);
 262       }
 263     }
 264   }
 265 }
 266
 267 IN_PROC_BROWSER_TEST_F(WebstoreProviderTest, NoSearchForSensitiveData) {
 268   // None of the following input strings should be accepted because they may
 269   // contain private data.
 270   const char* inputs[] = {
 271     // file: scheme is bad.
 272     "file://filename",
 273     "FILE://filename",
 274     // URLs with usernames, ports, queries or refs are bad.
 275     "http://username:password@hostname/",
 276     "http://www.example.com:1000",
 277     "http://foo:1000",
 278     "http://hostname/?query=q",
 279     "http://hostname/path#ref",
 280     // A https URL with path is bad.
 281     "https://hostname/path",
 282   };
 283
 284   for (size_t i = 0; i < arraysize(inputs); ++i) {
 285     RunQueryAndVerify(inputs[i], kOneResult, NULL, 0);
 286   }
 287 }
 288
 289 IN_PROC_BROWSER_TEST_F(WebstoreProviderTest, NoSearchForShortQueries) {
 290   RunQueryAndVerify("a", kOneResult, NULL, 0);
 291   RunQueryAndVerify("ab", kOneResult, NULL, 0);
 292   RunQueryAndVerify("abc", kOneResult, kParsedOneResult, 1);
 293 }
 294
 295 // Flaky on CrOS and Windows: http://crbug.com/246136.
 296 #if defined(OS_WIN) || defined(OS_CHROMEOS)
 297 #define MAYBE_SearchCache DISABLED_SearchCache
 298 #else
 299 #define MAYBE_SearchCache SearchCache
 300 #endif
 301 IN_PROC_BROWSER_TEST_F(WebstoreProviderTest, MAYBE_SearchCache) {
 302   RunQueryAndVerify("foo", kOneResult, kParsedOneResult, 1);
 303
 304   // No result is provided but the provider gets the result from the cache.
 305   RunQueryAndVerify("foo", "", kParsedOneResult, 1);
 306 }
 307
 308 }  // namespace test
 309 }  // namespace app_list