Run tests with chrome driver

The one test that is not executed with the same assertions is the
javascript throw, because the error information returned by chrome
driver is too different from gecko.

Did a quick fix to the ignored youtube tests to avoid the anchor
elements without an href attribute.

Author: equalsraf

.travis.yml

@@ -7,9 +7,11 @@ addons:
   # Force the latest firefox, otherwise we get and old ESR version
   # that we dont even support
   firefox: latest
+  chrome: stable
   apt:
     packages:
     - firefox
+    - google-chrome-stable
     - xvfb
 before_script:
   # start xvfb and firefox to run the tests
@@ -21,5 +23,10 @@ before_script:
   - bin/download_geckodriver
   - export PATH=$PATH:$HOME/.cargo/bin:$PWD/bin
   - which geckodriver
+  # install chromedriver
+  - bin/download_chromedriver
+  - export CHROME_BIN=/usr/bin/google-chrome-stable
+  - export CHROME_HEADLESS=1
+  - which chromedriver
 script:
   - RUST_LOG="webdriver=trace" cargo test --verbose

bin/download_chromedriver

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -ex
+
+script_dir=$( cd $(dirname ${BASH_SOURCE[0]}); pwd )
+
+version=$(wget -q -O - http://chromedriver.storage.googleapis.com/LATEST_RELEASE)
+
+curl -sSL \
+     http://chromedriver.storage.googleapis.com/$version/chromedriver_linux64.zip \
+     -o ${script_dir}/chromedriver-linux64.zip
+unzip -d ${script_dir} ${script_dir}/chromedriver-linux64.zip
+chmod +x ${script_dir}/chromedriver

tests/webdriver_client_integration.rs

@@ -11,20 +11,32 @@ use std::env;
 use std::sync::{Once, ONCE_INIT};
 use std::thread::sleep;
 use std::time::Duration;
-use webdriver_client::{Driver, HttpDriverBuilder};
+use webdriver_client::{Driver, HttpDriverBuilder, DriverSession};
 use webdriver_client::firefox::GeckoDriver;
+use webdriver_client::chrome::ChromeDriver;
 use webdriver_client::messages::ExecuteCmd;
 
 #[test]
-fn test_file() {
+fn test_file_geckodriver() {
     ensure_logging_init();
-
     // TODO: Perhaps calculate path from PATH environment variable.
     let gecko = GeckoDriver::build()
         .firefox_binary("/usr/bin/firefox")
         .spawn().unwrap();
     let sess = gecko.session().unwrap();
+    test_file(sess);
+}
+
+#[test]
+fn test_file_chromedriver() {
+    ensure_logging_init();
+    let chrome = ChromeDriver::build()
+        .spawn().unwrap();
+    let sess = chrome.session().unwrap();
+    test_file(sess);
+}
 
+fn test_file(sess: DriverSession) {
     let test_url = get_integration_test_url();
     sess.go(&test_url).unwrap();
     let url = sess.get_current_url().unwrap();
@@ -55,22 +67,6 @@ fn test_file() {
         assert_eq!(exec_int, 4);
     }
 
-    {
-        // Test execute handling an exception
-        let exec_res = sess.execute(ExecuteCmd {
-            script: "throw 'SomeException';".to_owned(),
-            args: vec![],
-        });
-        assert!(exec_res.is_err());
-        let err = exec_res.err().unwrap();
-        let err = match err {
-            webdriver_client::Error::WebDriverError(e) => e,
-            _ => panic!("Unexpected error variant: {:#?}", err),
-        };
-        assert_eq!(err.error, "javascript error");
-        assert_eq!(err.message, "SomeException");
-    }
-
     {
         // Test execute async
         let exec_json = sess.execute_async(ExecuteCmd {
@@ -86,14 +82,68 @@ fn test_file() {
 }
 
 #[test]
-fn test_http_driver() {
+fn test_exception_handling_geckodriver() {
+    ensure_logging_init();
+    // TODO: Perhaps calculate path from PATH environment variable.
+    let gecko = GeckoDriver::build()
+        .firefox_binary("/usr/bin/firefox")
+        .spawn().unwrap();
+    let sess = gecko.session().unwrap();
+
+    let exec_res = sess.execute(ExecuteCmd {
+        script: "throw 'SomeException';".to_owned(),
+        args: vec![],
+    });
+    assert!(exec_res.is_err());
+    let err = exec_res.err().unwrap();
+    let err = match err {
+        webdriver_client::Error::WebDriverError(e) => e,
+        _ => panic!("Unexpected error variant: {:#?}", err),
+    };
+    assert_eq!(err.error, "javascript error");
+    assert_eq!(err.message, "SomeException");
+}
+
+/// This test is kept separate from the gecko variant because the error messages are different
+/// in chrome and so are the other stacktrace information
+#[test]
+fn test_exception_handling_chromedriver() {
     ensure_logging_init();
+    let chrome = ChromeDriver::build()
+        .spawn().unwrap();
+    let sess = chrome.session().unwrap();
+
+    let exec_res = sess.execute(ExecuteCmd {
+        script: "throw 'SomeException';".to_owned(),
+        args: vec![],
+    });
+    assert!(exec_res.is_err());
+    let err = exec_res.err().unwrap();
+    match err {
+        webdriver_client::Error::WebDriverError(_) => (),
+        _ => panic!("Unexpected error variant: {:#?}", err),
+    }
+}
 
+#[test]
+fn test_http_driver_geckodriver() {
+    ensure_logging_init();
     // TODO: Perhaps calculate path from PATH environment variable.
     let gecko = GeckoDriver::build()
         .firefox_binary("/usr/bin/firefox")
         .spawn().unwrap();
+    test_http_driver(gecko.url());
+}
+
+#[test]
+fn test_http_driver_chromedriver() {
+    ensure_logging_init();
+    let chrome = ChromeDriver::build()
+        .spawn().unwrap();
+    test_http_driver(chrome.url());
+}
 
+fn test_http_driver(url: &str) {
     // Hackily sleep a bit until geckodriver is ready, otherwise our session
     // will fail to connect.
     // If this is unreliable, we could try:
@@ -102,7 +152,7 @@ fn test_http_driver() {
     sleep(Duration::from_millis(1000));
 
     let http_driver = HttpDriverBuilder::default()
-                                        .url(gecko.url())
+                                        .url(url)
                                         .build().unwrap();
     let sess = http_driver.session().unwrap();
 
@@ -137,21 +187,36 @@ fn get_integration_test_url() -> String {
     format!("file://{crate}/tests/integration_test.html", crate = crate_root)
 }
 
+/// This depends on an external page not under our control, we
+/// should migrate to using local files.
 mod youtube_integration_test {
-    use webdriver_client::Driver;
+    use webdriver_client::{Driver, DriverSession};
     use webdriver_client::firefox::GeckoDriver;
+    use webdriver_client::chrome::ChromeDriver;
     use webdriver_client::messages::LocationStrategy;
 
-    /// This depends on an external page not under our control, we
-    /// should migrate to using local files.
     #[test]
     #[ignore]
-    fn test() {
+    fn test_geckodriver() {
         let gecko = GeckoDriver::build()
             .kill_on_drop(true)
             .spawn()
             .unwrap();
-        let mut sess = gecko.session().unwrap();
+        let sess = gecko.session().unwrap();
+        test(sess);
+    }
+
+    #[test]
+    #[ignore]
+    fn test_chromedriver() {
+        let chrome = ChromeDriver::build()
+            .spawn()
+            .unwrap();
+        let sess = chrome.session().unwrap();
+        test(sess);
+    }
+
+    fn test(mut sess: DriverSession) {
         sess.go("https://www.youtube.com/watch?v=dQw4w9WgXcQ").unwrap();
         sess.get_current_url().unwrap();
         sess.back().unwrap();
@@ -160,7 +225,7 @@ mod youtube_integration_test {
         sess.get_page_source().unwrap();
 
         {
-            let el = sess.find_element("a", LocationStrategy::Css).unwrap();
+            let el = sess.find_element("a[href]", LocationStrategy::Css).unwrap();
             el.attribute("href").unwrap();
             el.css_value("color").unwrap();
             el.text().unwrap();