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
16namespace base {
17class FilePath;
18}
19
20namespace extensions {
21class 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.
32class 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