use std::fmt::Write;
use std::panic::AssertUnwindSafe;
use std::pin::pin;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use anyhow::{Context, Result, anyhow, bail};
use futures_util::FutureExt;
use thirtyfour::prelude::*;
use tokio::time::{self, Duration};
use crate::driver::{self, Driver, QUIT_TIMEOUT, STARTUP_TIMEOUT, with_cleanup};
use crate::finding::{LOAD_TIMEOUT, WAIT_TIMEOUT};
use crate::{Engine, Fixture, TestDriver};
#[derive(Clone, Default)]
pub(crate) struct Waiting(Arc<Mutex<Option<String>>>);
impl Waiting {
pub(crate) fn on(&self, what: impl std::fmt::Display) {
*self.held() = Some(what.to_string());
}
pub(crate) fn clear(&self) {
*self.held() = None;
}
pub(crate) fn clause(&self) -> String {
match &*self.held() {
Some(what) => format!(", last waiting for {what}"),
None => String::new(),
}
}
fn held(&self) -> std::sync::MutexGuard<'_, Option<String>> {
self.0.lock().unwrap_or_else(|held| held.into_inner())
}
}
#[derive(Clone, Default)]
pub(crate) struct Holding(Arc<AtomicBool>);
impl Holding {
pub(crate) fn set(&self, held: bool) {
self.0.store(held, Ordering::Relaxed);
}
pub(crate) fn take(&self) -> bool {
self.0.swap(false, Ordering::Relaxed)
}
}
pub(crate) struct Browser {
pub(crate) webdriver: Driver,
pub(crate) driver: TestDriver,
}
impl Browser {
pub(crate) async fn open() -> Result<Self> {
let engine = crate::harness::engine();
let deadline = time::Instant::now() + STARTUP_TIMEOUT;
let caps = engine.capabilities(crate::harness::headed())?;
let webdriver = Driver::new(engine, deadline).await?;
Self::connect(webdriver, caps, deadline).await
}
pub(crate) async fn connect(
mut webdriver: Driver,
mut caps: Capabilities,
deadline: time::Instant,
) -> Result<Self> {
let downloads = tempfile::tempdir().context("creating browser download directory")?;
let directory = downloads.path().to_string_lossy().into_owned();
let key = match webdriver.engine() {
Engine::Firefox => "moz:firefoxOptions",
Engine::Chrome => "goog:chromeOptions",
};
if !caps.contains_key(key) {
caps.set(key, serde_json::json!({}))?;
}
match webdriver.engine() {
Engine::Firefox => {
let options = caps
.get_mut("moz:firefoxOptions")
.context("Firefox capabilities have no options")?;
let prefs = options
.as_object_mut()
.context("Firefox options")?
.entry("prefs")
.or_insert_with(|| serde_json::json!({}));
let prefs = prefs.as_object_mut().context("Firefox preferences")?;
prefs.insert("browser.download.folderList".into(), 2.into());
prefs.insert("browser.download.dir".into(), directory.into());
prefs.insert("browser.download.useDownloadDir".into(), true.into());
prefs.insert(
"browser.helperApps.neverAsk.saveToDisk".into(),
"audio/wav,application/zip,application/json".into(),
);
}
Engine::Chrome => {
let options = caps
.get_mut("goog:chromeOptions")
.context("Chrome capabilities have no options")?;
options["prefs"] = serde_json::json!({
"download.default_directory": directory,
"download.prompt_for_download": false,
});
}
}
tracing::info!(
"{} address: {:?}",
webdriver.engine().driver(),
webdriver.address
);
let url = format!("http://{}", webdriver.address);
let connected = webdriver
.during(deadline, "startup", async {
Ok(WebDriver::new(&url, caps).await?)
})
.await;
let driver = match connected {
Ok(driver) => driver,
Err(error) => return Err(with_cleanup(error, webdriver.terminate().await)),
};
Ok(Self {
webdriver,
driver: TestDriver {
inner: driver,
wait_timeout: WAIT_TIMEOUT,
load_timeout: LOAD_TIMEOUT,
waiting: Waiting::default(),
watching: AtomicBool::new(false),
holding: Holding::default(),
downloads,
},
})
}
async fn reset(&mut self, url: &str) -> Result<()> {
self.driver.waiting.clear();
self.driver.watching.store(false, Ordering::Relaxed);
self.driver.holding.set(false);
for file in std::fs::read_dir(self.driver.downloads.path())? {
std::fs::remove_file(file?.path())?;
}
let old = self.driver.inner.window().await?;
let fresh = self.driver.inner.new_tab().await?;
self.driver.inner.switch_to_window(fresh.clone()).await?;
self.driver.inner.switch_to_window(old).await?;
self.driver.inner.close_window().await?;
self.driver.inner.switch_to_window(fresh).await?;
self.driver.set_window_size(WINDOW.0, WINDOW.1).await?;
self.driver.inner.goto(url).await?;
Ok(())
}
pub(crate) async fn close(mut self) -> Result<Option<anyhow::Error>> {
let driver = self.driver.inner.clone();
let quit = self
.webdriver
.during(time::Instant::now() + QUIT_TIMEOUT, "quit", async {
Ok(driver.quit().await?)
})
.await;
let reaped = self.webdriver.terminate().await;
match (quit, reaped) {
(Ok(()), reaped) => reaped.map(|()| None),
(Err(error), Ok(())) if error.downcast_ref::<driver::TimedOut>().is_some() => {
Ok(Some(error))
}
(Err(error), reaped) => Err(with_cleanup(error, reaped)),
}
}
}
impl Drop for Browser {
fn drop(&mut self) {
let _ = self.driver.inner.clone().leak();
}
}
pub(crate) const WINDOW: (u32, u32) = (1600, 1000);
const SESSION_DEATH: &[&str] = &[
"invalid session id",
"session id is invalid",
"session deleted because of page crash",
"session terminated",
"the webdriver server's output ended",
"error sending request",
];
pub(crate) fn browser_death(error: &anyhow::Error) -> Option<&'static str> {
let mut source: Option<&dyn std::error::Error> = Some(error.as_ref());
while let Some(error) = source {
let said = error.to_string().to_lowercase();
if let Some(mark) = SESSION_DEATH.iter().find(|mark| said.contains(**mark)) {
return Some(mark);
}
source = error.source();
}
None
}
fn went_away(browser: &Browser, mark: &str) -> anyhow::Error {
let name = browser.webdriver.engine().driver();
anyhow!(
"the browser went away ({mark}); {name} last said: {}",
driver_said(browser)
)
}
fn driver_said(browser: &Browser) -> String {
let said = browser.webdriver.diagnostics();
said.lines()
.rev()
.take(3)
.collect::<Vec<_>>()
.into_iter()
.rev()
.collect::<Vec<_>>()
.join(" | ")
}
pub(crate) async fn run_one<F: Fixture>(
browser: &mut Browser,
start: crate::harness::Start<F>,
setup: F::Setup,
limit: Option<Duration>,
) -> Result<()> {
let mut fixture = F::start(setup).await?;
let mut errors = String::new();
let result = match browser.reset(&fixture.url()).await {
Ok(()) => drive_one(browser, &mut fixture, start, limit).await,
Err(error) => Err(error),
};
let fixture_result = fixture.quit().await;
if let Err(error) = result.as_ref() {
if let Some(mark) = browser_death(error) {
let mut error = went_away(browser, mark);
if let Err(quit) = fixture_result {
error = error.context(format!("the fixture also failed to quit: {quit}"));
}
return Err(error);
}
write_chain(&mut errors, "Test error", error)?;
}
if let Err(error) = fixture_result {
write_chain(&mut errors, "Fixture error", &error)?;
}
if !errors.is_empty() {
return Err(anyhow!("{errors}"));
}
Ok(())
}
fn write_chain(errors: &mut String, label: &str, error: &anyhow::Error) -> std::fmt::Result {
writeln!(errors, "{label}: {error}")?;
for cause in error.chain().skip(1) {
writeln!(errors, " Caused by: {cause}")?;
}
Ok(())
}
async fn drive_one<F: Fixture>(
browser: &mut Browser,
fixture: &mut F,
start: crate::harness::Start<F>,
limit: Option<Duration>,
) -> Result<()> {
let mut timeout = pin!(async move {
match limit {
Some(limit) => time::sleep(limit).await,
None => std::future::pending::<()>().await,
}
});
let Browser { webdriver, driver } = browser;
let waiting = driver.waiting.clone();
let outcome = {
let task = AssertUnwindSafe(start(driver, fixture)).catch_unwind();
let mut task = pin!(task);
loop {
tokio::select! {
_ = timeout.as_mut() => {
break Err(overran(limit, &waiting));
}
result = task.as_mut() => {
break Ok(result);
}
result = webdriver.io() => {
if !result? {
break Err("the WebDriver server's output ended".to_string());
}
}
}
}
};
match outcome {
Ok(Ok(Ok(()))) => match driver.error_seen().await? {
Some(threw) => bail!("the page threw: {threw}"),
None => Ok(()),
},
Ok(Ok(result)) => result,
Ok(Err(panicked)) => bail!("the test panicked: {}", panic_message(&panicked)),
Err(error) => bail!(error),
}
}
pub(crate) fn overran(limit: Option<Duration>, waiting: &Waiting) -> String {
let seconds = limit.map_or(0, |limit| limit.as_secs());
format!(
"the test was still running after {seconds}s, which is --timeout{}",
waiting.clause()
)
}
fn panic_message(payload: &Box<dyn std::any::Any + Send>) -> &str {
if let Some(message) = payload.downcast_ref::<&'static str>() {
return message;
}
if let Some(message) = payload.downcast_ref::<String>() {
return message;
}
"a payload that is neither a string nor a &str"
}
#[cfg(test)]
mod browser_tests {
use anyhow::{Context, Result, ensure};
use super::{Browser, write_chain};
#[test]
fn a_report_names_every_cause() -> Result<()> {
let error = anyhow::anyhow!("the root")
.context("the middle")
.context("the top");
let mut errors = String::new();
write_chain(&mut errors, "Test error", &error)?;
assert_eq!(
errors,
"Test error: the top\n Caused by: the middle\n Caused by: the root\n"
);
Ok(())
}
#[tokio::test]
#[ignore = "requires a real WebDriver"]
async fn a_reset_discards_the_preceding_document() -> Result<()> {
let mut browser = Browser::open().await?;
let result = async {
browser.reset("data:text/html,first").await?;
let first = browser.driver.inner.window().await?;
browser.reset("data:text/html,second").await?;
let second = browser.driver.inner.window().await?;
let windows = browser.driver.inner.windows().await?;
let history = browser
.driver
.inner
.execute("return history.length", Vec::new())
.await?
.json()
.as_u64()
.context("browser history length")?;
ensure!(first != second, "the second reset kept the first tab");
ensure!(windows == [second], "reset left tabs behind: {windows:?}");
ensure!(history <= 2, "the fresh tab has {history} history entries");
Ok(())
}
.await;
match (result, browser.close().await) {
(Ok(()), Ok(_)) => Ok(()),
(Err(error), Ok(_)) | (Ok(()), Err(error)) => Err(error),
(Err(error), Err(cleanup)) => Err(super::driver::with_cleanup(error, Err(cleanup))),
}
}
}