OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <memory> | 5 #include <memory> |
6 | 6 |
7 #include "base/memory/ptr_util.h" | 7 #include "base/memory/ptr_util.h" |
8 #include "base/strings/stringprintf.h" | 8 #include "base/strings/stringprintf.h" |
9 #include "content/public/test/browser_test.h" | 9 #include "content/public/test/browser_test.h" |
10 #include "headless/public/domains/page.h" | 10 #include "headless/public/domains/page.h" |
11 #include "headless/public/headless_browser.h" | 11 #include "headless/public/headless_browser.h" |
12 #include "headless/public/headless_devtools_client.h" | 12 #include "headless/public/headless_devtools_client.h" |
13 #include "headless/public/headless_devtools_target.h" | 13 #include "headless/public/headless_devtools_target.h" |
14 #include "headless/public/headless_web_contents.h" | 14 #include "headless/public/headless_web_contents.h" |
15 #include "headless/test/headless_browser_test.h" | 15 #include "headless/test/headless_browser_test.h" |
16 #include "headless/test/test_protocol_handler.h" | 16 #include "headless/test/test_protocol_handler.h" |
17 #include "net/test/spawned_test_server/spawned_test_server.h" | 17 #include "net/test/spawned_test_server/spawned_test_server.h" |
18 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
19 #include "ui/gfx/geometry/size.h" | 19 #include "ui/gfx/geometry/size.h" |
20 | 20 |
21 namespace headless { | 21 namespace headless { |
22 | 22 |
| 23 namespace { |
| 24 |
| 25 template <class T> |
| 26 std::vector<T> Sorted(std::vector<T> vector) { |
| 27 std::sort(vector.begin(), vector.end()); |
| 28 return vector; |
| 29 } |
| 30 |
| 31 } // namespace |
| 32 |
23 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, CreateAndDestroyWebContents) { | 33 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, CreateAndDestroyWebContents) { |
| 34 std::unique_ptr<HeadlessBrowserContext> browser_context = |
| 35 browser()->CreateBrowserContextBuilder().Build(); |
24 HeadlessWebContents* web_contents = | 36 HeadlessWebContents* web_contents = |
25 browser()->CreateWebContentsBuilder().Build(); | 37 browser_context->CreateWebContentsBuilder().Build(); |
26 EXPECT_TRUE(web_contents); | 38 EXPECT_TRUE(web_contents); |
27 | 39 |
28 EXPECT_EQ(static_cast<size_t>(1), browser()->GetAllWebContents().size()); | 40 EXPECT_EQ(browser()->GetAllWebContents(), |
29 EXPECT_EQ(web_contents, browser()->GetAllWebContents()[0]); | 41 std::vector<HeadlessWebContents*>({web_contents})); |
| 42 EXPECT_EQ(browser_context->GetAllWebContents(), |
| 43 std::vector<HeadlessWebContents*>({web_contents})); |
| 44 |
30 // TODO(skyostil): Verify viewport dimensions once we can. | 45 // TODO(skyostil): Verify viewport dimensions once we can. |
| 46 |
31 web_contents->Close(); | 47 web_contents->Close(); |
32 | 48 |
33 EXPECT_TRUE(browser()->GetAllWebContents().empty()); | 49 EXPECT_TRUE(browser()->GetAllWebContents().empty()); |
| 50 EXPECT_TRUE(browser_context->GetAllWebContents().empty()); |
| 51 } |
| 52 |
| 53 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, |
| 54 WebContentsAreDestroyedWithContext) { |
| 55 std::unique_ptr<HeadlessBrowserContext> browser_context = |
| 56 browser()->CreateBrowserContextBuilder().Build(); |
| 57 HeadlessWebContents* web_contents = |
| 58 browser_context->CreateWebContentsBuilder().Build(); |
| 59 EXPECT_TRUE(web_contents); |
| 60 |
| 61 EXPECT_EQ(browser()->GetAllWebContents(), |
| 62 std::vector<HeadlessWebContents*>({web_contents})); |
| 63 |
| 64 EXPECT_EQ(browser_context->GetAllWebContents(), |
| 65 std::vector<HeadlessWebContents*>({web_contents})); |
| 66 |
| 67 browser_context.reset(); |
| 68 |
| 69 EXPECT_TRUE(browser()->GetAllWebContents().empty()); |
| 70 } |
| 71 |
| 72 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, DestroyAndCreateTwoWebContents) { |
| 73 std::unique_ptr<HeadlessBrowserContext> browser_context1 = |
| 74 browser()->CreateBrowserContextBuilder().Build(); |
| 75 HeadlessWebContents* web_contents1 = |
| 76 browser_context1->CreateWebContentsBuilder().Build(); |
| 77 |
| 78 EXPECT_EQ(browser()->GetAllWebContents(), |
| 79 std::vector<HeadlessWebContents*>({web_contents1})); |
| 80 EXPECT_EQ(browser_context1->GetAllWebContents(), |
| 81 std::vector<HeadlessWebContents*>({web_contents1})); |
| 82 |
| 83 std::unique_ptr<HeadlessBrowserContext> browser_context2 = |
| 84 browser()->CreateBrowserContextBuilder().Build(); |
| 85 HeadlessWebContents* web_contents2 = |
| 86 browser_context2->CreateWebContentsBuilder().Build(); |
| 87 |
| 88 EXPECT_EQ(Sorted(browser()->GetAllWebContents()), |
| 89 Sorted(std::vector<HeadlessWebContents*>( |
| 90 {web_contents1, web_contents2}))); |
| 91 EXPECT_EQ(browser_context1->GetAllWebContents(), |
| 92 std::vector<HeadlessWebContents*>({web_contents1})); |
| 93 EXPECT_EQ(browser_context2->GetAllWebContents(), |
| 94 std::vector<HeadlessWebContents*>({web_contents2})); |
| 95 |
| 96 browser_context1.reset(); |
| 97 |
| 98 EXPECT_EQ(browser()->GetAllWebContents(), |
| 99 std::vector<HeadlessWebContents*>({web_contents2})); |
| 100 EXPECT_EQ(browser_context2->GetAllWebContents(), |
| 101 std::vector<HeadlessWebContents*>({web_contents2})); |
| 102 |
| 103 browser_context2.reset(); |
| 104 |
| 105 EXPECT_TRUE(browser()->GetAllWebContents().empty()); |
34 } | 106 } |
35 | 107 |
36 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, CreateWithBadURL) { | 108 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, CreateWithBadURL) { |
37 GURL bad_url("not_valid"); | 109 GURL bad_url("not_valid"); |
| 110 |
| 111 std::unique_ptr<HeadlessBrowserContext> browser_context = |
| 112 browser()->CreateBrowserContextBuilder().Build(); |
38 HeadlessWebContents* web_contents = | 113 HeadlessWebContents* web_contents = |
39 browser()->CreateWebContentsBuilder().SetInitialURL(bad_url).Build(); | 114 browser_context->CreateWebContentsBuilder() |
| 115 .SetInitialURL(bad_url) |
| 116 .Build(); |
| 117 |
40 EXPECT_FALSE(web_contents); | 118 EXPECT_FALSE(web_contents); |
41 EXPECT_TRUE(browser()->GetAllWebContents().empty()); | 119 EXPECT_TRUE(browser()->GetAllWebContents().empty()); |
42 } | 120 } |
43 | 121 |
44 class HeadlessBrowserTestWithProxy : public HeadlessBrowserTest { | 122 class HeadlessBrowserTestWithProxy : public HeadlessBrowserTest { |
45 public: | 123 public: |
46 HeadlessBrowserTestWithProxy() | 124 HeadlessBrowserTestWithProxy() |
47 : proxy_server_(net::SpawnedTestServer::TYPE_HTTP, | 125 : proxy_server_(net::SpawnedTestServer::TYPE_HTTP, |
48 net::SpawnedTestServer::kLocalhost, | 126 net::SpawnedTestServer::kLocalhost, |
49 base::FilePath(FILE_PATH_LITERAL("headless/test/data"))) { | 127 base::FilePath(FILE_PATH_LITERAL("headless/test/data"))) { |
50 } | 128 } |
51 | 129 |
52 void SetUp() override { | 130 void SetUp() override { |
53 ASSERT_TRUE(proxy_server_.Start()); | 131 ASSERT_TRUE(proxy_server_.Start()); |
54 HeadlessBrowserTest::SetUp(); | 132 HeadlessBrowserTest::SetUp(); |
55 } | 133 } |
56 | 134 |
57 void TearDown() override { | 135 void TearDown() override { |
58 proxy_server_.Stop(); | 136 proxy_server_.Stop(); |
59 HeadlessBrowserTest::TearDown(); | 137 HeadlessBrowserTest::TearDown(); |
60 } | 138 } |
61 | 139 |
62 net::SpawnedTestServer* proxy_server() { return &proxy_server_; } | 140 net::SpawnedTestServer* proxy_server() { return &proxy_server_; } |
63 | 141 |
64 private: | 142 private: |
65 net::SpawnedTestServer proxy_server_; | 143 net::SpawnedTestServer proxy_server_; |
66 }; | 144 }; |
67 | 145 |
68 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTestWithProxy, SetProxyServer) { | 146 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTestWithProxy, SetProxyServer) { |
69 HeadlessBrowser::Options::Builder builder; | 147 std::unique_ptr<HeadlessBrowserContext> browser_context = |
70 builder.SetProxyServer(proxy_server()->host_port_pair()); | 148 browser() |
71 SetBrowserOptions(builder.Build()); | 149 ->CreateBrowserContextBuilder() |
| 150 .SetProxyServer(proxy_server()->host_port_pair()) |
| 151 .Build(); |
72 | 152 |
73 // Load a page which doesn't actually exist, but for which the our proxy | 153 // Load a page which doesn't actually exist, but for which the our proxy |
74 // returns valid content anyway. | 154 // returns valid content anyway. |
75 // | 155 // |
76 // TODO(altimin): Currently this construction does not serve hello.html | 156 // TODO(altimin): Currently this construction does not serve hello.html |
77 // from headless/test/data as expected. We should fix this. | 157 // from headless/test/data as expected. We should fix this. |
78 HeadlessWebContents* web_contents = | 158 HeadlessWebContents* web_contents = |
79 browser() | 159 browser_context->CreateWebContentsBuilder() |
80 ->CreateWebContentsBuilder() | |
81 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) | 160 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) |
82 .Build(); | 161 .Build(); |
83 EXPECT_TRUE(WaitForLoad(web_contents)); | 162 EXPECT_TRUE(WaitForLoad(web_contents)); |
84 EXPECT_EQ(static_cast<size_t>(1), browser()->GetAllWebContents().size()); | 163 EXPECT_EQ(browser()->GetAllWebContents(), |
85 EXPECT_EQ(web_contents, browser()->GetAllWebContents()[0]); | 164 std::vector<HeadlessWebContents*>({web_contents})); |
86 web_contents->Close(); | 165 web_contents->Close(); |
87 EXPECT_TRUE(browser()->GetAllWebContents().empty()); | 166 EXPECT_TRUE(browser()->GetAllWebContents().empty()); |
88 } | 167 } |
89 | 168 |
90 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, SetHostResolverRules) { | 169 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, SetHostResolverRules) { |
91 EXPECT_TRUE(embedded_test_server()->Start()); | 170 EXPECT_TRUE(embedded_test_server()->Start()); |
92 HeadlessBrowser::Options::Builder builder; | 171 |
93 builder.SetHostResolverRules( | 172 std::string host_resolver_rules = |
94 base::StringPrintf("MAP not-an-actual-domain.tld 127.0.0.1:%d", | 173 base::StringPrintf("MAP not-an-actual-domain.tld 127.0.0.1:%d", |
95 embedded_test_server()->host_port_pair().port())); | 174 embedded_test_server()->host_port_pair().port()); |
96 SetBrowserOptions(builder.Build()); | 175 |
| 176 std::unique_ptr<HeadlessBrowserContext> browser_context = |
| 177 browser() |
| 178 ->CreateBrowserContextBuilder() |
| 179 .SetHostResolverRules(host_resolver_rules) |
| 180 .Build(); |
97 | 181 |
98 // Load a page which doesn't actually exist, but which is turned into a valid | 182 // Load a page which doesn't actually exist, but which is turned into a valid |
99 // address by our host resolver rules. | 183 // address by our host resolver rules. |
100 HeadlessWebContents* web_contents = | 184 HeadlessWebContents* web_contents = |
101 browser() | 185 browser_context->CreateWebContentsBuilder() |
102 ->CreateWebContentsBuilder() | |
103 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) | 186 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) |
104 .Build(); | 187 .Build(); |
| 188 |
105 EXPECT_TRUE(WaitForLoad(web_contents)); | 189 EXPECT_TRUE(WaitForLoad(web_contents)); |
106 } | 190 } |
107 | 191 |
108 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpProtocolHandler) { | 192 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpProtocolHandler) { |
109 const std::string kResponseBody = "<p>HTTP response body</p>"; | 193 const std::string kResponseBody = "<p>HTTP response body</p>"; |
110 ProtocolHandlerMap protocol_handlers; | 194 ProtocolHandlerMap protocol_handlers; |
111 protocol_handlers[url::kHttpScheme] = | 195 protocol_handlers[url::kHttpScheme] = |
112 base::WrapUnique(new TestProtocolHandler(kResponseBody)); | 196 base::WrapUnique(new TestProtocolHandler(kResponseBody)); |
113 | 197 |
114 HeadlessBrowser::Options::Builder builder; | 198 std::unique_ptr<HeadlessBrowserContext> browser_context = |
115 builder.SetProtocolHandlers(std::move(protocol_handlers)); | 199 browser() |
116 SetBrowserOptions(builder.Build()); | 200 ->CreateBrowserContextBuilder() |
| 201 .SetProtocolHandlers(std::move(protocol_handlers)) |
| 202 .Build(); |
117 | 203 |
118 // Load a page which doesn't actually exist, but which is fetched by our | 204 // Load a page which doesn't actually exist, but which is fetched by our |
119 // custom protocol handler. | 205 // custom protocol handler. |
120 HeadlessWebContents* web_contents = | 206 HeadlessWebContents* web_contents = |
121 browser() | 207 browser_context->CreateWebContentsBuilder() |
122 ->CreateWebContentsBuilder() | |
123 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) | 208 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) |
124 .Build(); | 209 .Build(); |
125 EXPECT_TRUE(WaitForLoad(web_contents)); | 210 EXPECT_TRUE(WaitForLoad(web_contents)); |
126 | 211 |
127 std::string inner_html; | 212 std::string inner_html; |
128 EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML") | 213 EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML") |
129 ->GetResult() | 214 ->GetResult() |
130 ->GetValue() | 215 ->GetValue() |
131 ->GetAsString(&inner_html)); | 216 ->GetAsString(&inner_html)); |
132 EXPECT_EQ(kResponseBody, inner_html); | 217 EXPECT_EQ(kResponseBody, inner_html); |
133 } | 218 } |
134 | 219 |
135 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpsProtocolHandler) { | 220 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpsProtocolHandler) { |
136 const std::string kResponseBody = "<p>HTTPS response body</p>"; | 221 const std::string kResponseBody = "<p>HTTPS response body</p>"; |
137 ProtocolHandlerMap protocol_handlers; | 222 ProtocolHandlerMap protocol_handlers; |
138 protocol_handlers[url::kHttpsScheme] = | 223 protocol_handlers[url::kHttpsScheme] = |
139 base::WrapUnique(new TestProtocolHandler(kResponseBody)); | 224 base::WrapUnique(new TestProtocolHandler(kResponseBody)); |
140 | 225 |
141 HeadlessBrowser::Options::Builder builder; | 226 std::unique_ptr<HeadlessBrowserContext> browser_context = |
142 builder.SetProtocolHandlers(std::move(protocol_handlers)); | 227 browser() |
143 SetBrowserOptions(builder.Build()); | 228 ->CreateBrowserContextBuilder() |
| 229 .SetProtocolHandlers(std::move(protocol_handlers)) |
| 230 .Build(); |
144 | 231 |
145 // Load a page which doesn't actually exist, but which is fetched by our | 232 // Load a page which doesn't actually exist, but which is fetched by our |
146 // custom protocol handler. | 233 // custom protocol handler. |
147 HeadlessWebContents* web_contents = | 234 HeadlessWebContents* web_contents = |
148 browser() | 235 browser_context->CreateWebContentsBuilder() |
149 ->CreateWebContentsBuilder() | |
150 .SetInitialURL(GURL("https://not-an-actual-domain.tld/hello.html")) | 236 .SetInitialURL(GURL("https://not-an-actual-domain.tld/hello.html")) |
151 .Build(); | 237 .Build(); |
152 EXPECT_TRUE(WaitForLoad(web_contents)); | 238 EXPECT_TRUE(WaitForLoad(web_contents)); |
153 | 239 |
154 std::string inner_html; | 240 std::string inner_html; |
155 EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML") | 241 EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML") |
156 ->GetResult() | 242 ->GetResult() |
157 ->GetValue() | 243 ->GetValue() |
158 ->GetAsString(&inner_html)); | 244 ->GetAsString(&inner_html)); |
159 EXPECT_EQ(kResponseBody, inner_html); | 245 EXPECT_EQ(kResponseBody, inner_html); |
160 } | 246 } |
161 | 247 |
162 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, WebGLSupported) { | 248 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, WebGLSupported) { |
| 249 std::unique_ptr<HeadlessBrowserContext> browser_context = |
| 250 browser()->CreateBrowserContextBuilder().Build(); |
| 251 |
163 HeadlessWebContents* web_contents = | 252 HeadlessWebContents* web_contents = |
164 browser()->CreateWebContentsBuilder().Build(); | 253 browser_context->CreateWebContentsBuilder().Build(); |
165 | 254 |
166 bool webgl_supported; | 255 bool webgl_supported; |
167 EXPECT_TRUE( | 256 EXPECT_TRUE( |
168 EvaluateScript(web_contents, | 257 EvaluateScript(web_contents, |
169 "(document.createElement('canvas').getContext('webgl')" | 258 "(document.createElement('canvas').getContext('webgl')" |
170 " instanceof WebGLRenderingContext)") | 259 " instanceof WebGLRenderingContext)") |
171 ->GetResult() | 260 ->GetResult() |
172 ->GetValue() | 261 ->GetValue() |
173 ->GetAsBoolean(&webgl_supported)); | 262 ->GetAsBoolean(&webgl_supported)); |
174 EXPECT_TRUE(webgl_supported); | 263 EXPECT_TRUE(webgl_supported); |
175 } | 264 } |
176 | 265 |
177 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, DefaultSizes) { | 266 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, DefaultSizes) { |
| 267 std::unique_ptr<HeadlessBrowserContext> browser_context = |
| 268 browser()->CreateBrowserContextBuilder().Build(); |
| 269 |
178 HeadlessWebContents* web_contents = | 270 HeadlessWebContents* web_contents = |
179 browser()->CreateWebContentsBuilder().Build(); | 271 browser_context->CreateWebContentsBuilder().Build(); |
180 | 272 |
181 HeadlessBrowser::Options::Builder builder; | 273 HeadlessBrowser::Options::Builder builder; |
182 const HeadlessBrowser::Options kDefaultOptions = builder.Build(); | 274 const HeadlessBrowser::Options kDefaultOptions = builder.Build(); |
183 | 275 |
184 int screen_width; | 276 int screen_width; |
185 int screen_height; | 277 int screen_height; |
186 int window_width; | 278 int window_width; |
187 int window_height; | 279 int window_height; |
188 | 280 |
189 EXPECT_TRUE(EvaluateScript(web_contents, "screen.width") | 281 EXPECT_TRUE(EvaluateScript(web_contents, "screen.width") |
(...skipping 13 matching lines...) Expand all Loading... |
203 ->GetValue() | 295 ->GetValue() |
204 ->GetAsInteger(&window_height)); | 296 ->GetAsInteger(&window_height)); |
205 | 297 |
206 EXPECT_EQ(kDefaultOptions.window_size.width(), screen_width); | 298 EXPECT_EQ(kDefaultOptions.window_size.width(), screen_width); |
207 EXPECT_EQ(kDefaultOptions.window_size.height(), screen_height); | 299 EXPECT_EQ(kDefaultOptions.window_size.height(), screen_height); |
208 EXPECT_EQ(kDefaultOptions.window_size.width(), window_width); | 300 EXPECT_EQ(kDefaultOptions.window_size.width(), window_width); |
209 EXPECT_EQ(kDefaultOptions.window_size.height(), window_height); | 301 EXPECT_EQ(kDefaultOptions.window_size.height(), window_height); |
210 } | 302 } |
211 | 303 |
212 } // namespace headless | 304 } // namespace headless |
OLD | NEW |