use std::{
net::TcpListener,
ops::Deref,
path::{Path, PathBuf},
sync::Arc,
time::Duration,
};
use anyhow::{Context, Result};
use thirtyfour::{
CapabilitiesHelper, ChromiumLikeCapabilities, DesiredCapabilities, LoggingPrefsLogLevel,
WebDriver,
extensions::query::ElementPollerWithTimeout,
manager::{BrowserKind, WebDriverManager},
};
pub const WAIT: Duration = Duration::from_secs(10);
pub const POLL: Duration = Duration::from_millis(100);
pub trait Env: Deref<Target = Core> + Send + Sync + Sized + 'static {
fn start(suite: &'static str) -> impl Future<Output = Result<Self>>;
fn shutdown(&self) -> impl Future<Output = ()>;
}
#[derive(Debug, Clone)]
pub struct Settings {
pub workspace_root: PathBuf,
pub target_dir: PathBuf,
pub release: bool,
pub wasm_opt: bool,
pub skip_build: bool,
pub headless: bool,
pub chromedriver: Option<PathBuf>,
pub webdriver: Option<String>,
}
impl Settings {
pub fn from_env(manifest_dir: &str) -> Result<Self> {
let workspace_root = Path::new(manifest_dir)
.parent()
.with_context(|| format!("{manifest_dir} is not inside a workspace"))?
.to_path_buf();
let target_dir = match std::env::var_os("CARGO_TARGET_DIR") {
Some(dir) => workspace_root.join(dir),
None => workspace_root.join("target"),
};
Ok(Self {
workspace_root,
target_dir,
release: flag("E2E_RELEASE", false),
wasm_opt: flag("E2E_WASM_OPT", false),
skip_build: flag("E2E_SKIP_BUILD", false),
headless: flag("E2E_HEADLESS", true),
chromedriver: std::env::var_os("E2E_CHROMEDRIVER").map(PathBuf::from),
webdriver: std::env::var("E2E_WEBDRIVER").ok(),
})
}
pub fn profile(&self) -> &'static str {
if self.release { "release" } else { "debug" }
}
pub fn build_dir(&self) -> PathBuf {
self.target_dir.join("e2e").join(self.profile())
}
pub fn work_dir(&self, suite: &str) -> PathBuf {
self.target_dir.join("e2e").join(suite)
}
}
fn flag(name: &str, default: bool) -> bool {
match std::env::var(name) {
Ok(value) => parse_flag(&value),
Err(_) => default,
}
}
fn parse_flag(value: &str) -> bool {
!matches!(value, "" | "0" | "false" | "no")
}
#[derive(Debug, Clone)]
pub struct ChromeConfig {
pub window_size: (u32, u32),
pub lang: &'static str,
pub args: &'static [&'static str],
}
impl ChromeConfig {
fn arguments(&self) -> Vec<String> {
let (width, height) = self.window_size;
let accept_lang = match self.lang.split_once('-') {
Some((language, _)) => format!("{},{language}", self.lang),
None => self.lang.to_string(),
};
let mut arguments = vec![
format!("--window-size={width},{height}"),
format!("--lang={}", self.lang),
format!("--accept-lang={accept_lang}"),
];
let defaults = [
"--no-first-run",
"--no-default-browser-check",
"--disable-search-engine-choice-screen",
];
arguments.extend(defaults.iter().chain(self.args).map(|arg| arg.to_string()));
arguments
}
}
impl Default for ChromeConfig {
fn default() -> Self {
Self {
window_size: (1400, 1000),
lang: "en-US",
args: &[],
}
}
}
pub struct Core {
pub suite: &'static str,
pub settings: Settings,
pub base_url: String,
pub work_dir: PathBuf,
pub http: reqwest::Client,
chrome: ChromeConfig,
webdriver: Arc<WebDriverManager>,
}
impl Core {
pub fn new(
suite: &'static str,
settings: Settings,
base_url: String,
chrome: ChromeConfig,
) -> Result<Self> {
let work_dir = settings.work_dir(suite);
std::fs::create_dir_all(&work_dir)
.with_context(|| format!("can't create {}", work_dir.display()))?;
let _ = std::fs::remove_dir_all(work_dir.join("artifacts"));
let http = reqwest::Client::builder()
.timeout(Duration::from_secs(30))
.build()?;
Ok(Self {
suite,
webdriver: webdriver_manager(&settings),
settings,
base_url,
work_dir,
http,
chrome,
})
}
pub fn url(&self, path: &str) -> String {
format!("{}{path}", self.base_url)
}
pub async fn new_browser(&self) -> Result<WebDriver> {
let mut caps = DesiredCapabilities::chrome();
if self.settings.headless {
caps.set_headless()?;
}
for arg in self.chrome.arguments() {
caps.add_arg(&arg)?;
}
caps.add_experimental_option(
"prefs",
serde_json::json!({
"credentials_enable_service": false,
"profile.password_manager_enabled": false,
"profile.password_manager_leak_detection": false,
}),
)?;
caps.add_arg("--disable-features=PasswordLeakDetection")?;
caps.set_browser_log_level(LoggingPrefsLogLevel::All)?;
caps.set("unhandledPromptBehavior", "ignore")?;
let driver = match &self.settings.webdriver {
Some(url) => WebDriver::builder(url, caps)
.poller(poller())
.await
.with_context(|| format!("can't start Chrome through the WebDriver at {url}"))?,
None => self
.webdriver
.launch(caps)
.await
.context("can't start Chrome through chromedriver")?,
};
let emulated = driver
.cdp()
.send_raw(
"Emulation.setFocusEmulationEnabled",
serde_json::json!({ "enabled": true }),
)
.await;
if let Err(err) = emulated {
let _ = driver.quit().await;
return Err(err).context("can't emulate the focus of the page");
}
Ok(driver)
}
}
pub fn free_port() -> Result<u16> {
let listener = TcpListener::bind("127.0.0.1:0")?;
Ok(listener.local_addr()?.port())
}
fn poller() -> Arc<ElementPollerWithTimeout> {
Arc::new(ElementPollerWithTimeout::new(WAIT, POLL))
}
fn webdriver_manager(settings: &Settings) -> Arc<WebDriverManager> {
let mut builder = WebDriverManager::builder().match_local().poller(poller());
if let Some(chromedriver) = &settings.chromedriver {
builder = builder.driver_binary(BrowserKind::Chrome, chromedriver);
}
builder.build()
}
#[cfg(test)]
mod tests {
use super::{ChromeConfig, parse_flag};
#[test]
fn the_language_decides_accept_language_too() {
let config = ChromeConfig {
lang: "pl-PL",
args: &["--mute-audio"],
..Default::default()
};
let arguments = config.arguments();
for expected in ["--lang=pl-PL", "--accept-lang=pl-PL,pl", "--mute-audio"] {
assert!(arguments.iter().any(|arg| arg == expected), "{arguments:?}");
}
}
#[test]
fn a_language_without_a_region_is_accepted_alone() {
let config = ChromeConfig {
lang: "pl",
..Default::default()
};
let arguments = config.arguments();
assert!(
arguments.iter().any(|arg| arg == "--accept-lang=pl"),
"{arguments:?}"
);
}
#[test]
fn flags() {
for off in ["", "0", "false", "no"] {
assert!(!parse_flag(off), "{off:?}");
}
for on in ["1", "true", "yes"] {
assert!(parse_flag(on), "{on:?}");
}
}
}