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 // TODO(skyostil): Verify viewport dimensions once we can. |
| 68 |
| 69 browser_context.reset(); |
| 70 |
| 71 EXPECT_TRUE(browser()->GetAllWebContents().empty()); |
| 72 } |
| 73 |
| 74 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, DestroyAndCreateTwoWebContents) { |
| 75 std::unique_ptr<HeadlessBrowserContext> browser_context1 = |
| 76 browser()->CreateBrowserContextBuilder().Build(); |
| 77 HeadlessWebContents* web_contents1 = |
| 78 browser_context1->CreateWebContentsBuilder().Build(); |
| 79 |
| 80 EXPECT_EQ(browser()->GetAllWebContents(), |
| 81 std::vector<HeadlessWebContents*>({web_contents1})); |
| 82 EXPECT_EQ(browser_context1->GetAllWebContents(), |
| 83 std::vector<HeadlessWebContents*>({web_contents1})); |
| 84 |
| 85 std::unique_ptr<HeadlessBrowserContext> browser_context2 = |
| 86 browser()->CreateBrowserContextBuilder().Build(); |
| 87 HeadlessWebContents* web_contents2 = |
| 88 browser_context2->CreateWebContentsBuilder().Build(); |
| 89 |
| 90 EXPECT_EQ(Sorted(browser()->GetAllWebContents()), |
| 91 Sorted(std::vector<HeadlessWebContents*>( |
| 92 {web_contents1, web_contents2}))); |
| 93 EXPECT_EQ(browser_context1->GetAllWebContents(), |
| 94 std::vector<HeadlessWebContents*>({web_contents1})); |
| 95 EXPECT_EQ(browser_context2->GetAllWebContents(), |
| 96 std::vector<HeadlessWebContents*>({web_contents2})); |
| 97 |
| 98 browser_context1.reset(); |
| 99 |
| 100 EXPECT_EQ(browser()->GetAllWebContents(), |
| 101 std::vector<HeadlessWebContents*>({web_contents2})); |
| 102 EXPECT_EQ(browser_context2->GetAllWebContents(), |
| 103 std::vector<HeadlessWebContents*>({web_contents2})); |
| 104 |
| 105 browser_context2.reset(); |
| 106 |
| 107 EXPECT_TRUE(browser()->GetAllWebContents().empty()); |
34 } | 108 } |
35 | 109 |
36 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, CreateWithBadURL) { | 110 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, CreateWithBadURL) { |
37 GURL bad_url("not_valid"); | 111 GURL bad_url("not_valid"); |
| 112 |
| 113 std::unique_ptr<HeadlessBrowserContext> browser_context = |
| 114 browser()->CreateBrowserContextBuilder().Build(); |
38 HeadlessWebContents* web_contents = | 115 HeadlessWebContents* web_contents = |
39 browser()->CreateWebContentsBuilder().SetInitialURL(bad_url).Build(); | 116 browser_context->CreateWebContentsBuilder() |
| 117 .SetInitialURL(bad_url) |
| 118 .Build(); |
| 119 |
40 EXPECT_FALSE(web_contents); | 120 EXPECT_FALSE(web_contents); |
41 EXPECT_TRUE(browser()->GetAllWebContents().empty()); | 121 EXPECT_TRUE(browser()->GetAllWebContents().empty()); |
42 } | 122 } |
43 | 123 |
44 class HeadlessBrowserTestWithProxy : public HeadlessBrowserTest { | 124 class HeadlessBrowserTestWithProxy : public HeadlessBrowserTest { |
45 public: | 125 public: |
46 HeadlessBrowserTestWithProxy() | 126 HeadlessBrowserTestWithProxy() |
47 : proxy_server_(net::SpawnedTestServer::TYPE_HTTP, | 127 : proxy_server_(net::SpawnedTestServer::TYPE_HTTP, |
48 net::SpawnedTestServer::kLocalhost, | 128 net::SpawnedTestServer::kLocalhost, |
49 base::FilePath(FILE_PATH_LITERAL("headless/test/data"))) { | 129 base::FilePath(FILE_PATH_LITERAL("headless/test/data"))) { |
50 } | 130 } |
51 | 131 |
52 void SetUp() override { | 132 void SetUp() override { |
53 ASSERT_TRUE(proxy_server_.Start()); | 133 ASSERT_TRUE(proxy_server_.Start()); |
54 HeadlessBrowserTest::SetUp(); | 134 HeadlessBrowserTest::SetUp(); |
55 } | 135 } |
56 | 136 |
57 void TearDown() override { | 137 void TearDown() override { |
58 proxy_server_.Stop(); | 138 proxy_server_.Stop(); |
59 HeadlessBrowserTest::TearDown(); | 139 HeadlessBrowserTest::TearDown(); |
60 } | 140 } |
61 | 141 |
62 net::SpawnedTestServer* proxy_server() { return &proxy_server_; } | 142 net::SpawnedTestServer* proxy_server() { return &proxy_server_; } |
63 | 143 |
64 private: | 144 private: |
65 net::SpawnedTestServer proxy_server_; | 145 net::SpawnedTestServer proxy_server_; |
66 }; | 146 }; |
67 | 147 |
68 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTestWithProxy, SetProxyServer) { | 148 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTestWithProxy, SetProxyServer) { |
69 HeadlessBrowser::Options::Builder builder; | 149 std::unique_ptr<HeadlessBrowserContext> browser_context = |
70 builder.SetProxyServer(proxy_server()->host_port_pair()); | 150 browser() |
71 SetBrowserOptions(builder.Build()); | 151 ->CreateBrowserContextBuilder() |
| 152 .SetProxyServer(proxy_server()->host_port_pair()) |
| 153 .Build(); |
72 | 154 |
73 // Load a page which doesn't actually exist, but for which the our proxy | 155 // Load a page which doesn't actually exist, but for which the our proxy |
74 // returns valid content anyway. | 156 // returns valid content anyway. |
75 // | 157 // |
76 // TODO(altimin): Currently this construction does not serve hello.html | 158 // TODO(altimin): Currently this construction does not serve hello.html |
77 // from headless/test/data as expected. We should fix this. | 159 // from headless/test/data as expected. We should fix this. |
78 HeadlessWebContents* web_contents = | 160 HeadlessWebContents* web_contents = |
79 browser() | 161 browser_context->CreateWebContentsBuilder() |
80 ->CreateWebContentsBuilder() | |
81 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) | 162 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) |
82 .Build(); | 163 .Build(); |
83 EXPECT_TRUE(WaitForLoad(web_contents)); | 164 EXPECT_TRUE(WaitForLoad(web_contents)); |
84 EXPECT_EQ(static_cast<size_t>(1), browser()->GetAllWebContents().size()); | 165 EXPECT_EQ(static_cast<size_t>(1), browser()->GetAllWebContents().size()); |
85 EXPECT_EQ(web_contents, browser()->GetAllWebContents()[0]); | 166 EXPECT_EQ(web_contents, browser()->GetAllWebContents()[0]); |
86 web_contents->Close(); | 167 web_contents->Close(); |
87 EXPECT_TRUE(browser()->GetAllWebContents().empty()); | 168 EXPECT_TRUE(browser()->GetAllWebContents().empty()); |
88 } | 169 } |
89 | 170 |
90 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, SetHostResolverRules) { | 171 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, SetHostResolverRules) { |
91 EXPECT_TRUE(embedded_test_server()->Start()); | 172 EXPECT_TRUE(embedded_test_server()->Start()); |
92 HeadlessBrowser::Options::Builder builder; | 173 |
93 builder.SetHostResolverRules( | 174 std::string host_resolver_rules = |
94 base::StringPrintf("MAP not-an-actual-domain.tld 127.0.0.1:%d", | 175 base::StringPrintf("MAP not-an-actual-domain.tld 127.0.0.1:%d", |
95 embedded_test_server()->host_port_pair().port())); | 176 embedded_test_server()->host_port_pair().port()); |
96 SetBrowserOptions(builder.Build()); | 177 |
| 178 std::unique_ptr<HeadlessBrowserContext> browser_context = |
| 179 browser() |
| 180 ->CreateBrowserContextBuilder() |
| 181 .SetHostResolverRules(host_resolver_rules) |
| 182 .Build(); |
97 | 183 |
98 // Load a page which doesn't actually exist, but which is turned into a valid | 184 // Load a page which doesn't actually exist, but which is turned into a valid |
99 // address by our host resolver rules. | 185 // address by our host resolver rules. |
100 HeadlessWebContents* web_contents = | 186 HeadlessWebContents* web_contents = |
101 browser() | 187 browser_context->CreateWebContentsBuilder() |
102 ->CreateWebContentsBuilder() | |
103 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) | 188 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) |
104 .Build(); | 189 .Build(); |
| 190 |
105 EXPECT_TRUE(WaitForLoad(web_contents)); | 191 EXPECT_TRUE(WaitForLoad(web_contents)); |
106 } | 192 } |
107 | 193 |
108 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpProtocolHandler) { | 194 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpProtocolHandler) { |
109 const std::string kResponseBody = "<p>HTTP response body</p>"; | 195 const std::string kResponseBody = "<p>HTTP response body</p>"; |
110 ProtocolHandlerMap protocol_handlers; | 196 ProtocolHandlerMap protocol_handlers; |
111 protocol_handlers[url::kHttpScheme] = | 197 protocol_handlers[url::kHttpScheme] = |
112 base::WrapUnique(new TestProtocolHandler(kResponseBody)); | 198 base::WrapUnique(new TestProtocolHandler(kResponseBody)); |
113 | 199 |
114 HeadlessBrowser::Options::Builder builder; | 200 std::unique_ptr<HeadlessBrowserContext> browser_context = |
115 builder.SetProtocolHandlers(std::move(protocol_handlers)); | 201 browser() |
116 SetBrowserOptions(builder.Build()); | 202 ->CreateBrowserContextBuilder() |
| 203 .SetProtocolHandlers(std::move(protocol_handlers)) |
| 204 .Build(); |
117 | 205 |
118 // Load a page which doesn't actually exist, but which is fetched by our | 206 // Load a page which doesn't actually exist, but which is fetched by our |
119 // custom protocol handler. | 207 // custom protocol handler. |
120 HeadlessWebContents* web_contents = | 208 HeadlessWebContents* web_contents = |
121 browser() | 209 browser_context->CreateWebContentsBuilder() |
122 ->CreateWebContentsBuilder() | |
123 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) | 210 .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html")) |
124 .Build(); | 211 .Build(); |
125 EXPECT_TRUE(WaitForLoad(web_contents)); | 212 EXPECT_TRUE(WaitForLoad(web_contents)); |
126 | 213 |
127 std::string inner_html; | 214 std::string inner_html; |
128 EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML") | 215 EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML") |
129 ->GetResult() | 216 ->GetResult() |
130 ->GetValue() | 217 ->GetValue() |
131 ->GetAsString(&inner_html)); | 218 ->GetAsString(&inner_html)); |
132 EXPECT_EQ(kResponseBody, inner_html); | 219 EXPECT_EQ(kResponseBody, inner_html); |
133 } | 220 } |
134 | 221 |
135 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpsProtocolHandler) { | 222 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpsProtocolHandler) { |
136 const std::string kResponseBody = "<p>HTTPS response body</p>"; | 223 const std::string kResponseBody = "<p>HTTPS response body</p>"; |
137 ProtocolHandlerMap protocol_handlers; | 224 ProtocolHandlerMap protocol_handlers; |
138 protocol_handlers[url::kHttpsScheme] = | 225 protocol_handlers[url::kHttpsScheme] = |
139 base::WrapUnique(new TestProtocolHandler(kResponseBody)); | 226 base::WrapUnique(new TestProtocolHandler(kResponseBody)); |
140 | 227 |
141 HeadlessBrowser::Options::Builder builder; | 228 std::unique_ptr<HeadlessBrowserContext> browser_context = |
142 builder.SetProtocolHandlers(std::move(protocol_handlers)); | 229 browser() |
143 SetBrowserOptions(builder.Build()); | 230 ->CreateBrowserContextBuilder() |
| 231 .SetProtocolHandlers(std::move(protocol_handlers)) |
| 232 .Build(); |
144 | 233 |
145 // Load a page which doesn't actually exist, but which is fetched by our | 234 // Load a page which doesn't actually exist, but which is fetched by our |
146 // custom protocol handler. | 235 // custom protocol handler. |
147 HeadlessWebContents* web_contents = | 236 HeadlessWebContents* web_contents = |
148 browser() | 237 browser_context->CreateWebContentsBuilder() |
149 ->CreateWebContentsBuilder() | |
150 .SetInitialURL(GURL("https://not-an-actual-domain.tld/hello.html")) | 238 .SetInitialURL(GURL("https://not-an-actual-domain.tld/hello.html")) |
151 .Build(); | 239 .Build(); |
152 EXPECT_TRUE(WaitForLoad(web_contents)); | 240 EXPECT_TRUE(WaitForLoad(web_contents)); |
153 | 241 |
154 std::string inner_html; | 242 std::string inner_html; |
155 EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML") | 243 EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML") |
156 ->GetResult() | 244 ->GetResult() |
157 ->GetValue() | 245 ->GetValue() |
158 ->GetAsString(&inner_html)); | 246 ->GetAsString(&inner_html)); |
159 EXPECT_EQ(kResponseBody, inner_html); | 247 EXPECT_EQ(kResponseBody, inner_html); |
160 } | 248 } |
161 | 249 |
162 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, WebGLSupported) { | 250 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, WebGLSupported) { |
| 251 std::unique_ptr<HeadlessBrowserContext> browser_context = |
| 252 browser()->CreateBrowserContextBuilder().Build(); |
| 253 |
163 HeadlessWebContents* web_contents = | 254 HeadlessWebContents* web_contents = |
164 browser()->CreateWebContentsBuilder().Build(); | 255 browser_context->CreateWebContentsBuilder().Build(); |
165 | 256 |
166 bool webgl_supported; | 257 bool webgl_supported; |
167 EXPECT_TRUE(EvaluateScript( | 258 EXPECT_TRUE(EvaluateScript( |
168 web_contents, | 259 web_contents, |
169 "(document.createElement('canvas').getContext('webgl')" | 260 "(document.createElement('canvas').getContext('webgl')" |
170 " instanceof WebGLRenderingContext)") | 261 " instanceof WebGLRenderingContext)") |
171 ->GetResult() | 262 ->GetResult() |
172 ->GetValue() | 263 ->GetValue() |
173 ->GetAsBoolean(&webgl_supported)); | 264 ->GetAsBoolean(&webgl_supported)); |
174 EXPECT_TRUE(webgl_supported); | 265 EXPECT_TRUE(webgl_supported); |
175 } | 266 } |
176 | 267 |
177 } // namespace headless | 268 } // namespace headless |
OLD | NEW |