Support launching multiple Chrome DriverSessions

Author: illicitonion

src/chrome.rs

@@ -1,6 +1,7 @@
 use super::*;
 
 use std::process::{Command, Child, Stdio};
+use std::sync::Arc;
 use std::thread;
 use std::time::Duration;
 
@@ -26,7 +27,7 @@ impl ChromeDriverBuilder {
         self.kill_on_drop = kill;
         self
     }
-    pub fn spawn(self) -> Result<ChromeDriver, Error> {
+    pub fn spawn(self) -> Result<Arc<ChromeDriver>, Error> {
         let port = util::check_tcp_port(self.port)?;
 
         let child = Command::new("chromedriver")
@@ -38,11 +39,11 @@ impl ChromeDriverBuilder {
 
         // TODO: parameterize this
         thread::sleep(Duration::new(1, 500));
-        Ok(ChromeDriver {
+        Ok(Arc::new(ChromeDriver {
             child: child,
             url: format!("http://localhost:{}", port),
             kill_on_drop: self.kill_on_drop,
-        })
+        }))
     }
 }
 
@@ -54,7 +55,7 @@ pub struct ChromeDriver {
 }
 
 impl ChromeDriver {
-    pub fn spawn() -> Result<Self, Error> {
+    pub fn spawn() -> Result<Arc<Self>, Error> {
         ChromeDriverBuilder::new().spawn()
     }
     pub fn build() -> ChromeDriverBuilder {
@@ -70,8 +71,15 @@ impl Drop for ChromeDriver {
     }
 }
 
-impl Driver for ChromeDriver {
+// ChromeDriver supports launching multiple browsers from the same chromedriver process.
+impl Driver for Arc<ChromeDriver> {
     fn url(&self) -> &str {
         &self.url
     }
 }
+
+impl MultiSessionDriver for Arc<ChromeDriver> {
+    fn session(&self) -> Result<DriverSession, Error> {
+        DriverSession::create_session(self.url(), self.clone())
+    }
+}

src/firefox.rs

@@ -69,6 +69,11 @@ impl GeckoDriver {
     pub fn build() -> GeckoDriverBuilder {
         GeckoDriverBuilder::new()
     }
+
+    /// Start a session for this driver
+    pub fn session(self) -> Result<DriverSession, Error> where Self : Sized + 'static {
+        DriverSession::create_session(&self.url().to_owned(), self)
+    }
 }
 
 impl Drop for GeckoDriver {
@@ -84,4 +89,3 @@ impl Driver for GeckoDriver {
         &self.url
     }
 }
-

src/lib.rs

@@ -7,6 +7,7 @@ use std::convert::From;
 use std::io::Read;
 use std::io;
 use std::fmt::{self, Debug};
+use std::sync::Weak;
 
 extern crate hyper;
 use hyper::client::*;
@@ -83,10 +84,11 @@ impl From<serde_json::Error> for Error {
 pub trait Driver {
     /// The url used to connect to this driver
     fn url(&self) -> &str;
+}
+
+pub trait MultiSessionDriver: Driver {
     /// Start a session for this driver
-    fn session(self) -> Result<DriverSession, Error> where Self : Sized + 'static {
-        DriverSession::create_session(Box::new(self))
-    }
+    fn session(&self) -> Result<DriverSession, Error>;
 }
 
 /// A driver using a pre-existing WebDriver HTTP URL.
@@ -101,6 +103,17 @@ impl Driver for HttpDriver {
     fn url(&self) -> &str { &self.url }
 }
 
+impl MultiSessionDriver for HttpDriver {
+    fn session(&self) -> Result<DriverSession, Error> {
+        // We need to pass something which implements Drop here,
+        // and a Weak is a cheap something.
+        // Ideally, create_session would take an Option<impl Drop>,
+        // and we could just pass None, but impl Trait isn't a stable thing yet.
+        let r: Weak<()> = Weak::new();
+        DriverSession::create_session(&self.url(), r)
+    }
+}
+
 /// Wrapper around the hyper Client, that handles Json encoding and URL construction
 struct HttpClient {
     baseurl: Url,
@@ -166,25 +179,25 @@ impl HttpClient {
 ///
 /// By default the session is removed on `Drop`
 pub struct DriverSession {
-    driver: Box<Driver>,
+    driver: Box<Drop>,
     client: HttpClient,
     session_id: String,
     drop_session: bool,
 }
 
 impl DriverSession {
     /// Create a new session with the driver.
-    pub fn create_session(driver: Box<Driver>)
+    pub fn create_session<D: Drop + Sized + 'static>(url: &str, driver: D)
     -> Result<DriverSession, Error>
     {
-        let baseurl = Url::parse(driver.url())
+        let baseurl = Url::parse(url)
                           .map_err(|_| Error::InvalidUrl)?;
         let client = HttpClient::new(baseurl);
         info!("Creating session at {}", client.baseurl);
         let sess = try!(Self::new_session(&client, &NewSessionCmd::new()));
         info!("Session {} created", sess.sessionId);
         Ok(DriverSession {
-            driver: driver,
+            driver: Box::new(driver),
             client: client,
             session_id: sess.sessionId,
             drop_session: true,
@@ -193,10 +206,8 @@ impl DriverSession {
 
     /// Use an existing session
     pub fn attach(url: &str, session_id: &str) -> Result<DriverSession, Error> {
-        let driver = Box::new(HttpDriver {
-            url: url.to_owned(),
-        });
         let baseurl = try!(Url::parse(url).map_err(|_| Error::InvalidUrl));
+        let driver: Box<Weak<()>> = Box::new(Weak::new());
         let mut s = DriverSession {
             driver: driver,
             client: HttpClient::new(baseurl),

tests/webdriver_client_integration.rs

@@ -15,7 +15,8 @@ use std::path::PathBuf;
 use std::sync::{Once, ONCE_INIT};
 use std::thread::sleep;
 use std::time::Duration;
-use webdriver_client::{Driver, DriverSession, HttpDriverBuilder, LocationStrategy};
+use webdriver_client::{Driver, DriverSession, HttpDriverBuilder, LocationStrategy, MultiSessionDriver};
+use webdriver_client::chrome::ChromeDriver;
 use webdriver_client::firefox::GeckoDriver;
 use webdriver_client::messages::ExecuteCmd;
 
@@ -335,6 +336,24 @@ fn test_http_driver() {
     assert_eq!(url, test_url);
 }
 
+#[test]
+fn launch_multiple_chromes() {
+    ensure_logging_init();
+
+    let server = FileServer::new();
+    let chromedriver = ChromeDriver::build().spawn().unwrap();
+    let chrome1 = chromedriver.session().expect("Error starting first browser");
+    let chrome2 = chromedriver.session().expect("Error starting second browser");
+
+    let page1 = server.url("/page1.html");
+    let page2 = server.url("/page2.html");
+    chrome1.go(&page1).expect("Error getting page1");
+    chrome2.go(&page2).expect("Error getting page2");
+
+    assert_eq!(&chrome1.get_current_url().expect("Error getting url 1"), &page1);
+    assert_eq!(&chrome2.get_current_url().expect("Error getting url 2"), &page2);
+}
+
 fn ensure_logging_init() {
     static DONE: Once = ONCE_INIT;
     DONE.call_once(|| init_logging());