chrome/browser/extensions/extension_apitest.cc

   1 // Copyright (c) 2012 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 "chrome/browser/extensions/extension_apitest.h"
   6
   7 #include "base/strings/string_split.h"
   8 #include "base/strings/string_util.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "chrome/browser/chrome_notification_types.h"
  11 #include "chrome/browser/extensions/extension_service.h"
  12 #include "chrome/browser/extensions/unpacked_installer.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/browser/ui/browser.h"
  15 #include "chrome/browser/ui/extensions/application_launch.h"
  16 #include "chrome/test/base/ui_test_utils.h"
  17 #include "content/public/browser/notification_registrar.h"
  18 #include "content/public/browser/notification_service.h"
  19 #include "extensions/browser/api/test/test_api.h"
  20 #include "extensions/browser/extension_system.h"
  21 #include "extensions/common/extension.h"
  22 #include "extensions/common/extension_set.h"
  23 #include "net/base/escape.h"
  24 #include "net/base/filename_util.h"
  25 #include "net/test/embedded_test_server/embedded_test_server.h"
  26 #include "net/test/embedded_test_server/http_request.h"
  27 #include "net/test/embedded_test_server/http_response.h"
  28 #include "net/test/spawned_test_server/spawned_test_server.h"
  29
  30 namespace {
  31
  32 const char kTestCustomArg[] = "customArg";
  33 const char kTestServerPort[] = "testServer.port";
  34 const char kTestDataDirectory[] = "testDataDirectory";
  35 const char kTestWebSocketPort[] = "testWebSocketPort";
  36 const char kFtpServerPort[] = "ftpServer.port";
  37 const char kSpawnedTestServerPort[] = "spawnedTestServer.port";
  38
  39 scoped_ptr<net::test_server::HttpResponse> HandleServerRedirectRequest(
  40     const net::test_server::HttpRequest& request) {
  41   if (!StartsWithASCII(request.relative_url, "/server-redirect?", true))
  42     return scoped_ptr<net::test_server::HttpResponse>();
  43
  44   size_t query_string_pos = request.relative_url.find('?');
  45   std::string redirect_target =
  46       request.relative_url.substr(query_string_pos + 1);
  47
  48   scoped_ptr<net::test_server::BasicHttpResponse> http_response(
  49       new net::test_server::BasicHttpResponse);
  50   http_response->set_code(net::HTTP_MOVED_PERMANENTLY);
  51   http_response->AddCustomHeader("Location", redirect_target);
  52   return http_response.PassAs<net::test_server::HttpResponse>();
  53 }
  54
  55 scoped_ptr<net::test_server::HttpResponse> HandleEchoHeaderRequest(
  56     const net::test_server::HttpRequest& request) {
  57   if (!StartsWithASCII(request.relative_url, "/echoheader?", true))
  58     return scoped_ptr<net::test_server::HttpResponse>();
  59
  60   size_t query_string_pos = request.relative_url.find('?');
  61   std::string header_name =
  62       request.relative_url.substr(query_string_pos + 1);
  63
  64   std::string header_value;
  65   std::map<std::string, std::string>::const_iterator it = request.headers.find(
  66       header_name);
  67   if (it != request.headers.end())
  68     header_value = it->second;
  69
  70   scoped_ptr<net::test_server::BasicHttpResponse> http_response(
  71       new net::test_server::BasicHttpResponse);
  72   http_response->set_code(net::HTTP_OK);
  73   http_response->set_content(header_value);
  74   return http_response.PassAs<net::test_server::HttpResponse>();
  75 }
  76
  77 scoped_ptr<net::test_server::HttpResponse> HandleSetCookieRequest(
  78     const net::test_server::HttpRequest& request) {
  79   if (!StartsWithASCII(request.relative_url, "/set-cookie?", true))
  80     return scoped_ptr<net::test_server::HttpResponse>();
  81
  82   scoped_ptr<net::test_server::BasicHttpResponse> http_response(
  83       new net::test_server::BasicHttpResponse);
  84   http_response->set_code(net::HTTP_OK);
  85
  86   size_t query_string_pos = request.relative_url.find('?');
  87   std::string cookie_value =
  88       request.relative_url.substr(query_string_pos + 1);
  89
  90   std::vector<std::string> cookies;
  91   base::SplitString(cookie_value, '&', &cookies);
  92
  93   for (size_t i = 0; i < cookies.size(); i++)
  94     http_response->AddCustomHeader("Set-Cookie", cookies[i]);
  95
  96   return http_response.PassAs<net::test_server::HttpResponse>();
  97 }
  98
  99 scoped_ptr<net::test_server::HttpResponse> HandleSetHeaderRequest(
 100     const net::test_server::HttpRequest& request) {
 101   if (!StartsWithASCII(request.relative_url, "/set-header?", true))
 102     return scoped_ptr<net::test_server::HttpResponse>();
 103
 104   size_t query_string_pos = request.relative_url.find('?');
 105   std::string escaped_header =
 106       request.relative_url.substr(query_string_pos + 1);
 107
 108   std::string header =
 109       net::UnescapeURLComponent(escaped_header,
 110                                 net::UnescapeRule::NORMAL |
 111                                 net::UnescapeRule::SPACES |
 112                                 net::UnescapeRule::URL_SPECIAL_CHARS);
 113
 114   size_t colon_pos = header.find(':');
 115   if (colon_pos == std::string::npos)
 116     return scoped_ptr<net::test_server::HttpResponse>();
 117
 118   std::string header_name = header.substr(0, colon_pos);
 119   // Skip space after colon.
 120   std::string header_value = header.substr(colon_pos + 2);
 121
 122   scoped_ptr<net::test_server::BasicHttpResponse> http_response(
 123       new net::test_server::BasicHttpResponse);
 124   http_response->set_code(net::HTTP_OK);
 125   http_response->AddCustomHeader(header_name, header_value);
 126   return http_response.PassAs<net::test_server::HttpResponse>();
 127 }
 128
 129 };  // namespace
 130
 131 ExtensionApiTest::ExtensionApiTest() {
 132   embedded_test_server()->RegisterRequestHandler(
 133       base::Bind(&HandleServerRedirectRequest));
 134   embedded_test_server()->RegisterRequestHandler(
 135       base::Bind(&HandleEchoHeaderRequest));
 136   embedded_test_server()->RegisterRequestHandler(
 137       base::Bind(&HandleSetCookieRequest));
 138   embedded_test_server()->RegisterRequestHandler(
 139       base::Bind(&HandleSetHeaderRequest));
 140 }
 141
 142 ExtensionApiTest::~ExtensionApiTest() {}
 143
 144 ExtensionApiTest::ResultCatcher::ResultCatcher()
 145     : profile_restriction_(NULL),
 146       waiting_(false) {
 147   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_TEST_PASSED,
 148                  content::NotificationService::AllSources());
 149   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_TEST_FAILED,
 150                  content::NotificationService::AllSources());
 151 }
 152
 153 ExtensionApiTest::ResultCatcher::~ResultCatcher() {
 154 }
 155
 156 bool ExtensionApiTest::ResultCatcher::GetNextResult() {
 157   // Depending on the tests, multiple results can come in from a single call
 158   // to RunMessageLoop(), so we maintain a queue of results and just pull them
 159   // off as the test calls this, going to the run loop only when the queue is
 160   // empty.
 161   if (results_.empty()) {
 162     waiting_ = true;
 163     content::RunMessageLoop();
 164     waiting_ = false;
 165   }
 166
 167   if (!results_.empty()) {
 168     bool ret = results_.front();
 169     results_.pop_front();
 170     message_ = messages_.front();
 171     messages_.pop_front();
 172     return ret;
 173   }
 174
 175   NOTREACHED();
 176   return false;
 177 }
 178
 179 void ExtensionApiTest::ResultCatcher::Observe(
 180     int type, const content::NotificationSource& source,
 181     const content::NotificationDetails& details) {
 182   if (profile_restriction_ &&
 183       content::Source<Profile>(source).ptr() != profile_restriction_) {
 184     return;
 185   }
 186
 187   switch (type) {
 188     case chrome::NOTIFICATION_EXTENSION_TEST_PASSED:
 189       VLOG(1) << "Got EXTENSION_TEST_PASSED notification.";
 190       results_.push_back(true);
 191       messages_.push_back(std::string());
 192       if (waiting_)
 193         base::MessageLoopForUI::current()->Quit();
 194       break;
 195
 196     case chrome::NOTIFICATION_EXTENSION_TEST_FAILED:
 197       VLOG(1) << "Got EXTENSION_TEST_FAILED notification.";
 198       results_.push_back(false);
 199       messages_.push_back(*(content::Details<std::string>(details).ptr()));
 200       if (waiting_)
 201         base::MessageLoopForUI::current()->Quit();
 202       break;
 203
 204     default:
 205       NOTREACHED();
 206   }
 207 }
 208
 209 void ExtensionApiTest::SetUpInProcessBrowserTestFixture() {
 210   DCHECK(!test_config_.get()) << "Previous test did not clear config state.";
 211   test_config_.reset(new base::DictionaryValue());
 212   test_config_->SetString(kTestDataDirectory,
 213                           net::FilePathToFileURL(test_data_dir_).spec());
 214   test_config_->SetInteger(kTestWebSocketPort, 0);
 215   extensions::TestGetConfigFunction::set_test_config_state(
 216       test_config_.get());
 217 }
 218
 219 void ExtensionApiTest::TearDownInProcessBrowserTestFixture() {
 220   extensions::TestGetConfigFunction::set_test_config_state(NULL);
 221   test_config_.reset(NULL);
 222 }
 223
 224 bool ExtensionApiTest::RunExtensionTest(const std::string& extension_name) {
 225   return RunExtensionTestImpl(
 226       extension_name, std::string(), NULL, kFlagEnableFileAccess);
 227 }
 228
 229 bool ExtensionApiTest::RunExtensionTestIncognito(
 230     const std::string& extension_name) {
 231   return RunExtensionTestImpl(extension_name,
 232                               std::string(),
 233                               NULL,
 234                               kFlagEnableIncognito | kFlagEnableFileAccess);
 235 }
 236
 237 bool ExtensionApiTest::RunExtensionTestIgnoreManifestWarnings(
 238     const std::string& extension_name) {
 239   return RunExtensionTestImpl(
 240       extension_name, std::string(), NULL, kFlagIgnoreManifestWarnings);
 241 }
 242
 243 bool ExtensionApiTest::RunExtensionTestAllowOldManifestVersion(
 244     const std::string& extension_name) {
 245   return RunExtensionTestImpl(
 246       extension_name,
 247       std::string(),
 248       NULL,
 249       kFlagEnableFileAccess | kFlagAllowOldManifestVersions);
 250 }
 251
 252 bool ExtensionApiTest::RunComponentExtensionTest(
 253     const std::string& extension_name) {
 254   return RunExtensionTestImpl(extension_name,
 255                               std::string(),
 256                               NULL,
 257                               kFlagEnableFileAccess | kFlagLoadAsComponent);
 258 }
 259
 260 bool ExtensionApiTest::RunExtensionTestNoFileAccess(
 261     const std::string& extension_name) {
 262   return RunExtensionTestImpl(extension_name, std::string(), NULL, kFlagNone);
 263 }
 264
 265 bool ExtensionApiTest::RunExtensionTestIncognitoNoFileAccess(
 266     const std::string& extension_name) {
 267   return RunExtensionTestImpl(
 268       extension_name, std::string(), NULL, kFlagEnableIncognito);
 269 }
 270
 271 bool ExtensionApiTest::RunExtensionSubtest(const std::string& extension_name,
 272                                            const std::string& page_url) {
 273   return RunExtensionSubtest(extension_name, page_url, kFlagEnableFileAccess);
 274 }
 275
 276 bool ExtensionApiTest::RunExtensionSubtest(const std::string& extension_name,
 277                                            const std::string& page_url,
 278                                            int flags) {
 279   DCHECK(!page_url.empty()) << "Argument page_url is required.";
 280   // See http://crbug.com/177163 for details.
 281 #if defined(OS_WIN) && !defined(NDEBUG)
 282   LOG(WARNING) << "Workaround for 177163, prematurely returning";
 283   return true;
 284 #else
 285   return RunExtensionTestImpl(extension_name, page_url, NULL, flags);
 286 #endif
 287 }
 288
 289
 290 bool ExtensionApiTest::RunPageTest(const std::string& page_url) {
 291   return RunExtensionSubtest(std::string(), page_url);
 292 }
 293
 294 bool ExtensionApiTest::RunPageTest(const std::string& page_url,
 295                                    int flags) {
 296   return RunExtensionSubtest(std::string(), page_url, flags);
 297 }
 298
 299 bool ExtensionApiTest::RunPlatformAppTest(const std::string& extension_name) {
 300   return RunExtensionTestImpl(
 301       extension_name, std::string(), NULL, kFlagLaunchPlatformApp);
 302 }
 303
 304 bool ExtensionApiTest::RunPlatformAppTestWithArg(
 305     const std::string& extension_name, const char* custom_arg) {
 306   return RunExtensionTestImpl(
 307       extension_name, std::string(), custom_arg, kFlagLaunchPlatformApp);
 308 }
 309
 310 bool ExtensionApiTest::RunPlatformAppTestWithFlags(
 311     const std::string& extension_name, int flags) {
 312   return RunExtensionTestImpl(
 313       extension_name, std::string(), NULL, flags | kFlagLaunchPlatformApp);
 314 }
 315
 316 // Load |extension_name| extension and/or |page_url| and wait for
 317 // PASSED or FAILED notification.
 318 bool ExtensionApiTest::RunExtensionTestImpl(const std::string& extension_name,
 319                                             const std::string& page_url,
 320                                             const char* custom_arg,
 321                                             int flags) {
 322   bool load_as_component = (flags & kFlagLoadAsComponent) != 0;
 323   bool launch_platform_app = (flags & kFlagLaunchPlatformApp) != 0;
 324   bool use_incognito = (flags & kFlagUseIncognito) != 0;
 325
 326   if (custom_arg && custom_arg[0])
 327     test_config_->SetString(kTestCustomArg, custom_arg);
 328
 329   ResultCatcher catcher;
 330   DCHECK(!extension_name.empty() || !page_url.empty()) <<
 331       "extension_name and page_url cannot both be empty";
 332
 333   const extensions::Extension* extension = NULL;
 334   if (!extension_name.empty()) {
 335     base::FilePath extension_path = test_data_dir_.AppendASCII(extension_name);
 336     if (load_as_component) {
 337       extension = LoadExtensionAsComponent(extension_path);
 338     } else {
 339       int browser_test_flags = ExtensionBrowserTest::kFlagNone;
 340       if (flags & kFlagEnableIncognito)
 341         browser_test_flags |= ExtensionBrowserTest::kFlagEnableIncognito;
 342       if (flags & kFlagEnableFileAccess)
 343         browser_test_flags |= ExtensionBrowserTest::kFlagEnableFileAccess;
 344       if (flags & kFlagIgnoreManifestWarnings)
 345         browser_test_flags |= ExtensionBrowserTest::kFlagIgnoreManifestWarnings;
 346       if (flags & kFlagAllowOldManifestVersions) {
 347         browser_test_flags |=
 348             ExtensionBrowserTest::kFlagAllowOldManifestVersions;
 349       }
 350       extension = LoadExtensionWithFlags(extension_path, browser_test_flags);
 351     }
 352     if (!extension) {
 353       message_ = "Failed to load extension.";
 354       return false;
 355     }
 356   }
 357
 358   // If there is a page_url to load, navigate it.
 359   if (!page_url.empty()) {
 360     GURL url = GURL(page_url);
 361
 362     // Note: We use is_valid() here in the expectation that the provided url
 363     // may lack a scheme & host and thus be a relative url within the loaded
 364     // extension.
 365     if (!url.is_valid()) {
 366       DCHECK(!extension_name.empty()) <<
 367           "Relative page_url given with no extension_name";
 368
 369       url = extension->GetResourceURL(page_url);
 370     }
 371
 372     if (use_incognito)
 373       ui_test_utils::OpenURLOffTheRecord(browser()->profile(), url);
 374     else
 375       ui_test_utils::NavigateToURL(browser(), url);
 376   } else if (launch_platform_app) {
 377     AppLaunchParams params(browser()->profile(),
 378                            extension,
 379                            extensions::LAUNCH_CONTAINER_NONE,
 380                            NEW_WINDOW);
 381     params.command_line = *CommandLine::ForCurrentProcess();
 382     OpenApplication(params);
 383   }
 384
 385   if (!catcher.GetNextResult()) {
 386     message_ = catcher.message();
 387     return false;
 388   }
 389
 390   return true;
 391 }
 392
 393 // Test that exactly one extension is loaded, and return it.
 394 const extensions::Extension* ExtensionApiTest::GetSingleLoadedExtension() {
 395   ExtensionService* service = extensions::ExtensionSystem::Get(
 396       browser()->profile())->extension_service();
 397
 398   const extensions::Extension* extension = NULL;
 399   for (extensions::ExtensionSet::const_iterator it =
 400            service->extensions()->begin();
 401        it != service->extensions()->end(); ++it) {
 402     // Ignore any component extensions. They are automatically loaded into all
 403     // profiles and aren't the extension we're looking for here.
 404     if ((*it)->location() == extensions::Manifest::COMPONENT)
 405       continue;
 406
 407     if (extension != NULL) {
 408       // TODO(yoz): this is misleading; it counts component extensions.
 409       message_ = base::StringPrintf(
 410           "Expected only one extension to be present.  Found %u.",
 411           static_cast<unsigned>(service->extensions()->size()));
 412       return NULL;
 413     }
 414
 415     extension = it->get();
 416   }
 417
 418   if (!extension) {
 419     message_ = "extension pointer is NULL.";
 420     return NULL;
 421   }
 422   return extension;
 423 }
 424
 425 bool ExtensionApiTest::StartEmbeddedTestServer() {
 426   if (!embedded_test_server()->InitializeAndWaitUntilReady())
 427     return false;
 428
 429   // Build a dictionary of values that tests can use to build URLs that
 430   // access the test server and local file system.  Tests can see these values
 431   // using the extension API function chrome.test.getConfig().
 432   test_config_->SetInteger(kTestServerPort,
 433                            embedded_test_server()->port());
 434
 435   return true;
 436 }
 437
 438 bool ExtensionApiTest::StartWebSocketServer(
 439     const base::FilePath& root_directory) {
 440   websocket_server_.reset(new net::SpawnedTestServer(
 441       net::SpawnedTestServer::TYPE_WS,
 442       net::SpawnedTestServer::kLocalhost,
 443       root_directory));
 444
 445   if (!websocket_server_->Start())
 446     return false;
 447
 448   test_config_->SetInteger(kTestWebSocketPort,
 449                            websocket_server_->host_port_pair().port());
 450
 451   return true;
 452 }
 453
 454 bool ExtensionApiTest::StartFTPServer(const base::FilePath& root_directory) {
 455   ftp_server_.reset(new net::SpawnedTestServer(
 456       net::SpawnedTestServer::TYPE_FTP,
 457       net::SpawnedTestServer::kLocalhost,
 458       root_directory));
 459
 460   if (!ftp_server_->Start())
 461     return false;
 462
 463   test_config_->SetInteger(kFtpServerPort,
 464                            ftp_server_->host_port_pair().port());
 465
 466   return true;
 467 }
 468
 469 bool ExtensionApiTest::StartSpawnedTestServer() {
 470   if (!test_server()->Start())
 471     return false;
 472
 473   // Build a dictionary of values that tests can use to build URLs that
 474   // access the test server and local file system.  Tests can see these values
 475   // using the extension API function chrome.test.getConfig().
 476   test_config_->SetInteger(kSpawnedTestServerPort,
 477                            test_server()->host_port_pair().port());
 478
 479   return true;
 480 }
 481
 482 void ExtensionApiTest::SetUpCommandLine(CommandLine* command_line) {
 483   ExtensionBrowserTest::SetUpCommandLine(command_line);
 484   test_data_dir_ = test_data_dir_.AppendASCII("api_test");
 485 }