| OLD | NEW |
|---|
| (Empty) |
| 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_FRAME_TEST_TEST_WITH_WEB_SERVER_H_ | |
| 6 #define CHROME_FRAME_TEST_TEST_WITH_WEB_SERVER_H_ | |
| 7 | |
| 8 #include <windows.h> | |
| 9 #include <string> | |
| 10 | |
| 11 #include "base/files/scoped_temp_dir.h" | |
| 12 #include "base/strings/string_util.h" | |
| 13 #include "base/strings/stringprintf.h" | |
| 14 #include "base/strings/utf_string_conversions.h" | |
| 15 #include "base/win/scoped_handle.h" | |
| 16 #include "chrome_frame/chrome_tab.h" | |
| 17 #include "chrome_frame/test/chrome_frame_test_utils.h" | |
| 18 #include "chrome_frame/test/test_server.h" | |
| 19 #include "testing/gmock/include/gmock/gmock.h" | |
| 20 #include "testing/gtest/include/gtest/gtest.h" | |
| 21 | |
| 22 // Specifies the invocation method for CF. | |
| 23 class CFInvocation { | |
| 24 public: | |
| 25 enum Type { | |
| 26 NONE = 0, | |
| 27 META_TAG, | |
| 28 HTTP_HEADER | |
| 29 }; | |
| 30 | |
| 31 CFInvocation(): method_(NONE) {} | |
| 32 explicit CFInvocation(Type method): method_(method) {} | |
| 33 | |
| 34 // Convience methods for creating this class. | |
| 35 static CFInvocation None() { return CFInvocation(NONE); } | |
| 36 static CFInvocation MetaTag() { return CFInvocation(META_TAG); } | |
| 37 static CFInvocation HttpHeader() { return CFInvocation(HTTP_HEADER); } | |
| 38 | |
| 39 // Returns whether this page does invoke CF. | |
| 40 bool invokes_cf() const { | |
| 41 return method_ != NONE; | |
| 42 } | |
| 43 | |
| 44 Type type() const { return method_; } | |
| 45 | |
| 46 private: | |
| 47 Type method_; | |
| 48 }; | |
| 49 | |
| 50 // An interface for listeners of interesting events on a MockWebServer. | |
| 51 class WebServerListener { | |
| 52 public: | |
| 53 virtual ~WebServerListener() {} | |
| 54 | |
| 55 // Invoked when a MockWebServer receives an expected response; see | |
| 56 // MockWebServer::ExpectAndHandlePostedResult. | |
| 57 virtual void OnExpectedResponse() = 0; | |
| 58 }; | |
| 59 | |
| 60 // Simple Gmock friendly web server. Sample usage: | |
| 61 // MockWebServer mock(9999, "0.0.0.0"); | |
| 62 // EXPECT_CALL(mock, Get(_, StrEq("/favicon.ico"), _)).WillRepeatedly(SendFast( | |
| 63 // "HTTP/1.1 404 Not Found" | |
| 64 // "text/html; charset=UTF-8", std::string())); | |
| 65 // | |
| 66 // EXPECT_CALL(mock, Get(_, StrEq("/book"), _)).WillRepeatedly(Send( | |
| 67 // "HTTP/1.1 302 Found\r\n" | |
| 68 // "Connection: close\r\n" | |
| 69 // "Content-Type: text/html\r\n" | |
| 70 // "Location: library\r\n", | |
| 71 // "<html>Lalalala</html>", 3, 1000)); | |
| 72 // | |
| 73 // EXPECT_CALL(mock, Get(_, StrEq("/library"), _)).WillRepeatedly(Send( | |
| 74 // "HTTP/1.1 200 OK\r\n" | |
| 75 // "Connection: close\r\n" | |
| 76 // "Content-Type: text/html\r\n", | |
| 77 // "<html><meta http-equiv=\"X-UA-Compatible\" content=\"chrome=1\" />" | |
| 78 // "<body>Rendered in CF.</body></html>", 4, 1000)); | |
| 79 class MockWebServer : public test_server::HTTPTestServer { | |
| 80 public: | |
| 81 MockWebServer(int port, const std::wstring& address, base::FilePath root_dir) | |
| 82 : test_server::HTTPTestServer(port, address, root_dir), listener_(NULL) {} | |
| 83 | |
| 84 // Overriden from test_server::HTTPTestServer. | |
| 85 MOCK_METHOD3(Get, void(test_server::ConfigurableConnection* connection, | |
| 86 const std::wstring& path, | |
| 87 const test_server::Request& r)); | |
| 88 MOCK_METHOD3(Post, void(test_server::ConfigurableConnection* connection, | |
| 89 const std::wstring& path, | |
| 90 const test_server::Request& r)); | |
| 91 | |
| 92 // Expect a GET request for |url|. Respond with the file appropriate for | |
| 93 // the given |url|. Modify the file to follow the given CFInvocation method. | |
| 94 // The response includes a no-cache header. |allow_meta_tag_double_req| | |
| 95 // specifies whether to allow the request to happen twice if the invocation | |
| 96 // is using the CF meta tag. | |
| 97 void ExpectAndServeRequest(CFInvocation invocation, const std::wstring& url); | |
| 98 | |
| 99 // Expect a number of GET requests for |url|. Rest is similar to the function | |
| 100 // ExpectAndServeRequest. | |
| 101 void ExpectAndServeRequestWithCardinality(CFInvocation invocation, | |
| 102 const std::wstring& url, | |
| 103 testing::Cardinality cardinality); | |
| 104 | |
| 105 // Same as above except do not include the no-cache header. | |
| 106 void ExpectAndServeRequestAllowCache(CFInvocation invocation, | |
| 107 const std::wstring& url); | |
| 108 | |
| 109 // Expect any number of GETs for the given resource path (e.g, /favicon.ico) | |
| 110 // and respond with the file, if it exists, or a 404 if it does not. | |
| 111 void ExpectAndServeRequestAnyNumberTimes(CFInvocation invocation, | |
| 112 const std::wstring& path_prefix); | |
| 113 | |
| 114 void set_listener(WebServerListener* listener) { listener_ = listener; } | |
| 115 | |
| 116 // Expect a POST to an URL containing |post_suffix|, saving the response | |
| 117 // contents for retrieval by posted_result(). Invokes the listener's | |
| 118 // OnExpectedResponse method if the posted response matches the expected | |
| 119 // result. | |
| 120 void ExpectAndHandlePostedResult(CFInvocation invocation, | |
| 121 const std::wstring& post_suffix); | |
| 122 | |
| 123 // Expect and serve all incoming GET requests. | |
| 124 void ExpectAndServeAnyRequests(CFInvocation invocation) { | |
| 125 ExpectAndServeRequestAnyNumberTimes(invocation, L""); | |
| 126 } | |
| 127 | |
| 128 | |
| 129 // Send a response on the given connection appropriate for |resource_uri|. | |
| 130 // If the file referred to by |path| exists, send the file data, otherwise | |
| 131 // send 404. Modify the file data according to the given invocation method. | |
| 132 void SendResponseHelper(test_server::ConfigurableConnection* connection, | |
| 133 const std::wstring& resource_uri, | |
| 134 const test_server::Request& request, | |
| 135 CFInvocation invocation, | |
| 136 bool add_no_cache_header); | |
| 137 // Handles the posted /writefile response | |
| 138 void HandlePostedResponse(test_server::ConfigurableConnection* connection, | |
| 139 const test_server::Request& request); | |
| 140 | |
| 141 void ClearResults() { | |
| 142 posted_result_.clear(); | |
| 143 expected_result_.clear(); | |
| 144 } | |
| 145 | |
| 146 void set_expected_result(const std::string& expected_result) { | |
| 147 expected_result_ = expected_result; | |
| 148 } | |
| 149 | |
| 150 const std::string& posted_result() const { | |
| 151 return posted_result_; | |
| 152 } | |
| 153 | |
| 154 private: | |
| 155 WebServerListener* listener_; | |
| 156 // Holds the results of tests which post success/failure. | |
| 157 std::string posted_result_; | |
| 158 std::string expected_result_; | |
| 159 }; | |
| 160 | |
| 161 class MockWebServerListener : public WebServerListener { | |
| 162 public: | |
| 163 MOCK_METHOD0(OnExpectedResponse, void()); | |
| 164 }; | |
| 165 | |
| 166 // Class that: | |
| 167 // 1) Starts the local webserver, | |
| 168 // 2) Supports launching browsers - Internet Explorer with local url | |
| 169 // 3) Wait the webserver to finish. It is supposed the test webpage to shutdown | |
| 170 // the server by navigating to "kill" page | |
| 171 // 4) Supports read the posted results from the test webpage to the "dump" | |
| 172 // webserver directory | |
| 173 class ChromeFrameTestWithWebServer : public testing::Test { | |
| 174 public: | |
| 175 ChromeFrameTestWithWebServer(); | |
| 176 | |
| 177 protected: | |
| 178 enum BrowserKind { INVALID, IE, CHROME }; | |
| 179 | |
| 180 bool LaunchBrowser(BrowserKind browser, const wchar_t* url); | |
| 181 | |
| 182 // Returns true if the test completed in time, or false if it timed out. | |
| 183 bool WaitForTestToComplete(base::TimeDelta duration); | |
| 184 | |
| 185 // Waits for the page to notify us of the window.onload event firing. | |
| 186 // Note that the milliseconds value is only approximate. | |
| 187 bool WaitForOnLoad(int milliseconds); | |
| 188 | |
| 189 // Launches the specified browser and waits for the test to complete (see | |
| 190 // WaitForTestToComplete). Then checks that the outcome is equal to the | |
| 191 // expected result. The test is repeated once if it fails due to a timeout. | |
| 192 // This function uses EXPECT_TRUE and ASSERT_TRUE for all steps performed | |
| 193 // hence no return value. | |
| 194 void SimpleBrowserTestExpectedResult(BrowserKind browser, | |
| 195 const wchar_t* page, const char* result); | |
| 196 void SimpleBrowserTest(BrowserKind browser, const wchar_t* page); | |
| 197 | |
| 198 // Sets up expectations for a page to post back a result. | |
| 199 void ExpectAndHandlePostedResult(); | |
| 200 | |
| 201 // Test if chrome frame correctly reports its version. | |
| 202 void VersionTest(BrowserKind browser, const wchar_t* page); | |
| 203 | |
| 204 void CloseBrowser(); | |
| 205 | |
| 206 // Ensures (well, at least tries to ensure) that the browser window has focus. | |
| 207 bool BringBrowserToTop(); | |
| 208 | |
| 209 const base::FilePath& GetCFTestFilePath() { | |
| 210 return test_file_path_; | |
| 211 } | |
| 212 | |
| 213 static chrome_frame_test::TimedMsgLoop& loop() { | |
| 214 return *loop_; | |
| 215 } | |
| 216 | |
| 217 static testing::StrictMock<MockWebServerListener>& listener_mock() { | |
| 218 return *listener_mock_; | |
| 219 } | |
| 220 | |
| 221 static testing::StrictMock<MockWebServer>& server_mock() { | |
| 222 return *server_mock_; | |
| 223 } | |
| 224 | |
| 225 static void SetUpTestCase(); | |
| 226 static void TearDownTestCase(); | |
| 227 | |
| 228 static const base::FilePath& GetChromeUserDataDirectory(); | |
| 229 | |
| 230 virtual void SetUp() OVERRIDE; | |
| 231 virtual void TearDown() OVERRIDE; | |
| 232 | |
| 233 // The on-disk path to our html test files. | |
| 234 static base::FilePath test_file_path_; | |
| 235 static base::FilePath results_dir_; | |
| 236 static base::FilePath CFInstall_path_; | |
| 237 static base::FilePath CFInstance_path_; | |
| 238 static base::FilePath chrome_user_data_dir_; | |
| 239 | |
| 240 // The user data directory used for Chrome instances. | |
| 241 static base::ScopedTempDir temp_dir_; | |
| 242 | |
| 243 // The web server from which we serve the web! | |
| 244 static chrome_frame_test::TimedMsgLoop* loop_; | |
| 245 static std::string local_address_; | |
| 246 static testing::StrictMock<MockWebServerListener>* listener_mock_; | |
| 247 static testing::StrictMock<MockWebServer>* server_mock_; | |
| 248 | |
| 249 BrowserKind browser_; | |
| 250 base::win::ScopedHandle browser_handle_; | |
| 251 }; | |
| 252 | |
| 253 // A helper class for doing some bookkeeping when using the | |
| 254 // SimpleWebServer class. | |
| 255 class SimpleWebServerTest { | |
| 256 public: | |
| 257 SimpleWebServerTest(const std::string& address, int port) | |
| 258 : server_(address, port), port_(port) { | |
| 259 } | |
| 260 | |
| 261 ~SimpleWebServerTest() { | |
| 262 server_.DeleteAllResponses(); | |
| 263 } | |
| 264 | |
| 265 template <class ResponseClass> | |
| 266 void PopulateStaticFileListT(const wchar_t* pages[], int count, | |
| 267 const base::FilePath& directory) { | |
| 268 for (int i = 0; i < count; ++i) { | |
| 269 server_.AddResponse(new ResponseClass( | |
| 270 base::StringPrintf("/%ls", pages[i]).c_str(), | |
| 271 directory.Append(pages[i]))); | |
| 272 } | |
| 273 } | |
| 274 | |
| 275 std::wstring FormatHttpPath(const wchar_t* document_path) { | |
| 276 return base::StringPrintf(L"http://%ls:%i/%ls", | |
| 277 base::ASCIIToWide(server_.host()).c_str(), port_, | |
| 278 document_path); | |
| 279 } | |
| 280 | |
| 281 // Returns the last client request object. | |
| 282 // Under normal circumstances this will be the request for /quit. | |
| 283 const test_server::Request& last_request() const { | |
| 284 const test_server::ConnectionList& connections = server_.connections(); | |
| 285 DCHECK(connections.size()); | |
| 286 const test_server::Connection* c = connections.back(); | |
| 287 return c->request(); | |
| 288 } | |
| 289 | |
| 290 bool FindRequest(const std::string& path, | |
| 291 const test_server::Request** request) { | |
| 292 test_server::ConnectionList::const_iterator index; | |
| 293 for (index = server_.connections().begin(); | |
| 294 index != server_.connections().end(); index++) { | |
| 295 const test_server::Connection* connection = *index; | |
| 296 if (!lstrcmpiA(connection->request().path().c_str(), path.c_str())) { | |
| 297 if (request) | |
| 298 *request = &connection->request(); | |
| 299 return true; | |
| 300 } | |
| 301 } | |
| 302 return false; | |
| 303 } | |
| 304 | |
| 305 // Counts the number of times a page was requested. | |
| 306 // Optionally checks if the request method for each is equal to | |
| 307 // |expected_method|. If expected_method is NULL no such check is made. | |
| 308 int GetRequestCountForPage(const wchar_t* page, const char* expected_method) { | |
| 309 // Check how many requests we got for the cf page. | |
| 310 test_server::ConnectionList::const_iterator it; | |
| 311 int requests = 0; | |
| 312 const test_server::ConnectionList& connections = server_.connections(); | |
| 313 for (it = connections.begin(); it != connections.end(); ++it) { | |
| 314 const test_server::Connection* c = (*it); | |
| 315 const test_server::Request& r = c->request(); | |
| 316 if (!r.path().empty() && | |
| 317 base::ASCIIToWide(r.path().substr(1)).compare(page) == 0) { | |
| 318 if (expected_method) { | |
| 319 EXPECT_EQ(expected_method, r.method()); | |
| 320 } | |
| 321 requests++; | |
| 322 } | |
| 323 } | |
| 324 return requests; | |
| 325 } | |
| 326 | |
| 327 test_server::SimpleWebServer* web_server() { | |
| 328 return &server_; | |
| 329 } | |
| 330 | |
| 331 protected: | |
| 332 test_server::SimpleWebServer server_; | |
| 333 int port_; | |
| 334 }; | |
| 335 | |
| 336 ACTION_P2(SendFast, headers, content) { | |
| 337 arg0->Send(headers, content); | |
| 338 } | |
| 339 | |
| 340 ACTION_P4(Send, headers, content, chunk, timeout) { | |
| 341 test_server::ConfigurableConnection::SendOptions options( | |
| 342 test_server::ConfigurableConnection::SendOptions:: | |
| 343 IMMEDIATE_HEADERS_DELAYED_CONTENT, chunk, timeout); | |
| 344 arg0->SendWithOptions(std::string(headers), | |
| 345 std::string(content), | |
| 346 options); | |
| 347 } | |
| 348 | |
| 349 ACTION_P4(SendSlow, headers, content, chunk, timeout) { | |
| 350 test_server::ConfigurableConnection::SendOptions options( | |
| 351 test_server::ConfigurableConnection::SendOptions::DELAYED, chunk, timeout); | |
| 352 arg0->SendWithOptions(std::string(headers), | |
| 353 std::string(content), | |
| 354 options); | |
| 355 } | |
| 356 | |
| 357 // Sends a response with the file data for the given path, if the file exists, | |
| 358 // or a 404 if the file does not. This response includes a no-cache header. | |
| 359 ACTION_P2(SendResponse, server, invocation) { | |
| 360 server->SendResponseHelper(arg0, arg1, arg2, invocation, true); | |
| 361 } | |
| 362 | |
| 363 // Same as above except that the response does not include the no-cache header. | |
| 364 ACTION_P2(SendAllowCacheResponse, server, invocation) { | |
| 365 server->SendResponseHelper(arg0, arg1, invocation, false); | |
| 366 } | |
| 367 | |
| 368 ACTION_P2(HandlePostedResponseHelper, server, invocation) { | |
| 369 server->HandlePostedResponse(arg0, arg2); | |
| 370 } | |
| 371 | |
| 372 #endif // CHROME_FRAME_TEST_TEST_WITH_WEB_SERVER_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 126143005:
Remove Chrome Frame code and resources. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src