use command::Parameters;
use error::{ErrorStatus, WebDriverError, WebDriverResult};
use rustc_serialize::json::{Json, ToJson};
use std::collections::BTreeMap;
use url::Url;
pub type Capabilities = BTreeMap<String, Json>;
/// Trait for objects that can be used to inspect browser capabilities
///
/// The main methods in this trait are called with a Capabilites object
/// resulting from a full set of potential capabilites for the session.
/// Given those Capabilities they return a property of the browser instance
/// that would be initiated. In many cases this will be independent of the
/// input, but in the case of e.g. browser version, it might depend on a
/// path to the binary provided as a capability.
pub trait BrowserCapabilities {
/// Set up the Capabilites object
///
/// Typically used to create any internal caches
fn init(&mut self, &Capabilities);
/// Name of the browser
fn browser_name(&mut self, &Capabilities) -> WebDriverResult<Option<String>>;
/// Version number of the browser
fn browser_version(&mut self, &Capabilities) -> WebDriverResult<Option<String>>;
/// Compare actual browser version to that provided in a version specifier
///
/// Parameters are the actual browser version and the comparison string,
/// respectively. The format of the comparison string is implementation-defined.
fn compare_browser_version(&mut self, version: &str, comparison: &str) -> WebDriverResult<bool>;
/// Name of the platform/OS
fn platform_name(&mut self, &Capabilities) -> WebDriverResult<Option<String>>;
/// Whether insecure certificates are supported
fn accept_insecure_certs(&mut self, &Capabilities) -> WebDriverResult<bool>;
fn accept_proxy(&mut self, proxy_settings: &BTreeMap<String, Json>, &Capabilities) -> WebDriverResult<bool>;
/// Type check custom properties
///
/// Check that custom properties containing ":" have the correct data types.
/// Properties that are unrecognised must be ignored i.e. return without
/// error.
fn validate_custom(&self, name: &str, value: &Json) -> WebDriverResult<()>;
/// Check if custom properties are accepted capabilites
///
/// Check that custom properties containing ":" are compatible with
/// the implementation.
fn accept_custom(&mut self, name: &str, value: &Json, merged: &Capabilities) -> WebDriverResult<bool>;
}
/// Trait to abstract over various version of the new session parameters
///
/// This trait is expected to be implemented on objects holding the capabilities
/// from a new session command.
pub trait CapabilitiesMatching {
/// Match the BrowserCapabilities against some candidate capabilites
///
/// Takes a BrowserCapabilites object and returns a set of capabilites that
/// are valid for that browser, if any, or None if there are no matching
/// capabilities.
fn match_browser<T: BrowserCapabilities>(&self, browser_capabilities: &mut T)
-> WebDriverResult<Option<Capabilities>>;
}
#[derive(Debug, PartialEq)]
pub struct SpecNewSessionParameters {
pub alwaysMatch: Capabilities,
pub firstMatch: Vec<Capabilities>,
}
impl SpecNewSessionParameters {
fn validate<T: BrowserCapabilities>(&self,
mut capabilities: Capabilities,
browser_capabilities: &T) -> WebDriverResult<Capabilities> {
// Filter out entries with the value `null`
let null_entries = capabilities
.iter()
.filter(|&(_, ref value)| **value == Json::Null)
.map(|(k, _)| k.clone())
.collect::<Vec<String>>();
for key in null_entries {
capabilities.remove(&key);
}
for (key, value) in capabilities.iter() {
match &**key {
"acceptInsecureCerts" => if !value.is_boolean() {
return Err(WebDriverError::new(ErrorStatus::InvalidArgument,
format!("acceptInsecureCerts is not boolean: {}", value)))
},
x @ "browserName" |
x @ "browserVersion" |
x @ "platformName" => if !value.is_string() {
return Err(WebDriverError::new(ErrorStatus::InvalidArgument,
format!("{} is not a string: {}", x, value)))
},
"pageLoadStrategy" => {
try!(SpecNewSessionParameters::validate_page_load_strategy(value))
}
"proxy" => {
try!(SpecNewSessionParameters::validate_proxy(value))
},
"timeouts" => {
try!(SpecNewSessionParameters::validate_timeouts(value))
},
"unhandledPromptBehavior" => {
try!(SpecNewSessionParameters::validate_unhandled_prompt_behaviour(value))
}
x => {
if !x.contains(":") {
return Err(WebDriverError::new(ErrorStatus::InvalidArgument,
format!("{} is not the name of a known capability or extension capability", x)))
} else {
try!(browser_capabilities.validate_custom(x, value));
}
}
}
}
Ok(capabilities)
}
fn validate_page_load_strategy(value: &Json) -> WebDriverResult<()> {
match value {
&Json::String(ref x) => {
match &**x {
"normal" |
"eager" |
"none" => {},
x => {
return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("Invalid page load strategy: {}", x)))
}
}
}
_ => return Err(WebDriverError::new(ErrorStatus::InvalidArgument,
"pageLoadStrategy is not a string"))
}
Ok(())
}
fn validate_proxy(proxy_value: &Json) -> WebDriverResult<()> {
let obj = try_opt!(proxy_value.as_object(),
ErrorStatus::InvalidArgument,
"proxy is not an object");
for (key, value) in obj.iter() {
match &**key {
"proxyType" => match value.as_string() {
Some("pac") |
Some("direct") |
Some("autodetect") |
Some("system") |
Some("manual") => {},
Some(x) => return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("Invalid proxyType value: {}", x))),
None => return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("proxyType is not a string: {}", value))),
},
"proxyAutoconfigUrl" => match value.as_string() {
Some(x) => {
Url::parse(x).or(Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("proxyAutoconfigUrl is not a valid URL: {}", x))))?;
},
None => return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
"proxyAutoconfigUrl is not a string"
))
},
"ftpProxy" => SpecNewSessionParameters::validate_host(value, "ftpProxy")?,
"httpProxy" => SpecNewSessionParameters::validate_host(value, "httpProxy")?,
"noProxy" => SpecNewSessionParameters::validate_no_proxy(value)?,
"sslProxy" => SpecNewSessionParameters::validate_host(value, "sslProxy")?,
"socksProxy" => SpecNewSessionParameters::validate_host(value, "socksProxy")?,
"socksVersion" => if !value.is_number() {
return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("socksVersion is not a number: {}", value)
))
},
x => return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("Invalid proxy configuration entry: {}", x)))
}
}
Ok(())
}
fn validate_no_proxy(value: &Json) -> WebDriverResult<()> {
match value.as_array() {
Some(hosts) => {
for host in hosts {
match host.as_string() {
Some(_) => {},
None => return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("noProxy item is not a string: {}", host)
))
}
}
},
None => return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("noProxy is not an array: {}", value)
))
}
Ok(())
}
/// Validate whether a named capability is JSON value is a string containing a host
/// and possible port
fn validate_host(value: &Json, entry: &str) -> WebDriverResult<()> {
match value.as_string() {
Some(host) => {
if host.contains("://") {
return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("{} must not contain a scheme: {}", entry, host)));
}
// Temporarily add a scheme so the host can be parsed as URL
let s = String::from(format!("http://{}", host));
let url = Url::parse(s.as_str()).or(Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("{} is not a valid URL: {}", entry, host))))?;
if url.username() != "" ||
url.password() != None ||
url.path() != "/" ||
url.query() != None ||
url.fragment() != None {
return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("{} is not of the form host[:port]: {}", entry, host)));
}
},
None => return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("{} is not a string: {}", entry, value)
))
}
Ok(())
}
fn validate_timeouts(value: &Json) -> WebDriverResult<()> {
let obj = try_opt!(
value.as_object(),
ErrorStatus::InvalidArgument,
"timeouts capability is not an object"
);
for (key, value) in obj.iter() {
match &**key {
x @ "script" | x @ "pageLoad" | x @ "implicit" => {
let timeout = try_opt!(
value.as_i64(),
ErrorStatus::InvalidArgument,
format!("{} timeouts value is not an integer: {}", x, value)
);
if timeout < 0 {
return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("{} timeouts value is negative: {}", x, timeout),
));
}
}
x => {
return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("Invalid timeouts capability entry: {}", x),
))
}
}
}
Ok(())
}
fn validate_unhandled_prompt_behaviour(value: &Json) -> WebDriverResult<()> {
let behaviour = try_opt!(
value.as_string(),
ErrorStatus::InvalidArgument,
format!("unhandledPromptBehavior is not a string: {}", value)
);
match behaviour {
"dismiss" | "accept" => {}
x => {
return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
format!("Invalid unhandledPromptBehavior value: {}", x),
))
}
}
Ok(())
}
}
impl Parameters for SpecNewSessionParameters {
fn from_json(body: &Json) -> WebDriverResult<SpecNewSessionParameters> {
let data = try_opt!(
body.as_object(),
ErrorStatus::UnknownError,
format!("Malformed capabilities, message body is not an object: {}", body)
);
let capabilities = try_opt!(
try_opt!(
data.get("capabilities"),
ErrorStatus::InvalidArgument,
"Malformed capabilities, missing \"capabilities\" field"
).as_object(),
ErrorStatus::InvalidArgument,
"Malformed capabilities, \"capabilities\" field is not an object}"
);
let default_always_match = Json::Object(Capabilities::new());
let always_match = try_opt!(
capabilities
.get("alwaysMatch")
.unwrap_or(&default_always_match)
.as_object(),
ErrorStatus::InvalidArgument,
"Malformed capabilities, alwaysMatch field is not an object"
);
let default_first_matches = Json::Array(vec![]);
let first_matches = try_opt!(
capabilities
.get("firstMatch")
.unwrap_or(&default_first_matches)
.as_array(),
ErrorStatus::InvalidArgument,
"Malformed capabilities, firstMatch field is not an array"
).iter()
.map(|x| {
x.as_object().map(|x| x.clone()).ok_or(WebDriverError::new(
ErrorStatus::InvalidArgument,
"Malformed capabilities, firstMatch entry is not an object",
))
})
.collect::<WebDriverResult<Vec<Capabilities>>>()?;
return Ok(SpecNewSessionParameters {
alwaysMatch: always_match.clone(),
firstMatch: first_matches,
});
}
}
impl ToJson for SpecNewSessionParameters {
fn to_json(&self) -> Json {
let mut body = BTreeMap::new();
let mut capabilities = BTreeMap::new();
capabilities.insert("alwaysMatch".into(), self.alwaysMatch.to_json());
capabilities.insert("firstMatch".into(), self.firstMatch.to_json());
body.insert("capabilities".into(), capabilities.to_json());
Json::Object(body)
}
}
impl CapabilitiesMatching for SpecNewSessionParameters {
fn match_browser<T: BrowserCapabilities>(
&self,
browser_capabilities: &mut T,
) -> WebDriverResult<Option<Capabilities>> {
let default = vec![BTreeMap::new()];
let capabilities_list = if self.firstMatch.len() > 0 {
&self.firstMatch
} else {
&default
};
let merged_capabilities = capabilities_list
.iter()
.map(|first_match_entry| {
if first_match_entry.keys().any(|k| self.alwaysMatch.contains_key(k)) {
return Err(WebDriverError::new(
ErrorStatus::InvalidArgument,
"firstMatch key shadowed a value in alwaysMatch",
));
}
let mut merged = self.alwaysMatch.clone();
merged.append(&mut first_match_entry.clone());
Ok(merged)
})
.map(|merged| {
merged.and_then(|x| self.validate(x, browser_capabilities))
})
.collect::<WebDriverResult<Vec<Capabilities>>>()?;
let selected = merged_capabilities
.iter()
.filter_map(|merged| {
browser_capabilities.init(merged);
for (key, value) in merged.iter() {
match &**key {
"browserName" => {
let browserValue = browser_capabilities
.browser_name(merged)
.ok()
.and_then(|x| x);
if value.as_string() != browserValue.as_ref().map(|x| &**x) {
return None;
}
}
"browserVersion" => {
let browserValue = browser_capabilities
.browser_version(merged)
.ok()
.and_then(|x| x);
// We already validated this was a string
let version_cond = value.as_string().unwrap_or("");
if let Some(version) = browserValue {
if !browser_capabilities
.compare_browser_version(&*version, version_cond)
.unwrap_or(false)
{
return None;
}
} else {
return None;
}
}
"platformName" => {
let browserValue = browser_capabilities
.platform_name(merged)
.ok()
.and_then(|x| x);
if value.as_string() != browserValue.as_ref().map(|x| &**x) {
return None;
}
}
"acceptInsecureCerts" => {
if value.as_boolean().unwrap_or(false) &&
!browser_capabilities
.accept_insecure_certs(merged)
.unwrap_or(false)
{
return None;
}
}
"proxy" => {
let default = BTreeMap::new();
let proxy = value.as_object().unwrap_or(&default);
if !browser_capabilities
.accept_proxy(&proxy, merged)
.unwrap_or(false)
{
return None;
}
}
name => {
if name.contains(":") {
if !browser_capabilities
.accept_custom(name, value, merged)
.unwrap_or(false)
{
return None;
}
} else {
// Accept the capability
}
}
}
}
return Some(merged);
})
.next()
.map(|x| x.clone());
Ok(selected)
}
}
#[derive(Debug, PartialEq)]
pub struct LegacyNewSessionParameters {
pub desired: Capabilities,
pub required: Capabilities,
}
impl CapabilitiesMatching for LegacyNewSessionParameters {
fn match_browser<T: BrowserCapabilities>(
&self,
browser_capabilities: &mut T,
) -> WebDriverResult<Option<Capabilities>> {
// For now don't do anything much, just merge the
// desired and required and return the merged list.
let mut capabilities: Capabilities = BTreeMap::new();
self.required.iter().chain(self.desired.iter()).fold(
&mut capabilities,
|caps, (key, value)| {
if !caps.contains_key(key) {
caps.insert(key.clone(), value.clone());
}
caps
},
);
browser_capabilities.init(&capabilities);
Ok(Some(capabilities))
}
}
impl Parameters for LegacyNewSessionParameters {
fn from_json(body: &Json) -> WebDriverResult<LegacyNewSessionParameters> {
let data = try_opt!(
body.as_object(),
ErrorStatus::UnknownError,
format!("Malformed legacy capabilities, message body is not an object: {}", body)
);
let desired = if let Some(capabilities) = data.get("desiredCapabilities") {
try_opt!(
capabilities.as_object(),
ErrorStatus::InvalidArgument,
"Malformed legacy capabilities, desiredCapabilities field is not an object"
).clone()
} else {
BTreeMap::new()
};
let required = if let Some(capabilities) = data.get("requiredCapabilities") {
try_opt!(
capabilities.as_object(),
ErrorStatus::InvalidArgument,
"Malformed legacy capabilities, requiredCapabilities field is not an object"
).clone()
} else {
BTreeMap::new()
};
Ok(LegacyNewSessionParameters { desired, required })
}
}
impl ToJson for LegacyNewSessionParameters {
fn to_json(&self) -> Json {
let mut data = BTreeMap::new();
data.insert("desiredCapabilities".to_owned(), self.desired.to_json());
data.insert("requiredCapabilities".to_owned(), self.required.to_json());
Json::Object(data)
}
}
#[cfg(test)]
mod tests {
use rustc_serialize::json::Json;
use super::{SpecNewSessionParameters, WebDriverResult};
fn validate_proxy(value: &str) -> WebDriverResult<()> {
let data = Json::from_str(value).unwrap();
SpecNewSessionParameters::validate_proxy(&data)
}
#[test]
fn test_validate_proxy() {
// proxy hosts
validate_proxy("{\"httpProxy\": \"127.0.0.1\"}").unwrap();
validate_proxy("{\"httpProxy\": \"127.0.0.1:\"}").unwrap();
validate_proxy("{\"httpProxy\": \"127.0.0.1:3128\"}").unwrap();
validate_proxy("{\"httpProxy\": \"localhost\"}").unwrap();
validate_proxy("{\"httpProxy\": \"localhost:3128\"}").unwrap();
validate_proxy("{\"httpProxy\": \"[2001:db8::1]\"}").unwrap();
validate_proxy("{\"httpProxy\": \"[2001:db8::1]:3128\"}").unwrap();
validate_proxy("{\"httpProxy\": \"example.org\"}").unwrap();
validate_proxy("{\"httpProxy\": \"example.org:3128\"}").unwrap();
assert!(validate_proxy("{\"httpProxy\": \"http://example.org\"}").is_err());
assert!(validate_proxy("{\"httpProxy\": \"example.org:-1\"}").is_err());
assert!(validate_proxy("{\"httpProxy\": \"2001:db8::1\"}").is_err());
// no proxy for manual proxy type
validate_proxy("{\"noProxy\": [\"foo\"]}").unwrap();
assert!(validate_proxy("{\"noProxy\": \"foo\"}").is_err());
assert!(validate_proxy("{\"noProxy\": [42]}").is_err());
}
}