use std::fs;
use std::path::{Path, PathBuf};
use super::command::merge_retry_config;
use super::launch::launch_browser;
use super::runtime::set_server_addr;
use super::types::{
AllwrightConfig, BrowserKind, ConfigApp, ConfigDesktop, ConfigDesktopTarget, ConfigMobile,
ConfigMobileTarget, Error, LaunchOptions, ResolveConfigOptions, ResolvedAppConfig,
ResolvedConfig, ResolvedDesktopConfig, ResolvedDesktopTargetConfig, ResolvedMobileConfig,
ResolvedMobileTargetConfig, Result,
};
const CONFIG_FILENAMES: [&str; 6] = [
"allwright.config.yaml",
"allwright.config.yml",
"allwright.config.json",
".allwright/config.yaml",
".allwright/config.yml",
".allwright/config.json",
];
pub fn find_config_file(start_dir: impl AsRef<Path>) -> Option<PathBuf> {
let mut current_dir = start_dir.as_ref().to_path_buf();
loop {
for filename in CONFIG_FILENAMES {
let candidate = current_dir.join(filename);
if candidate.is_file() {
return Some(candidate);
}
}
if !current_dir.pop() {
return None;
}
}
}
pub fn load_config_file(config_file: impl AsRef<Path>) -> Result<AllwrightConfig> {
let resolved = config_file.as_ref().to_path_buf();
let raw = fs::read_to_string(&resolved).map_err(|error| {
Error::new(format!(
"failed to read allwright config {}: {error}",
resolved.display()
))
})?;
let extension = resolved
.extension()
.and_then(|value| value.to_str())
.unwrap_or_default()
.to_ascii_lowercase();
let config = match extension.as_str() {
"json" => serde_json::from_str::<AllwrightConfig>(&raw).map_err(|error| {
Error::new(format!(
"failed to parse allwright config {} as JSON: {error}",
resolved.display()
))
})?,
"yaml" | "yml" => serde_yaml::from_str::<AllwrightConfig>(&raw).map_err(|error| {
Error::new(format!(
"failed to parse allwright config {} as YAML: {error}",
resolved.display()
))
})?,
_ => {
return Err(Error::new(format!(
"unsupported allwright config file extension .{} for {}",
if extension.is_empty() {
"<none>"
} else {
&extension
},
resolved.display()
)));
}
};
validate_config_shape(&config, &resolved)?;
Ok(config)
}
pub fn resolve_config(options: ResolveConfigOptions) -> Result<ResolvedConfig> {
let cwd = options
.cwd
.unwrap_or(std::env::current_dir().map_err(|error| {
Error::new(format!(
"failed to determine current working directory: {error}"
))
})?);
let config_file_path = match options.config_file {
Some(path) => Some(path),
None => find_config_file(cwd),
};
let file_config = match &config_file_path {
Some(path) => load_config_file(path)?,
None => AllwrightConfig::default(),
};
let suite_name = options.suite.and_then(|suite| {
let trimmed = suite.trim().to_owned();
if trimmed.is_empty() {
None
} else {
Some(trimmed)
}
});
let suite_config = match &suite_name {
Some(name) => {
let suite = file_config
.suites
.as_ref()
.and_then(|suites| suites.get(name))
.cloned();
if suite.is_none() {
return Err(Error::new(format!(
"allwright config suite \"{}\" was not found in {}",
name,
config_file_path
.as_ref()
.map(|path| path.display().to_string())
.unwrap_or_else(|| "the resolved config file".to_string())
)));
}
suite
}
None => None,
};
let server_addr = suite_config
.as_ref()
.and_then(|suite| suite.server.as_ref())
.and_then(|server| server.addr.clone())
.or_else(|| {
file_config
.server
.as_ref()
.and_then(|server| server.addr.clone())
});
let browser_name = suite_config
.as_ref()
.and_then(|suite| suite.web.as_ref())
.and_then(|web| web.browser.as_ref())
.and_then(|browser| browser.name)
.or_else(|| {
file_config
.web
.as_ref()
.and_then(|web| web.browser.as_ref())
.and_then(|browser| browser.name)
});
let browser_binary = suite_config
.as_ref()
.and_then(|suite| suite.web.as_ref())
.and_then(|web| web.browser.as_ref())
.and_then(|browser| browser.binary.clone())
.or_else(|| {
file_config
.web
.as_ref()
.and_then(|web| web.browser.as_ref())
.and_then(|browser| browser.binary.clone())
});
let mut launch_options = merge_launch_options(
file_config
.web
.as_ref()
.and_then(|web| web.browser.as_ref())
.and_then(|browser| browser.launch_options.clone()),
suite_config
.as_ref()
.and_then(|suite| suite.web.as_ref())
.and_then(|web| web.browser.as_ref())
.and_then(|browser| browser.launch_options.clone()),
);
if let Some(binary) = &browser_binary {
launch_options.browser_binary = Some(binary.clone());
}
let expect = merge_retry_config(
file_config.expect.clone(),
suite_config.as_ref().and_then(|suite| suite.expect.clone()),
);
let mobile = resolve_mobile_config(
file_config.mobile.as_ref(),
suite_config
.as_ref()
.and_then(|suite| suite.mobile.as_ref()),
);
let desktop = resolve_desktop_config(
file_config.desktop.as_ref(),
suite_config
.as_ref()
.and_then(|suite| suite.desktop.as_ref()),
);
let browser_name = browser_name.or_else(|| {
if mobile.android.is_some()
|| mobile.ios.is_some()
|| desktop.mac.is_some()
|| desktop.windows.is_some()
|| desktop.linux.is_some()
{
None
} else {
Some(BrowserKind::Chromium)
}
});
Ok(ResolvedConfig {
config_file_path,
suite_name,
server_addr,
browser_name,
browser_binary,
launch_options,
expect,
mobile,
desktop,
})
}
pub async fn launch_configured_browser(config: &ResolvedConfig) -> Result<super::types::Browser> {
if let Some(server_addr) = &config.server_addr {
set_server_addr(server_addr.clone())?;
}
let browser_name = config.browser_name.ok_or_else(|| {
Error::new(
"resolved config does not define web.browser.name and includes only non-web surfaces",
)
})?;
launch_browser(browser_name, config.launch_options.clone()).await
}
fn merge_launch_options(
base: Option<LaunchOptions>,
override_options: Option<LaunchOptions>,
) -> LaunchOptions {
let mut merged = base.unwrap_or_default();
if let Some(override_options) = override_options {
if override_options.browser_binary.is_some() {
merged.browser_binary = override_options.browser_binary;
}
if override_options.timeout_ms.is_some() {
merged.timeout_ms = override_options.timeout_ms;
}
}
merged
}
fn validate_config_shape(config: &AllwrightConfig, source: &Path) -> Result<()> {
if let Some(schema_version) = config.schema_version {
if schema_version != 1 {
return Err(Error::new(format!(
"allwright config {} has unsupported schemaVersion {}; expected 1",
source.display(),
schema_version
)));
}
}
Ok(())
}
fn resolve_mobile_config(
base: Option<&ConfigMobile>,
override_config: Option<&ConfigMobile>,
) -> ResolvedMobileConfig {
ResolvedMobileConfig {
android: resolve_mobile_target(
base.and_then(|mobile| mobile.android.as_ref()),
override_config.and_then(|mobile| mobile.android.as_ref()),
),
ios: resolve_mobile_target(
base.and_then(|mobile| mobile.ios.as_ref()),
override_config.and_then(|mobile| mobile.ios.as_ref()),
),
}
}
fn resolve_desktop_config(
base: Option<&ConfigDesktop>,
override_config: Option<&ConfigDesktop>,
) -> ResolvedDesktopConfig {
ResolvedDesktopConfig {
mac: resolve_desktop_target(
base.and_then(|desktop| desktop.mac.as_ref()),
override_config.and_then(|desktop| desktop.mac.as_ref()),
),
windows: resolve_desktop_target(
base.and_then(|desktop| desktop.windows.as_ref()),
override_config.and_then(|desktop| desktop.windows.as_ref()),
),
linux: resolve_desktop_target(
base.and_then(|desktop| desktop.linux.as_ref()),
override_config.and_then(|desktop| desktop.linux.as_ref()),
),
}
}
fn resolve_mobile_target(
base: Option<&ConfigMobileTarget>,
override_config: Option<&ConfigMobileTarget>,
) -> Option<ResolvedMobileTargetConfig> {
let app = resolve_app_config(
base.and_then(|target| target.app.as_ref()),
override_config.and_then(|target| target.app.as_ref()),
);
let resolved = ResolvedMobileTargetConfig {
device: override_config
.and_then(|target| target.device.clone())
.or_else(|| base.and_then(|target| target.device.clone())),
app,
};
if resolved.device.is_some() || resolved.app.is_some() {
Some(resolved)
} else {
None
}
}
fn resolve_desktop_target(
base: Option<&ConfigDesktopTarget>,
override_config: Option<&ConfigDesktopTarget>,
) -> Option<ResolvedDesktopTargetConfig> {
let resolved = ResolvedDesktopTargetConfig {
app: resolve_app_config(
base.and_then(|target| target.app.as_ref()),
override_config.and_then(|target| target.app.as_ref()),
),
};
if resolved.app.is_some() {
Some(resolved)
} else {
None
}
}
fn resolve_app_config(
base: Option<&ConfigApp>,
override_config: Option<&ConfigApp>,
) -> Option<ResolvedAppConfig> {
let resolved = ResolvedAppConfig {
id: override_config
.and_then(|app| app.id.clone())
.or_else(|| base.and_then(|app| app.id.clone())),
binary: override_config
.and_then(|app| app.binary.clone())
.or_else(|| base.and_then(|app| app.binary.clone())),
activity: override_config
.and_then(|app| app.activity.clone())
.or_else(|| base.and_then(|app| app.activity.clone())),
};
if resolved.id.is_some() || resolved.binary.is_some() || resolved.activity.is_some() {
Some(resolved)
} else {
None
}
}