OLD | NEW |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2013 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 "chrome/test/chromedriver/capabilities.h" | 5 #include "chrome/test/chromedriver/capabilities.h" |
6 | 6 |
7 #include "base/memory/ptr_util.h" | 7 #include "base/memory/ptr_util.h" |
8 #include "base/values.h" | 8 #include "base/values.h" |
9 #include "chrome/test/chromedriver/chrome/log.h" | 9 #include "chrome/test/chromedriver/chrome/log.h" |
10 #include "chrome/test/chromedriver/chrome/status.h" | 10 #include "chrome/test/chromedriver/chrome/status.h" |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
133 ASSERT_TRUE(status.IsOk()); | 133 ASSERT_TRUE(status.IsOk()); |
134 ASSERT_STREQ("path/to/logfile", capabilities.log_path.c_str()); | 134 ASSERT_STREQ("path/to/logfile", capabilities.log_path.c_str()); |
135 } | 135 } |
136 | 136 |
137 TEST(ParseCapabilities, Args) { | 137 TEST(ParseCapabilities, Args) { |
138 Capabilities capabilities; | 138 Capabilities capabilities; |
139 base::ListValue args; | 139 base::ListValue args; |
140 args.AppendString("arg1"); | 140 args.AppendString("arg1"); |
141 args.AppendString("arg2=val"); | 141 args.AppendString("arg2=val"); |
142 base::DictionaryValue caps; | 142 base::DictionaryValue caps; |
143 caps.Set("chromeOptions.args", args.DeepCopy()); | 143 caps.Set("chromeOptions.args", base::MakeUnique<base::Value>(args)); |
144 | 144 |
145 Status status = capabilities.Parse(caps); | 145 Status status = capabilities.Parse(caps); |
146 ASSERT_TRUE(status.IsOk()); | 146 ASSERT_TRUE(status.IsOk()); |
147 | 147 |
148 ASSERT_EQ(2u, capabilities.switches.GetSize()); | 148 ASSERT_EQ(2u, capabilities.switches.GetSize()); |
149 ASSERT_TRUE(capabilities.switches.HasSwitch("arg1")); | 149 ASSERT_TRUE(capabilities.switches.HasSwitch("arg1")); |
150 ASSERT_TRUE(capabilities.switches.HasSwitch("arg2")); | 150 ASSERT_TRUE(capabilities.switches.HasSwitch("arg2")); |
151 ASSERT_EQ("", capabilities.switches.GetSwitchValue("arg1")); | 151 ASSERT_EQ("", capabilities.switches.GetSwitchValue("arg1")); |
152 ASSERT_EQ("val", capabilities.switches.GetSwitchValue("arg2")); | 152 ASSERT_EQ("val", capabilities.switches.GetSwitchValue("arg2")); |
153 } | 153 } |
154 | 154 |
155 TEST(ParseCapabilities, Prefs) { | 155 TEST(ParseCapabilities, Prefs) { |
156 Capabilities capabilities; | 156 Capabilities capabilities; |
157 base::DictionaryValue prefs; | 157 base::DictionaryValue prefs; |
158 prefs.SetString("key1", "value1"); | 158 prefs.SetString("key1", "value1"); |
159 prefs.SetString("key2.k", "value2"); | 159 prefs.SetString("key2.k", "value2"); |
160 base::DictionaryValue caps; | 160 base::DictionaryValue caps; |
161 caps.Set("chromeOptions.prefs", prefs.DeepCopy()); | 161 caps.Set("chromeOptions.prefs", base::MakeUnique<base::Value>(prefs)); |
162 Status status = capabilities.Parse(caps); | 162 Status status = capabilities.Parse(caps); |
163 ASSERT_TRUE(status.IsOk()); | 163 ASSERT_TRUE(status.IsOk()); |
164 ASSERT_TRUE(capabilities.prefs->Equals(&prefs)); | 164 ASSERT_TRUE(capabilities.prefs->Equals(&prefs)); |
165 } | 165 } |
166 | 166 |
167 TEST(ParseCapabilities, LocalState) { | 167 TEST(ParseCapabilities, LocalState) { |
168 Capabilities capabilities; | 168 Capabilities capabilities; |
169 base::DictionaryValue local_state; | 169 base::DictionaryValue local_state; |
170 local_state.SetString("s1", "v1"); | 170 local_state.SetString("s1", "v1"); |
171 local_state.SetString("s2.s", "v2"); | 171 local_state.SetString("s2.s", "v2"); |
172 base::DictionaryValue caps; | 172 base::DictionaryValue caps; |
173 caps.Set("chromeOptions.localState", local_state.DeepCopy()); | 173 caps.Set("chromeOptions.localState", |
| 174 base::MakeUnique<base::Value>(local_state)); |
174 Status status = capabilities.Parse(caps); | 175 Status status = capabilities.Parse(caps); |
175 ASSERT_TRUE(status.IsOk()); | 176 ASSERT_TRUE(status.IsOk()); |
176 ASSERT_TRUE(capabilities.local_state->Equals(&local_state)); | 177 ASSERT_TRUE(capabilities.local_state->Equals(&local_state)); |
177 } | 178 } |
178 | 179 |
179 TEST(ParseCapabilities, Extensions) { | 180 TEST(ParseCapabilities, Extensions) { |
180 Capabilities capabilities; | 181 Capabilities capabilities; |
181 base::ListValue extensions; | 182 base::ListValue extensions; |
182 extensions.AppendString("ext1"); | 183 extensions.AppendString("ext1"); |
183 extensions.AppendString("ext2"); | 184 extensions.AppendString("ext2"); |
184 base::DictionaryValue caps; | 185 base::DictionaryValue caps; |
185 caps.Set("chromeOptions.extensions", extensions.DeepCopy()); | 186 caps.Set("chromeOptions.extensions", |
| 187 base::MakeUnique<base::Value>(extensions)); |
186 Status status = capabilities.Parse(caps); | 188 Status status = capabilities.Parse(caps); |
187 ASSERT_TRUE(status.IsOk()); | 189 ASSERT_TRUE(status.IsOk()); |
188 ASSERT_EQ(2u, capabilities.extensions.size()); | 190 ASSERT_EQ(2u, capabilities.extensions.size()); |
189 ASSERT_EQ("ext1", capabilities.extensions[0]); | 191 ASSERT_EQ("ext1", capabilities.extensions[0]); |
190 ASSERT_EQ("ext2", capabilities.extensions[1]); | 192 ASSERT_EQ("ext2", capabilities.extensions[1]); |
191 } | 193 } |
192 | 194 |
193 TEST(ParseCapabilities, UnrecognizedProxyType) { | 195 TEST(ParseCapabilities, UnrecognizedProxyType) { |
194 Capabilities capabilities; | 196 Capabilities capabilities; |
195 base::DictionaryValue proxy; | 197 base::DictionaryValue proxy; |
196 proxy.SetString("proxyType", "unknown proxy type"); | 198 proxy.SetString("proxyType", "unknown proxy type"); |
197 base::DictionaryValue caps; | 199 base::DictionaryValue caps; |
198 caps.Set("proxy", proxy.DeepCopy()); | 200 caps.Set("proxy", base::MakeUnique<base::Value>(proxy)); |
199 Status status = capabilities.Parse(caps); | 201 Status status = capabilities.Parse(caps); |
200 ASSERT_FALSE(status.IsOk()); | 202 ASSERT_FALSE(status.IsOk()); |
201 } | 203 } |
202 | 204 |
203 TEST(ParseCapabilities, IllegalProxyType) { | 205 TEST(ParseCapabilities, IllegalProxyType) { |
204 Capabilities capabilities; | 206 Capabilities capabilities; |
205 base::DictionaryValue proxy; | 207 base::DictionaryValue proxy; |
206 proxy.SetInteger("proxyType", 123); | 208 proxy.SetInteger("proxyType", 123); |
207 base::DictionaryValue caps; | 209 base::DictionaryValue caps; |
208 caps.Set("proxy", proxy.DeepCopy()); | 210 caps.Set("proxy", base::MakeUnique<base::Value>(proxy)); |
209 Status status = capabilities.Parse(caps); | 211 Status status = capabilities.Parse(caps); |
210 ASSERT_FALSE(status.IsOk()); | 212 ASSERT_FALSE(status.IsOk()); |
211 } | 213 } |
212 | 214 |
213 TEST(ParseCapabilities, DirectProxy) { | 215 TEST(ParseCapabilities, DirectProxy) { |
214 Capabilities capabilities; | 216 Capabilities capabilities; |
215 base::DictionaryValue proxy; | 217 base::DictionaryValue proxy; |
216 proxy.SetString("proxyType", "DIRECT"); | 218 proxy.SetString("proxyType", "DIRECT"); |
217 base::DictionaryValue caps; | 219 base::DictionaryValue caps; |
218 caps.Set("proxy", proxy.DeepCopy()); | 220 caps.Set("proxy", base::MakeUnique<base::Value>(proxy)); |
219 Status status = capabilities.Parse(caps); | 221 Status status = capabilities.Parse(caps); |
220 ASSERT_TRUE(status.IsOk()); | 222 ASSERT_TRUE(status.IsOk()); |
221 ASSERT_EQ(1u, capabilities.switches.GetSize()); | 223 ASSERT_EQ(1u, capabilities.switches.GetSize()); |
222 ASSERT_TRUE(capabilities.switches.HasSwitch("no-proxy-server")); | 224 ASSERT_TRUE(capabilities.switches.HasSwitch("no-proxy-server")); |
223 } | 225 } |
224 | 226 |
225 TEST(ParseCapabilities, SystemProxy) { | 227 TEST(ParseCapabilities, SystemProxy) { |
226 Capabilities capabilities; | 228 Capabilities capabilities; |
227 base::DictionaryValue proxy; | 229 base::DictionaryValue proxy; |
228 proxy.SetString("proxyType", "system"); | 230 proxy.SetString("proxyType", "system"); |
229 base::DictionaryValue caps; | 231 base::DictionaryValue caps; |
230 caps.Set("proxy", proxy.DeepCopy()); | 232 caps.Set("proxy", base::MakeUnique<base::Value>(proxy)); |
231 Status status = capabilities.Parse(caps); | 233 Status status = capabilities.Parse(caps); |
232 ASSERT_TRUE(status.IsOk()); | 234 ASSERT_TRUE(status.IsOk()); |
233 ASSERT_EQ(0u, capabilities.switches.GetSize()); | 235 ASSERT_EQ(0u, capabilities.switches.GetSize()); |
234 } | 236 } |
235 | 237 |
236 TEST(ParseCapabilities, PacProxy) { | 238 TEST(ParseCapabilities, PacProxy) { |
237 Capabilities capabilities; | 239 Capabilities capabilities; |
238 base::DictionaryValue proxy; | 240 base::DictionaryValue proxy; |
239 proxy.SetString("proxyType", "PAC"); | 241 proxy.SetString("proxyType", "PAC"); |
240 proxy.SetString("proxyAutoconfigUrl", "test.wpad"); | 242 proxy.SetString("proxyAutoconfigUrl", "test.wpad"); |
241 base::DictionaryValue caps; | 243 base::DictionaryValue caps; |
242 caps.Set("proxy", proxy.DeepCopy()); | 244 caps.Set("proxy", base::MakeUnique<base::Value>(proxy)); |
243 Status status = capabilities.Parse(caps); | 245 Status status = capabilities.Parse(caps); |
244 ASSERT_TRUE(status.IsOk()); | 246 ASSERT_TRUE(status.IsOk()); |
245 ASSERT_EQ(1u, capabilities.switches.GetSize()); | 247 ASSERT_EQ(1u, capabilities.switches.GetSize()); |
246 ASSERT_EQ("test.wpad", capabilities.switches.GetSwitchValue("proxy-pac-url")); | 248 ASSERT_EQ("test.wpad", capabilities.switches.GetSwitchValue("proxy-pac-url")); |
247 } | 249 } |
248 | 250 |
249 TEST(ParseCapabilities, MissingProxyAutoconfigUrl) { | 251 TEST(ParseCapabilities, MissingProxyAutoconfigUrl) { |
250 Capabilities capabilities; | 252 Capabilities capabilities; |
251 base::DictionaryValue proxy; | 253 base::DictionaryValue proxy; |
252 proxy.SetString("proxyType", "PAC"); | 254 proxy.SetString("proxyType", "PAC"); |
253 proxy.SetString("httpProxy", "http://localhost:8001"); | 255 proxy.SetString("httpProxy", "http://localhost:8001"); |
254 base::DictionaryValue caps; | 256 base::DictionaryValue caps; |
255 caps.Set("proxy", proxy.DeepCopy()); | 257 caps.Set("proxy", base::MakeUnique<base::Value>(proxy)); |
256 Status status = capabilities.Parse(caps); | 258 Status status = capabilities.Parse(caps); |
257 ASSERT_FALSE(status.IsOk()); | 259 ASSERT_FALSE(status.IsOk()); |
258 } | 260 } |
259 | 261 |
260 TEST(ParseCapabilities, AutodetectProxy) { | 262 TEST(ParseCapabilities, AutodetectProxy) { |
261 Capabilities capabilities; | 263 Capabilities capabilities; |
262 base::DictionaryValue proxy; | 264 base::DictionaryValue proxy; |
263 proxy.SetString("proxyType", "autodetect"); | 265 proxy.SetString("proxyType", "autodetect"); |
264 base::DictionaryValue caps; | 266 base::DictionaryValue caps; |
265 caps.Set("proxy", proxy.DeepCopy()); | 267 caps.Set("proxy", base::MakeUnique<base::Value>(proxy)); |
266 Status status = capabilities.Parse(caps); | 268 Status status = capabilities.Parse(caps); |
267 ASSERT_TRUE(status.IsOk()); | 269 ASSERT_TRUE(status.IsOk()); |
268 ASSERT_EQ(1u, capabilities.switches.GetSize()); | 270 ASSERT_EQ(1u, capabilities.switches.GetSize()); |
269 ASSERT_TRUE(capabilities.switches.HasSwitch("proxy-auto-detect")); | 271 ASSERT_TRUE(capabilities.switches.HasSwitch("proxy-auto-detect")); |
270 } | 272 } |
271 | 273 |
272 TEST(ParseCapabilities, ManualProxy) { | 274 TEST(ParseCapabilities, ManualProxy) { |
273 Capabilities capabilities; | 275 Capabilities capabilities; |
274 base::DictionaryValue proxy; | 276 base::DictionaryValue proxy; |
275 proxy.SetString("proxyType", "manual"); | 277 proxy.SetString("proxyType", "manual"); |
276 proxy.SetString("ftpProxy", "localhost:9001"); | 278 proxy.SetString("ftpProxy", "localhost:9001"); |
277 proxy.SetString("httpProxy", "localhost:8001"); | 279 proxy.SetString("httpProxy", "localhost:8001"); |
278 proxy.SetString("sslProxy", "localhost:10001"); | 280 proxy.SetString("sslProxy", "localhost:10001"); |
279 proxy.SetString("noProxy", "google.com, youtube.com"); | 281 proxy.SetString("noProxy", "google.com, youtube.com"); |
280 base::DictionaryValue caps; | 282 base::DictionaryValue caps; |
281 caps.Set("proxy", proxy.DeepCopy()); | 283 caps.Set("proxy", base::MakeUnique<base::Value>(proxy)); |
282 Status status = capabilities.Parse(caps); | 284 Status status = capabilities.Parse(caps); |
283 ASSERT_TRUE(status.IsOk()); | 285 ASSERT_TRUE(status.IsOk()); |
284 ASSERT_EQ(2u, capabilities.switches.GetSize()); | 286 ASSERT_EQ(2u, capabilities.switches.GetSize()); |
285 ASSERT_EQ( | 287 ASSERT_EQ( |
286 "ftp=localhost:9001;http=localhost:8001;https=localhost:10001", | 288 "ftp=localhost:9001;http=localhost:8001;https=localhost:10001", |
287 capabilities.switches.GetSwitchValue("proxy-server")); | 289 capabilities.switches.GetSwitchValue("proxy-server")); |
288 ASSERT_EQ( | 290 ASSERT_EQ( |
289 "google.com, youtube.com", | 291 "google.com, youtube.com", |
290 capabilities.switches.GetSwitchValue("proxy-bypass-list")); | 292 capabilities.switches.GetSwitchValue("proxy-bypass-list")); |
291 } | 293 } |
292 | 294 |
293 TEST(ParseCapabilities, MissingSettingForManualProxy) { | 295 TEST(ParseCapabilities, MissingSettingForManualProxy) { |
294 Capabilities capabilities; | 296 Capabilities capabilities; |
295 base::DictionaryValue proxy; | 297 base::DictionaryValue proxy; |
296 proxy.SetString("proxyType", "manual"); | 298 proxy.SetString("proxyType", "manual"); |
297 base::DictionaryValue caps; | 299 base::DictionaryValue caps; |
298 caps.Set("proxy", proxy.DeepCopy()); | 300 caps.Set("proxy", base::MakeUnique<base::Value>(proxy)); |
299 Status status = capabilities.Parse(caps); | 301 Status status = capabilities.Parse(caps); |
300 ASSERT_FALSE(status.IsOk()); | 302 ASSERT_FALSE(status.IsOk()); |
301 } | 303 } |
302 | 304 |
303 TEST(ParseCapabilities, IgnoreNullValueForManualProxy) { | 305 TEST(ParseCapabilities, IgnoreNullValueForManualProxy) { |
304 Capabilities capabilities; | 306 Capabilities capabilities; |
305 base::DictionaryValue proxy; | 307 base::DictionaryValue proxy; |
306 proxy.SetString("proxyType", "manual"); | 308 proxy.SetString("proxyType", "manual"); |
307 proxy.SetString("ftpProxy", "localhost:9001"); | 309 proxy.SetString("ftpProxy", "localhost:9001"); |
308 proxy.Set("sslProxy", base::MakeUnique<base::Value>()); | 310 proxy.Set("sslProxy", base::MakeUnique<base::Value>()); |
309 proxy.Set("noProxy", base::MakeUnique<base::Value>()); | 311 proxy.Set("noProxy", base::MakeUnique<base::Value>()); |
310 base::DictionaryValue caps; | 312 base::DictionaryValue caps; |
311 caps.Set("proxy", proxy.DeepCopy()); | 313 caps.Set("proxy", base::MakeUnique<base::Value>(proxy)); |
312 Status status = capabilities.Parse(caps); | 314 Status status = capabilities.Parse(caps); |
313 ASSERT_TRUE(status.IsOk()); | 315 ASSERT_TRUE(status.IsOk()); |
314 ASSERT_EQ(1u, capabilities.switches.GetSize()); | 316 ASSERT_EQ(1u, capabilities.switches.GetSize()); |
315 ASSERT_TRUE(capabilities.switches.HasSwitch("proxy-server")); | 317 ASSERT_TRUE(capabilities.switches.HasSwitch("proxy-server")); |
316 ASSERT_EQ( | 318 ASSERT_EQ( |
317 "ftp=localhost:9001", | 319 "ftp=localhost:9001", |
318 capabilities.switches.GetSwitchValue("proxy-server")); | 320 capabilities.switches.GetSwitchValue("proxy-server")); |
319 } | 321 } |
320 | 322 |
321 TEST(ParseCapabilities, LoggingPrefsOk) { | 323 TEST(ParseCapabilities, LoggingPrefsOk) { |
322 Capabilities capabilities; | 324 Capabilities capabilities; |
323 base::DictionaryValue logging_prefs; | 325 base::DictionaryValue logging_prefs; |
324 logging_prefs.SetString("Network", "INFO"); | 326 logging_prefs.SetString("Network", "INFO"); |
325 base::DictionaryValue caps; | 327 base::DictionaryValue caps; |
326 caps.Set("loggingPrefs", logging_prefs.DeepCopy()); | 328 caps.Set("loggingPrefs", base::MakeUnique<base::Value>(logging_prefs)); |
327 Status status = capabilities.Parse(caps); | 329 Status status = capabilities.Parse(caps); |
328 ASSERT_TRUE(status.IsOk()); | 330 ASSERT_TRUE(status.IsOk()); |
329 ASSERT_EQ(1u, capabilities.logging_prefs.size()); | 331 ASSERT_EQ(1u, capabilities.logging_prefs.size()); |
330 ASSERT_EQ(Log::kInfo, capabilities.logging_prefs["Network"]); | 332 ASSERT_EQ(Log::kInfo, capabilities.logging_prefs["Network"]); |
331 } | 333 } |
332 | 334 |
333 TEST(ParseCapabilities, LoggingPrefsNotDict) { | 335 TEST(ParseCapabilities, LoggingPrefsNotDict) { |
334 Capabilities capabilities; | 336 Capabilities capabilities; |
335 base::DictionaryValue caps; | 337 base::DictionaryValue caps; |
336 caps.SetString("loggingPrefs", "INFO"); | 338 caps.SetString("loggingPrefs", "INFO"); |
337 Status status = capabilities.Parse(caps); | 339 Status status = capabilities.Parse(caps); |
338 ASSERT_FALSE(status.IsOk()); | 340 ASSERT_FALSE(status.IsOk()); |
339 } | 341 } |
340 | 342 |
341 TEST(ParseCapabilities, PerfLoggingPrefsInspectorDomainStatus) { | 343 TEST(ParseCapabilities, PerfLoggingPrefsInspectorDomainStatus) { |
342 Capabilities capabilities; | 344 Capabilities capabilities; |
343 // Perf log must be enabled if performance log preferences are specified. | 345 // Perf log must be enabled if performance log preferences are specified. |
344 base::DictionaryValue logging_prefs; | 346 base::DictionaryValue logging_prefs; |
345 logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO"); | 347 logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO"); |
346 base::DictionaryValue desired_caps; | 348 base::DictionaryValue desired_caps; |
347 desired_caps.Set("loggingPrefs", logging_prefs.DeepCopy()); | 349 desired_caps.Set("loggingPrefs", |
| 350 base::MakeUnique<base::Value>(logging_prefs)); |
348 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultEnabled, | 351 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultEnabled, |
349 capabilities.perf_logging_prefs.network); | 352 capabilities.perf_logging_prefs.network); |
350 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultEnabled, | 353 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultEnabled, |
351 capabilities.perf_logging_prefs.page); | 354 capabilities.perf_logging_prefs.page); |
352 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultDisabled, | 355 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultDisabled, |
353 capabilities.perf_logging_prefs.timeline); | 356 capabilities.perf_logging_prefs.timeline); |
354 base::DictionaryValue perf_logging_prefs; | 357 base::DictionaryValue perf_logging_prefs; |
355 perf_logging_prefs.SetBoolean("enableNetwork", true); | 358 perf_logging_prefs.SetBoolean("enableNetwork", true); |
356 perf_logging_prefs.SetBoolean("enablePage", false); | 359 perf_logging_prefs.SetBoolean("enablePage", false); |
357 desired_caps.Set("chromeOptions.perfLoggingPrefs", | 360 desired_caps.Set("chromeOptions.perfLoggingPrefs", |
358 perf_logging_prefs.DeepCopy()); | 361 base::MakeUnique<base::Value>(perf_logging_prefs)); |
359 Status status = capabilities.Parse(desired_caps); | 362 Status status = capabilities.Parse(desired_caps); |
360 ASSERT_TRUE(status.IsOk()); | 363 ASSERT_TRUE(status.IsOk()); |
361 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kExplicitlyEnabled, | 364 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kExplicitlyEnabled, |
362 capabilities.perf_logging_prefs.network); | 365 capabilities.perf_logging_prefs.network); |
363 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kExplicitlyDisabled, | 366 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kExplicitlyDisabled, |
364 capabilities.perf_logging_prefs.page); | 367 capabilities.perf_logging_prefs.page); |
365 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultDisabled, | 368 ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultDisabled, |
366 capabilities.perf_logging_prefs.timeline); | 369 capabilities.perf_logging_prefs.timeline); |
367 } | 370 } |
368 | 371 |
369 TEST(ParseCapabilities, PerfLoggingPrefsTracing) { | 372 TEST(ParseCapabilities, PerfLoggingPrefsTracing) { |
370 Capabilities capabilities; | 373 Capabilities capabilities; |
371 // Perf log must be enabled if performance log preferences are specified. | 374 // Perf log must be enabled if performance log preferences are specified. |
372 base::DictionaryValue logging_prefs; | 375 base::DictionaryValue logging_prefs; |
373 logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO"); | 376 logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO"); |
374 base::DictionaryValue desired_caps; | 377 base::DictionaryValue desired_caps; |
375 desired_caps.Set("loggingPrefs", logging_prefs.DeepCopy()); | 378 desired_caps.Set("loggingPrefs", |
| 379 base::MakeUnique<base::Value>(logging_prefs)); |
376 ASSERT_EQ("", capabilities.perf_logging_prefs.trace_categories); | 380 ASSERT_EQ("", capabilities.perf_logging_prefs.trace_categories); |
377 base::DictionaryValue perf_logging_prefs; | 381 base::DictionaryValue perf_logging_prefs; |
378 perf_logging_prefs.SetString("traceCategories", "benchmark,blink.console"); | 382 perf_logging_prefs.SetString("traceCategories", "benchmark,blink.console"); |
379 perf_logging_prefs.SetInteger("bufferUsageReportingInterval", 1234); | 383 perf_logging_prefs.SetInteger("bufferUsageReportingInterval", 1234); |
380 desired_caps.Set("chromeOptions.perfLoggingPrefs", | 384 desired_caps.Set("chromeOptions.perfLoggingPrefs", |
381 perf_logging_prefs.DeepCopy()); | 385 base::MakeUnique<base::Value>(perf_logging_prefs)); |
382 Status status = capabilities.Parse(desired_caps); | 386 Status status = capabilities.Parse(desired_caps); |
383 ASSERT_TRUE(status.IsOk()); | 387 ASSERT_TRUE(status.IsOk()); |
384 ASSERT_EQ("benchmark,blink.console", | 388 ASSERT_EQ("benchmark,blink.console", |
385 capabilities.perf_logging_prefs.trace_categories); | 389 capabilities.perf_logging_prefs.trace_categories); |
386 ASSERT_EQ(1234, | 390 ASSERT_EQ(1234, |
387 capabilities.perf_logging_prefs.buffer_usage_reporting_interval); | 391 capabilities.perf_logging_prefs.buffer_usage_reporting_interval); |
388 } | 392 } |
389 | 393 |
390 TEST(ParseCapabilities, PerfLoggingPrefsInvalidInterval) { | 394 TEST(ParseCapabilities, PerfLoggingPrefsInvalidInterval) { |
391 Capabilities capabilities; | 395 Capabilities capabilities; |
392 // Perf log must be enabled if performance log preferences are specified. | 396 // Perf log must be enabled if performance log preferences are specified. |
393 base::DictionaryValue logging_prefs; | 397 base::DictionaryValue logging_prefs; |
394 logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO"); | 398 logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO"); |
395 base::DictionaryValue desired_caps; | 399 base::DictionaryValue desired_caps; |
396 desired_caps.Set("loggingPrefs", logging_prefs.DeepCopy()); | 400 desired_caps.Set("loggingPrefs", |
| 401 base::MakeUnique<base::Value>(logging_prefs)); |
397 base::DictionaryValue perf_logging_prefs; | 402 base::DictionaryValue perf_logging_prefs; |
398 // A bufferUsageReportingInterval interval <= 0 will cause DevTools errors. | 403 // A bufferUsageReportingInterval interval <= 0 will cause DevTools errors. |
399 perf_logging_prefs.SetInteger("bufferUsageReportingInterval", 0); | 404 perf_logging_prefs.SetInteger("bufferUsageReportingInterval", 0); |
400 desired_caps.Set("chromeOptions.perfLoggingPrefs", | 405 desired_caps.Set("chromeOptions.perfLoggingPrefs", |
401 perf_logging_prefs.DeepCopy()); | 406 base::MakeUnique<base::Value>(perf_logging_prefs)); |
402 Status status = capabilities.Parse(desired_caps); | 407 Status status = capabilities.Parse(desired_caps); |
403 ASSERT_FALSE(status.IsOk()); | 408 ASSERT_FALSE(status.IsOk()); |
404 } | 409 } |
405 | 410 |
406 TEST(ParseCapabilities, PerfLoggingPrefsNotDict) { | 411 TEST(ParseCapabilities, PerfLoggingPrefsNotDict) { |
407 Capabilities capabilities; | 412 Capabilities capabilities; |
408 // Perf log must be enabled if performance log preferences are specified. | 413 // Perf log must be enabled if performance log preferences are specified. |
409 base::DictionaryValue logging_prefs; | 414 base::DictionaryValue logging_prefs; |
410 logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO"); | 415 logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO"); |
411 base::DictionaryValue desired_caps; | 416 base::DictionaryValue desired_caps; |
412 desired_caps.Set("loggingPrefs", logging_prefs.DeepCopy()); | 417 desired_caps.Set("loggingPrefs", |
| 418 base::MakeUnique<base::Value>(logging_prefs)); |
413 desired_caps.SetString("chromeOptions.perfLoggingPrefs", "traceCategories"); | 419 desired_caps.SetString("chromeOptions.perfLoggingPrefs", "traceCategories"); |
414 Status status = capabilities.Parse(desired_caps); | 420 Status status = capabilities.Parse(desired_caps); |
415 ASSERT_FALSE(status.IsOk()); | 421 ASSERT_FALSE(status.IsOk()); |
416 } | 422 } |
417 | 423 |
418 TEST(ParseCapabilities, PerfLoggingPrefsNoPerfLogLevel) { | 424 TEST(ParseCapabilities, PerfLoggingPrefsNoPerfLogLevel) { |
419 Capabilities capabilities; | 425 Capabilities capabilities; |
420 base::DictionaryValue desired_caps; | 426 base::DictionaryValue desired_caps; |
421 base::DictionaryValue perf_logging_prefs; | 427 base::DictionaryValue perf_logging_prefs; |
422 perf_logging_prefs.SetBoolean("enableNetwork", true); | 428 perf_logging_prefs.SetBoolean("enableNetwork", true); |
423 desired_caps.Set("chromeOptions.perfLoggingPrefs", | 429 desired_caps.Set("chromeOptions.perfLoggingPrefs", |
424 perf_logging_prefs.DeepCopy()); | 430 base::MakeUnique<base::Value>(perf_logging_prefs)); |
425 // Should fail because perf log must be enabled if perf log prefs specified. | 431 // Should fail because perf log must be enabled if perf log prefs specified. |
426 Status status = capabilities.Parse(desired_caps); | 432 Status status = capabilities.Parse(desired_caps); |
427 ASSERT_FALSE(status.IsOk()); | 433 ASSERT_FALSE(status.IsOk()); |
428 } | 434 } |
429 | 435 |
430 TEST(ParseCapabilities, PerfLoggingPrefsPerfLogOff) { | 436 TEST(ParseCapabilities, PerfLoggingPrefsPerfLogOff) { |
431 Capabilities capabilities; | 437 Capabilities capabilities; |
432 base::DictionaryValue logging_prefs; | 438 base::DictionaryValue logging_prefs; |
433 // Disable performance log by setting logging level to OFF. | 439 // Disable performance log by setting logging level to OFF. |
434 logging_prefs.SetString(WebDriverLog::kPerformanceType, "OFF"); | 440 logging_prefs.SetString(WebDriverLog::kPerformanceType, "OFF"); |
435 base::DictionaryValue desired_caps; | 441 base::DictionaryValue desired_caps; |
436 desired_caps.Set("loggingPrefs", logging_prefs.DeepCopy()); | 442 desired_caps.Set("loggingPrefs", |
| 443 base::MakeUnique<base::Value>(logging_prefs)); |
437 base::DictionaryValue perf_logging_prefs; | 444 base::DictionaryValue perf_logging_prefs; |
438 perf_logging_prefs.SetBoolean("enableNetwork", true); | 445 perf_logging_prefs.SetBoolean("enableNetwork", true); |
439 desired_caps.Set("chromeOptions.perfLoggingPrefs", | 446 desired_caps.Set("chromeOptions.perfLoggingPrefs", |
440 perf_logging_prefs.DeepCopy()); | 447 base::MakeUnique<base::Value>(perf_logging_prefs)); |
441 // Should fail because perf log must be enabled if perf log prefs specified. | 448 // Should fail because perf log must be enabled if perf log prefs specified. |
442 Status status = capabilities.Parse(desired_caps); | 449 Status status = capabilities.Parse(desired_caps); |
443 ASSERT_FALSE(status.IsOk()); | 450 ASSERT_FALSE(status.IsOk()); |
444 } | 451 } |
445 | 452 |
446 TEST(ParseCapabilities, ExcludeSwitches) { | 453 TEST(ParseCapabilities, ExcludeSwitches) { |
447 Capabilities capabilities; | 454 Capabilities capabilities; |
448 base::ListValue exclude_switches; | 455 base::ListValue exclude_switches; |
449 exclude_switches.AppendString("switch1"); | 456 exclude_switches.AppendString("switch1"); |
450 exclude_switches.AppendString("switch2"); | 457 exclude_switches.AppendString("switch2"); |
451 base::DictionaryValue caps; | 458 base::DictionaryValue caps; |
452 caps.Set("chromeOptions.excludeSwitches", exclude_switches.DeepCopy()); | 459 caps.Set("chromeOptions.excludeSwitches", |
| 460 base::MakeUnique<base::Value>(exclude_switches)); |
453 Status status = capabilities.Parse(caps); | 461 Status status = capabilities.Parse(caps); |
454 ASSERT_TRUE(status.IsOk()); | 462 ASSERT_TRUE(status.IsOk()); |
455 ASSERT_EQ(2u, capabilities.exclude_switches.size()); | 463 ASSERT_EQ(2u, capabilities.exclude_switches.size()); |
456 const std::set<std::string>& switches = capabilities.exclude_switches; | 464 const std::set<std::string>& switches = capabilities.exclude_switches; |
457 ASSERT_TRUE(switches.find("switch1") != switches.end()); | 465 ASSERT_TRUE(switches.find("switch1") != switches.end()); |
458 ASSERT_TRUE(switches.find("switch2") != switches.end()); | 466 ASSERT_TRUE(switches.find("switch2") != switches.end()); |
459 } | 467 } |
460 | 468 |
461 TEST(ParseCapabilities, UseRemoteBrowser) { | 469 TEST(ParseCapabilities, UseRemoteBrowser) { |
462 Capabilities capabilities; | 470 Capabilities capabilities; |
463 base::DictionaryValue caps; | 471 base::DictionaryValue caps; |
464 caps.SetString("chromeOptions.debuggerAddress", "abc:123"); | 472 caps.SetString("chromeOptions.debuggerAddress", "abc:123"); |
465 Status status = capabilities.Parse(caps); | 473 Status status = capabilities.Parse(caps); |
466 ASSERT_TRUE(status.IsOk()); | 474 ASSERT_TRUE(status.IsOk()); |
467 ASSERT_TRUE(capabilities.IsRemoteBrowser()); | 475 ASSERT_TRUE(capabilities.IsRemoteBrowser()); |
468 ASSERT_EQ("abc", capabilities.debugger_address.host()); | 476 ASSERT_EQ("abc", capabilities.debugger_address.host()); |
469 ASSERT_EQ(123, capabilities.debugger_address.port()); | 477 ASSERT_EQ(123, capabilities.debugger_address.port()); |
470 } | 478 } |
471 | 479 |
472 TEST(ParseCapabilities, MobileEmulationUserAgent) { | 480 TEST(ParseCapabilities, MobileEmulationUserAgent) { |
473 Capabilities capabilities; | 481 Capabilities capabilities; |
474 base::DictionaryValue mobile_emulation; | 482 base::DictionaryValue mobile_emulation; |
475 mobile_emulation.SetString("userAgent", "Agent Smith"); | 483 mobile_emulation.SetString("userAgent", "Agent Smith"); |
476 base::DictionaryValue caps; | 484 base::DictionaryValue caps; |
477 caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy()); | 485 caps.Set("chromeOptions.mobileEmulation", |
| 486 base::MakeUnique<base::Value>(mobile_emulation)); |
478 Status status = capabilities.Parse(caps); | 487 Status status = capabilities.Parse(caps); |
479 ASSERT_TRUE(status.IsOk()); | 488 ASSERT_TRUE(status.IsOk()); |
480 | 489 |
481 ASSERT_EQ(1u, capabilities.switches.GetSize()); | 490 ASSERT_EQ(1u, capabilities.switches.GetSize()); |
482 ASSERT_TRUE(capabilities.switches.HasSwitch("user-agent")); | 491 ASSERT_TRUE(capabilities.switches.HasSwitch("user-agent")); |
483 ASSERT_EQ("Agent Smith", capabilities.switches.GetSwitchValue("user-agent")); | 492 ASSERT_EQ("Agent Smith", capabilities.switches.GetSwitchValue("user-agent")); |
484 } | 493 } |
485 | 494 |
486 TEST(ParseCapabilities, MobileEmulationDeviceMetrics) { | 495 TEST(ParseCapabilities, MobileEmulationDeviceMetrics) { |
487 Capabilities capabilities; | 496 Capabilities capabilities; |
488 base::DictionaryValue mobile_emulation; | 497 base::DictionaryValue mobile_emulation; |
489 mobile_emulation.SetInteger("deviceMetrics.width", 360); | 498 mobile_emulation.SetInteger("deviceMetrics.width", 360); |
490 mobile_emulation.SetInteger("deviceMetrics.height", 640); | 499 mobile_emulation.SetInteger("deviceMetrics.height", 640); |
491 mobile_emulation.SetDouble("deviceMetrics.pixelRatio", 3.0); | 500 mobile_emulation.SetDouble("deviceMetrics.pixelRatio", 3.0); |
492 base::DictionaryValue caps; | 501 base::DictionaryValue caps; |
493 caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy()); | 502 caps.Set("chromeOptions.mobileEmulation", |
| 503 base::MakeUnique<base::Value>(mobile_emulation)); |
494 Status status = capabilities.Parse(caps); | 504 Status status = capabilities.Parse(caps); |
495 ASSERT_TRUE(status.IsOk()); | 505 ASSERT_TRUE(status.IsOk()); |
496 | 506 |
497 ASSERT_EQ(360, capabilities.device_metrics->width); | 507 ASSERT_EQ(360, capabilities.device_metrics->width); |
498 ASSERT_EQ(640, capabilities.device_metrics->height); | 508 ASSERT_EQ(640, capabilities.device_metrics->height); |
499 ASSERT_EQ(3.0, capabilities.device_metrics->device_scale_factor); | 509 ASSERT_EQ(3.0, capabilities.device_metrics->device_scale_factor); |
500 } | 510 } |
501 | 511 |
502 TEST(ParseCapabilities, MobileEmulationDeviceName) { | 512 TEST(ParseCapabilities, MobileEmulationDeviceName) { |
503 Capabilities capabilities; | 513 Capabilities capabilities; |
504 base::DictionaryValue mobile_emulation; | 514 base::DictionaryValue mobile_emulation; |
505 mobile_emulation.SetString("deviceName", "Google Nexus 5"); | 515 mobile_emulation.SetString("deviceName", "Google Nexus 5"); |
506 base::DictionaryValue caps; | 516 base::DictionaryValue caps; |
507 caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy()); | 517 caps.Set("chromeOptions.mobileEmulation", |
| 518 base::MakeUnique<base::Value>(mobile_emulation)); |
508 Status status = capabilities.Parse(caps); | 519 Status status = capabilities.Parse(caps); |
509 ASSERT_TRUE(status.IsOk()); | 520 ASSERT_TRUE(status.IsOk()); |
510 | 521 |
511 ASSERT_EQ(1u, capabilities.switches.GetSize()); | 522 ASSERT_EQ(1u, capabilities.switches.GetSize()); |
512 ASSERT_TRUE(capabilities.switches.HasSwitch("user-agent")); | 523 ASSERT_TRUE(capabilities.switches.HasSwitch("user-agent")); |
513 ASSERT_EQ( | 524 ASSERT_EQ( |
514 "Mozilla/5.0 (Linux; Android 4.4.4; Nexus 5 Build/KTU84P) " | 525 "Mozilla/5.0 (Linux; Android 4.4.4; Nexus 5 Build/KTU84P) " |
515 "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.114 Mobile " | 526 "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.114 Mobile " |
516 "Safari/537.36", | 527 "Safari/537.36", |
517 capabilities.switches.GetSwitchValue("user-agent")); | 528 capabilities.switches.GetSwitchValue("user-agent")); |
518 | 529 |
519 ASSERT_EQ(360, capabilities.device_metrics->width); | 530 ASSERT_EQ(360, capabilities.device_metrics->width); |
520 ASSERT_EQ(640, capabilities.device_metrics->height); | 531 ASSERT_EQ(640, capabilities.device_metrics->height); |
521 ASSERT_EQ(3.0, capabilities.device_metrics->device_scale_factor); | 532 ASSERT_EQ(3.0, capabilities.device_metrics->device_scale_factor); |
522 } | 533 } |
523 | 534 |
524 TEST(ParseCapabilities, MobileEmulationNotDict) { | 535 TEST(ParseCapabilities, MobileEmulationNotDict) { |
525 Capabilities capabilities; | 536 Capabilities capabilities; |
526 base::DictionaryValue caps; | 537 base::DictionaryValue caps; |
527 caps.SetString("chromeOptions.mobileEmulation", "Google Nexus 5"); | 538 caps.SetString("chromeOptions.mobileEmulation", "Google Nexus 5"); |
528 Status status = capabilities.Parse(caps); | 539 Status status = capabilities.Parse(caps); |
529 ASSERT_FALSE(status.IsOk()); | 540 ASSERT_FALSE(status.IsOk()); |
530 } | 541 } |
531 | 542 |
532 TEST(ParseCapabilities, MobileEmulationDeviceMetricsNotDict) { | 543 TEST(ParseCapabilities, MobileEmulationDeviceMetricsNotDict) { |
533 Capabilities capabilities; | 544 Capabilities capabilities; |
534 base::DictionaryValue mobile_emulation; | 545 base::DictionaryValue mobile_emulation; |
535 mobile_emulation.SetInteger("deviceMetrics", 360); | 546 mobile_emulation.SetInteger("deviceMetrics", 360); |
536 base::DictionaryValue caps; | 547 base::DictionaryValue caps; |
537 caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy()); | 548 caps.Set("chromeOptions.mobileEmulation", |
| 549 base::MakeUnique<base::Value>(mobile_emulation)); |
538 Status status = capabilities.Parse(caps); | 550 Status status = capabilities.Parse(caps); |
539 ASSERT_FALSE(status.IsOk()); | 551 ASSERT_FALSE(status.IsOk()); |
540 } | 552 } |
541 | 553 |
542 TEST(ParseCapabilities, MobileEmulationDeviceMetricsNotNumbers) { | 554 TEST(ParseCapabilities, MobileEmulationDeviceMetricsNotNumbers) { |
543 Capabilities capabilities; | 555 Capabilities capabilities; |
544 base::DictionaryValue mobile_emulation; | 556 base::DictionaryValue mobile_emulation; |
545 mobile_emulation.SetString("deviceMetrics.width", "360"); | 557 mobile_emulation.SetString("deviceMetrics.width", "360"); |
546 mobile_emulation.SetString("deviceMetrics.height", "640"); | 558 mobile_emulation.SetString("deviceMetrics.height", "640"); |
547 mobile_emulation.SetString("deviceMetrics.pixelRatio", "3.0"); | 559 mobile_emulation.SetString("deviceMetrics.pixelRatio", "3.0"); |
548 base::DictionaryValue caps; | 560 base::DictionaryValue caps; |
549 caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy()); | 561 caps.Set("chromeOptions.mobileEmulation", |
| 562 base::MakeUnique<base::Value>(mobile_emulation)); |
550 Status status = capabilities.Parse(caps); | 563 Status status = capabilities.Parse(caps); |
551 ASSERT_FALSE(status.IsOk()); | 564 ASSERT_FALSE(status.IsOk()); |
552 } | 565 } |
553 | 566 |
554 TEST(ParseCapabilities, MobileEmulationBadDict) { | 567 TEST(ParseCapabilities, MobileEmulationBadDict) { |
555 Capabilities capabilities; | 568 Capabilities capabilities; |
556 base::DictionaryValue mobile_emulation; | 569 base::DictionaryValue mobile_emulation; |
557 mobile_emulation.SetString("deviceName", "Google Nexus 5"); | 570 mobile_emulation.SetString("deviceName", "Google Nexus 5"); |
558 mobile_emulation.SetInteger("deviceMetrics.width", 360); | 571 mobile_emulation.SetInteger("deviceMetrics.width", 360); |
559 mobile_emulation.SetInteger("deviceMetrics.height", 640); | 572 mobile_emulation.SetInteger("deviceMetrics.height", 640); |
560 mobile_emulation.SetDouble("deviceMetrics.pixelRatio", 3.0); | 573 mobile_emulation.SetDouble("deviceMetrics.pixelRatio", 3.0); |
561 base::DictionaryValue caps; | 574 base::DictionaryValue caps; |
562 caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy()); | 575 caps.Set("chromeOptions.mobileEmulation", |
| 576 base::MakeUnique<base::Value>(mobile_emulation)); |
563 Status status = capabilities.Parse(caps); | 577 Status status = capabilities.Parse(caps); |
564 ASSERT_FALSE(status.IsOk()); | 578 ASSERT_FALSE(status.IsOk()); |
565 } | 579 } |
OLD | NEW |