use std::fmt;
use std::io::Error as IOError;
use std::error::Error;
use hyper::error as herror;
use webdriver::error as wderror;
use rustc_serialize::json;
#[derive(Debug)]
pub enum NewSessionError {
BadWebdriverUrl(herror::ParseError),
NotW3C(json::Json),
SessionNotCreated(wderror::WebDriverError),
}
impl Error for NewSessionError {
fn description(&self) -> &str {
match *self {
NewSessionError::BadWebdriverUrl(..) => "webdriver url is invalid",
NewSessionError::NotW3C(..) => "webdriver server gave non-conformant response",
NewSessionError::SessionNotCreated(..) => "webdriver did not create session",
}
}
fn cause(&self) -> Option<&Error> {
match *self {
NewSessionError::BadWebdriverUrl(ref e) => Some(e),
NewSessionError::NotW3C(..) => None,
NewSessionError::SessionNotCreated(ref e) => Some(e),
}
}
}
impl fmt::Display for NewSessionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}: ", self.description())?;
match *self {
NewSessionError::BadWebdriverUrl(ref e) => write!(f, "{}", e),
NewSessionError::NotW3C(ref e) => write!(f, "{:?}", e),
NewSessionError::SessionNotCreated(ref e) => write!(f, "{}", e),
}
}
}
#[derive(Debug)]
pub enum CmdError {
Standard(wderror::WebDriverError),
NoSuchElement(wderror::WebDriverError),
BadUrl(herror::ParseError),
Failed(herror::Error),
Lost(IOError),
NotJson(String),
Json(json::ParserError),
NotW3C(json::Json),
}
impl CmdError {
pub fn is_miss(&self) -> bool {
if let CmdError::NoSuchElement(..) = *self {
true
} else {
false
}
}
}
impl Error for CmdError {
fn description(&self) -> &str {
match *self {
CmdError::Standard(..) => "webdriver returned error",
CmdError::NoSuchElement(..) => "no element found matching selector",
CmdError::BadUrl(..) => "bad url provided",
CmdError::Failed(..) => "webdriver could not be reached",
CmdError::Lost(..) => "webdriver connection lost",
CmdError::NotJson(..) => "webdriver returned invalid response",
CmdError::Json(..) => "webdriver return incoherent response",
CmdError::NotW3C(..) => "webdriver return non-conforming response",
}
}
fn cause(&self) -> Option<&Error> {
match *self {
CmdError::Standard(ref e) => Some(e),
CmdError::NoSuchElement(ref e) => Some(e),
CmdError::BadUrl(ref e) => Some(e),
CmdError::Failed(ref e) => Some(e),
CmdError::Lost(ref e) => Some(e),
CmdError::NotJson(_) => None,
CmdError::Json(ref e) => Some(e),
CmdError::NotW3C(_) => None,
}
}
}
impl fmt::Display for CmdError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}: ", self.description())?;
match *self {
CmdError::Standard(ref e) => write!(f, "{}", e),
CmdError::NoSuchElement(ref e) => write!(f, "{}", e),
CmdError::BadUrl(ref e) => write!(f, "{}", e),
CmdError::Failed(ref e) => write!(f, "{}", e),
CmdError::Lost(ref e) => write!(f, "{}", e),
CmdError::NotJson(ref e) => write!(f, "{}", e),
CmdError::Json(ref e) => write!(f, "{}", e),
CmdError::NotW3C(ref e) => write!(f, "{:?}", e),
}
}
}
impl From<IOError> for CmdError {
fn from(e: IOError) -> Self {
CmdError::Lost(e)
}
}
impl From<herror::ParseError> for CmdError {
fn from(e: herror::ParseError) -> Self {
CmdError::BadUrl(e)
}
}
impl From<herror::Error> for CmdError {
fn from(e: herror::Error) -> Self {
CmdError::Failed(e)
}
}
impl From<wderror::WebDriverError> for CmdError {
fn from(e: wderror::WebDriverError) -> Self {
if let wderror::WebDriverError { error: wderror::ErrorStatus::NoSuchElement, .. } = e {
CmdError::NoSuchElement(e)
} else {
CmdError::Standard(e)
}
}
}
impl From<json::ParserError> for CmdError {
fn from(e: json::ParserError) -> Self {
CmdError::Json(e)
}
}