Home | History | Annotate | Download | only in extensions 
      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 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_APITEST_H_
      6 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_APITEST_H_
      7 
      8 #include <deque>
      9 #include <string>
     10 
     11 #include "base/compiler_specific.h"
     12 #include "base/values.h"
     13 #include "chrome/browser/extensions/extension_browsertest.h"
     14 #include "content/public/browser/notification_registrar.h"
     15 
     16 namespace base {
     17 class FilePath;
     18 }
     19 
     20 namespace extensions {
     21 class Extension;
     22 }
     23 
     24 // The general flow of these API tests should work like this:
     25 // (1) Setup initial browser state (e.g. create some bookmarks for the
     26 //     bookmark test)
     27 // (2) Call ASSERT_TRUE(RunExtensionTest(name));
     28 // (3) In your extension code, run your test and call chrome.test.pass or
     29 //     chrome.test.fail
     30 // (4) Verify expected browser state.
     31 // TODO(erikkay): There should also be a way to drive events in these tests.
     32 class ExtensionApiTest : public ExtensionBrowserTest {
     33  public:
     34   // Flags used to configure how the tests are run.
     35   // TODO(aa): Many of these are dupes of ExtensionBrowserTest::Flags. Combine
     36   // somehow?
     37   enum Flags {
     38     kFlagNone = 0,
     39 
     40     // Allow the extension to run in incognito mode.
     41     kFlagEnableIncognito = 1 << 0,
     42 
     43     // Launch the test page in an incognito window.
     44     kFlagUseIncognito = 1 << 1,
     45 
     46     // Allow file access for the extension.
     47     kFlagEnableFileAccess = 1 << 2,
     48 
     49     // Loads the extension with location COMPONENT.
     50     kFlagLoadAsComponent = 1 << 3,
     51 
     52     // Launch the extension as a platform app.
     53     kFlagLaunchPlatformApp = 1 << 4,
     54 
     55     // Don't fail when the loaded manifest has warnings.
     56     kFlagIgnoreManifestWarnings = 1 << 5,
     57 
     58     // Allow manifest versions older that Extension::kModernManifestVersion.
     59     // Used to test old manifest features.
     60     kFlagAllowOldManifestVersions = 1 << 6,
     61   };
     62 
     63   ExtensionApiTest();
     64   virtual ~ExtensionApiTest();
     65 
     66  protected:
     67   // InProcessBrowserTest:
     68   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
     69   virtual void TearDownInProcessBrowserTestFixture() OVERRIDE;
     70 
     71   // Load |extension_name| and wait for pass / fail notification.
     72   // |extension_name| is a directory in "test/data/extensions/api_test".
     73   bool RunExtensionTest(const std::string& extension_name);
     74 
     75   // Same as RunExtensionTest, but enables the extension for incognito mode.
     76   bool RunExtensionTestIncognito(const std::string& extension_name);
     77 
     78   // Same as RunExtensionTest, but ignores any warnings in the manifest.
     79   bool RunExtensionTestIgnoreManifestWarnings(
     80       const std::string& extension_name);
     81 
     82   // Same as RunExtensionTest, allow old manifest ersions.
     83   bool RunExtensionTestAllowOldManifestVersion(
     84       const std::string& extension_name);
     85 
     86   // Same as RunExtensionTest, but loads extension as component.
     87   bool RunComponentExtensionTest(const std::string& extension_name);
     88 
     89   // Same as RunExtensionTest, but disables file access.
     90   bool RunExtensionTestNoFileAccess(const std::string& extension_name);
     91 
     92   // Same as RunExtensionTestIncognito, but disables file access.
     93   bool RunExtensionTestIncognitoNoFileAccess(const std::string& extension_name);
     94 
     95   // If not empty, Load |extension_name|, load |page_url| and wait for pass /
     96   // fail notification from the extension API on the page. Note that if
     97   // |page_url| is not a valid url, it will be treated as a resource within
     98   // the extension. |extension_name| is a directory in
     99   // "test/data/extensions/api_test".
    100   bool RunExtensionSubtest(const std::string& extension_name,
    101                            const std::string& page_url);
    102 
    103   // Same as RunExtensionSubtest, except run with the specific |flags|
    104   // (as defined in the Flags enum).
    105   bool RunExtensionSubtest(const std::string& extension_name,
    106                            const std::string& page_url,
    107                            int flags);
    108 
    109   // Load |page_url| and wait for pass / fail notification from the extension
    110   // API on the page.
    111   bool RunPageTest(const std::string& page_url);
    112   bool RunPageTest(const std::string& page_url, int flags);
    113 
    114   // Similar to RunExtensionTest, except used for running tests in platform app
    115   // shell windows.
    116   bool RunPlatformAppTest(const std::string& extension_name);
    117 
    118   // Similar to RunPlatformAppTest, except sets an additional string argument
    119   // |customArg| to the test config object.
    120   bool RunPlatformAppTestWithArg(
    121       const std::string& extension_name, const char* custom_arg);
    122 
    123   // Similar to RunPlatformAppTest, with custom |flags| (as defined in the Flags
    124   // enum). The kFlagLaunchPlatformApp flag is automatically added.
    125   bool RunPlatformAppTestWithFlags(const std::string& extension_name,
    126                                    int flags);
    127 
    128   // Start the test server, and store details of its state.  Those details
    129   // will be available to javascript tests using chrome.test.getConfig().
    130   bool StartEmbeddedTestServer();
    131 
    132   // Start the test WebSocket server, and store details of its state. Those
    133   // details will be available to javascript tests using
    134   // chrome.test.getConfig().
    135   bool StartWebSocketServer(const base::FilePath& root_directory);
    136 
    137   // Start the test FTP server, and store details of its state. Those
    138   // details will be available to JavaScript tests using
    139   // chrome.test.getConfig().
    140   bool StartFTPServer(const base::FilePath& root_directory);
    141 
    142   // Start the spawned test server, and store details of its state.  Those
    143   // details will be available to javascript tests using
    144   // chrome.test.getConfig().
    145   bool StartSpawnedTestServer();
    146 
    147   // Test that exactly one extension loaded.  If so, return a pointer to
    148   // the extension.  If not, return NULL and set message_.
    149   const extensions::Extension* GetSingleLoadedExtension();
    150 
    151   // All extensions tested by ExtensionApiTest are in the "api_test" dir.
    152   virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE;
    153 
    154   // If it failed, what was the error message?
    155   std::string message_;
    156 
    157  private:
    158   bool RunExtensionTestImpl(const std::string& extension_name,
    159                             const std::string& test_page,
    160                             const char* custom_arg,
    161                             int flags);
    162 
    163   // Hold details of the test, set in C++, which can be accessed by
    164   // javascript using chrome.test.getConfig().
    165   scoped_ptr<base::DictionaryValue> test_config_;
    166 
    167   // Hold the test WebSocket server.
    168   scoped_ptr<net::SpawnedTestServer> websocket_server_;
    169 
    170   // Hold the test FTP server.
    171   scoped_ptr<net::SpawnedTestServer> ftp_server_;
    172 };
    173 
    174 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_APITEST_H_
    175