use super::*;
fn resolved(manifest: &str) -> ResolvedPackage {
let parsed: ManifestView = cargo_manifest(manifest).view().unwrap();
let package = parsed.package.unwrap();
ResolvedPackage {
workspace_root: PathBuf::new(),
package_dir: PathBuf::new(),
features: parsed.features.clone(),
name: package.name.clone(),
version: "1.0.0".to_string(),
package,
workspace_package: None,
produces_cdylib: false,
default_run: None,
}
}
fn selected(manifest: &str, wanted: &str) -> Vec<String> {
let mut args = Vec::new();
resolved(manifest)
.frontend_feature(wanted)
.push_to(&mut args);
args
}
const MULTI_TARGET: &str = r#"
[package]
name = "sandbox"
[features]
default = ["desktop"]
desktop = ["telar/desktop"]
tui = ["telar/tui"]
"#;
#[test]
fn asking_for_another_target_turns_the_default_one_off() {
assert_eq!(
selected(MULTI_TARGET, "tui"),
vec!["--no-default-features", "--features", "sandbox/tui"],
);
}
#[test]
fn the_target_a_package_already_defaults_to_is_left_alone() {
assert!(
selected(MULTI_TARGET, "desktop").is_empty(),
"naming what `default` already says would only drop the rest of it"
);
}
#[test]
fn a_package_that_declares_no_such_feature_goes_through_telar() {
let manifest = "[package]\nname = \"solo\"\n";
assert_eq!(selected(manifest, "tui"), vec!["--features", "telar/tui"]);
}
#[test]
fn the_rest_of_the_defaults_come_back() {
let manifest = r#"
[package]
name = "app"
[features]
default = ["desktop", "telemetry", "telar/svg"]
desktop = ["telar/desktop"]
tui = ["telar/tui"]
telemetry = []
"#;
assert_eq!(
selected(manifest, "tui"),
vec![
"--no-default-features",
"--features",
"app/tui,app/telemetry,telar/svg",
],
);
}
#[test]
fn a_frontend_reached_through_another_feature_still_counts() {
let manifest = r#"
[package]
name = "app"
[features]
default = ["everything"]
everything = ["desktop", "telemetry"]
desktop = ["telar/desktop"]
tui = ["telar/tui"]
telemetry = []
"#;
assert_eq!(
selected(manifest, "tui"),
vec!["--no-default-features", "--features", "app/tui"],
"`everything` carries the window, so re-naming it would bring it back"
);
assert!(selected(manifest, "desktop").is_empty());
}
#[test]
fn a_terminal_project_is_one_without_being_told() {
let tui = r#"
[package]
name = "app"
[features]
default = ["tui"]
desktop = ["telar/desktop"]
tui = ["telar/tui"]
"#;
assert!(resolved(tui).defaults_to_terminal());
assert!(
!resolved(MULTI_TARGET).defaults_to_terminal(),
"a default that opens a window is not a terminal project, whatever else it can compile"
);
assert!(
!resolved("[package]\nname = \"solo\"\n").defaults_to_terminal(),
"a package that named nothing keeps telar's own default, which is a window"
);
}
fn declared_features(manifest: &str) -> BTreeMap<String, toml::Value> {
cargo_manifest(manifest)
.view::<ManifestView>()
.unwrap()
.features
}
#[test]
fn a_tooling_feature_no_member_names_is_reported_with_the_entry_that_locks_it() {
let note = unlocked_tooling_note(
&[declared_features("[package]\nname = \"app\"\n")],
&["telar/dev"],
)
.expect("nothing in the workspace names `telar/dev`");
assert!(note.contains("`telar/dev`"), "{note}");
assert!(note.contains(&tooling_feature_entry()), "{note}");
}
#[test]
fn any_member_naming_it_in_either_spelling_locks_it() {
let app = declared_features("[package]\nname = \"app\"\n");
for spelling in ["telar/dev", "telar?/dev"] {
let tools = declared_features(&format!(
"[package]\nname = \"tools\"\n[features]\nlocked = [\"{spelling}\"]\n"
));
assert_eq!(
unlocked_tooling_note(&[app.clone(), tools], &["telar/dev"]),
None,
"`{spelling}`"
);
}
}
#[test]
fn only_the_features_left_unlocked_are_named() {
let app = declared_features("[package]\nname = \"app\"\n[features]\ndev = [\"telar/dev\"]\n");
let note = unlocked_tooling_note(&[app], &["telar/dev", "telar/hot-reload"])
.expect("`telar/hot-reload` is named nowhere");
assert!(note.contains("names `telar/hot-reload`, so"), "{note}");
}
#[test]
fn the_entry_cargo_telar_new_writes_locks_every_tooling_feature() {
let manifest = format!(
"[package]\nname = \"app\"\n[features]\n{}\n",
tooling_feature_entry()
);
assert_eq!(
unlocked_tooling_note(&[declared_features(&manifest)], &TOOLING_FEATURES),
None
);
}
#[test]
fn targets_web_is_true_for_either_spelling_of_the_browser_frontend() {
assert!(resolved(MULTI_TARGET.replace("tui", "web").as_str()).targets_web());
let dom = r#"
[package]
name = "app"
[features]
default = ["desktop"]
desktop = ["telar/desktop"]
web-dom = ["telar/web-dom"]
"#;
assert!(resolved(dom).targets_web());
assert!(
!resolved(MULTI_TARGET).targets_web(),
"a desktop/tui project names neither `web` nor `web-dom`"
);
}
fn write_workspace_manifest(dir: &Path, contents: &str) {
std::fs::create_dir_all(dir).unwrap();
std::fs::write(dir.join("Cargo.toml"), contents).unwrap();
}
fn temp_dir(name: &str) -> PathBuf {
let dir =
std::env::temp_dir().join(format!("cargo_telar_config_{name}_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
dir
}
#[test]
fn has_web_profile_reads_the_workspace_root_manifest() {
let dir = temp_dir("has_profile");
write_workspace_manifest(
&dir,
"[package]\nname = \"app\"\n\n[profile.web]\ninherits = \"release\"\n",
);
assert!(has_web_profile(&dir));
}
#[test]
fn has_web_profile_is_false_when_the_manifest_names_no_such_profile() {
let dir = temp_dir("no_profile");
write_workspace_manifest(&dir, "[package]\nname = \"app\"\n\n[profile.release]\n");
assert!(!has_web_profile(&dir));
}
#[test]
fn has_web_profile_is_false_when_there_is_no_manifest_at_all() {
assert!(!has_web_profile(Path::new(
"/nonexistent/cargo_telar_test_path"
)));
}
fn cargo_manifest(manifest: &str) -> CargoManifest {
CargoManifest::parse(Path::new("/nonexistent/package"), manifest).unwrap()
}
#[test]
fn the_catalogue_features_become_telar_components_with_no_feature() {
let manifest = cargo_manifest(
"[package]\nname = \"app\"\n[dependencies]\ntelar = { version = \"0.2\", features = [\"desktop\", \"components-overlays\", \"components-advanced\", \"components-base\"] }\n",
);
let moved = moved_telar_features(&manifest, None);
assert_eq!(
moved,
BTreeSet::from([
"components-advanced",
"components-base",
"components-overlays"
])
);
let hint = moved_features_hint("app", &moved, &[]).unwrap();
assert!(
hint.contains("cargo add -p app telar-components\n"),
"{hint}"
);
assert!(!hint.contains("--features"), "{hint}");
assert!(!hint.contains("telar-navigate"), "{hint}");
assert!(hint.contains("prelude = [\"telar_components\"]"), "{hint}");
}
#[test]
fn the_whole_catalogue_is_telar_components_and_navigate_is_its_own_crate() {
let moved = moved_telar_features(
&cargo_manifest(
"[package]\nname = \"app\"\n[dependencies]\ntelar = { version = \"0.2\", features = [\"components\", \"navigate\"] }\n",
),
None,
);
let hint = moved_features_hint("app", &moved, &[]).unwrap();
assert!(
hint.contains("cargo add -p app telar-components\n"),
"{hint}"
);
assert!(hint.contains("cargo add -p app telar-navigate"), "{hint}");
assert!(
hint.contains("prelude = [\"telar_components\", \"telar_navigate\"]"),
"{hint}"
);
}
#[test]
fn a_moved_feature_is_found_wherever_the_manifest_turns_it_on() {
for spelling in ["telar/navigate", "telar?/navigate"] {
let manifest = cargo_manifest(&format!(
"[package]\nname = \"app\"\n[dependencies]\ntelar = \"0.2\"\n[features]\nroutes = [\"{spelling}\"]\n"
));
assert_eq!(
moved_telar_features(&manifest, None),
BTreeSet::from(["navigate"]),
"{spelling}"
);
}
let target = cargo_manifest(
"[package]\nname = \"app\"\n[target.'cfg(unix)'.dependencies]\ntelar = { version = \"0.2\", features = [\"components-chrome\"] }\n",
);
assert_eq!(
moved_telar_features(&target, None),
BTreeSet::from(["components-chrome"])
);
let renamed = cargo_manifest(
"[package]\nname = \"app\"\n[dependencies]\nui = { package = \"telar\", version = \"0.2\" }\n[features]\nnav = [\"ui/navigate\"]\n",
);
assert_eq!(
moved_telar_features(&renamed, None),
BTreeSet::from(["navigate"])
);
let workspace = cargo_manifest(
"[workspace.dependencies]\ntelar = { version = \"0.2\", features = [\"components\"] }\n",
);
let inheriting =
cargo_manifest("[package]\nname = \"app\"\n[dependencies]\ntelar = { workspace = true }\n");
assert_eq!(
moved_telar_features(&inheriting, workspace.workspace_dependencies()),
BTreeSet::from(["components"])
);
}
#[test]
fn a_project_that_names_none_of_them_gets_no_hint() {
let manifest = cargo_manifest(
"[package]\nname = \"app\"\n[dependencies]\ntelar = { version = \"0.2\", features = [\"desktop\"] }\ntelar-components = \"0.2\"\n[features]\nnavigate = []\n",
);
let moved = moved_telar_features(&manifest, None);
assert!(moved.is_empty(), "{moved:?}");
assert_eq!(moved_features_hint("app", &moved, &[]), None);
}
#[test]
fn the_prelude_line_keeps_what_is_declared_and_is_left_out_when_complete() {
let moved = BTreeSet::from(["components", "navigate"]);
let declared = [telar_project::PreludeEntry::parse("my-plugin").unwrap()];
let hint = moved_features_hint("app", &moved, &declared).unwrap();
assert!(
hint.contains("prelude = [\"my_plugin\", \"telar_components\", \"telar_navigate\"]"),
"{hint}"
);
let complete = [
telar_project::PreludeEntry::parse("telar-components").unwrap(),
telar_project::PreludeEntry::parse("telar-navigate").unwrap(),
];
let hint = moved_features_hint("app", &moved, &complete).unwrap();
assert!(!hint.contains("prelude"), "{hint}");
}
#[test]
fn the_watch_feature_becomes_telar_watch_without_a_prelude_entry() {
let moved = moved_telar_features(
&cargo_manifest(
"[package]\nname = \"app\"\n[dependencies]\ntelar = { version = \"0.2\", features = [\"desktop\", \"watch\"] }\n",
),
None,
);
assert_eq!(moved, BTreeSet::from(["watch"]));
let hint = moved_features_hint("app", &moved, &[]).unwrap();
assert!(hint.contains("cargo add -p app telar-watch"), "{hint}");
assert!(!hint.contains("prelude"), "{hint}");
}
fn workshop_refusal(package: &str) -> Option<String> {
missing_workshop(&resolve_package(&["-p", package].map(str::to_string)).unwrap())
}
#[test]
fn a_package_without_the_workshop_is_refused_with_the_command_that_adds_it() {
let refusal =
workshop_refusal("telar-components").expect("telar-components declares no workshop");
assert!(
refusal.contains("`telar-components` declares no optional `telar-workshop` dependency"),
"{refusal}"
);
assert!(
refusal.contains("cargo add -p telar-components telar-workshop --optional"),
"{refusal}"
);
assert_eq!(refusal.lines().count(), 1, "{refusal}");
}
#[test]
fn a_package_that_declares_the_workshop_is_not_refused() {
assert_eq!(workshop_refusal("catalogue"), None);
}
fn package_in(manifest: &str) -> (tempfile::TempDir, Result<ResolvedPackage, PackageError>) {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("Cargo.toml"), manifest).unwrap();
let resolved = resolve_package_in(dir.path().to_path_buf());
(dir, resolved)
}
#[test]
fn a_package_resolves_to_its_own_name_and_version() {
let (_dir, resolved) = package_in("[package]\nname = \"gallery\"\nversion = \"2.4.1\"\n");
let resolved = resolved.unwrap();
assert_eq!(resolved.name, "gallery");
assert_eq!(resolved.version, "2.4.1");
}
#[test]
fn a_version_inherited_from_the_workspace_resolves_to_the_workspace_one() {
let (_dir, resolved) = package_in(
"[workspace]\n[workspace.package]\nversion = \"3.1.0\"\n[package]\nname = \"gallery\"\nversion.workspace = true\n",
);
assert_eq!(resolved.unwrap().version, "3.1.0");
}
#[test]
fn a_malformed_manifest_is_reported_with_its_parse_error() {
let (dir, resolved) = package_in("[package\nname = \"gallery\"\n");
let message = resolved.err().expect("a malformed manifest").to_string();
assert!(
message.contains(&dir.path().join("Cargo.toml").display().to_string()),
"{message}"
);
}
#[test]
fn a_package_without_a_version_is_refused_instead_of_given_one() {
let (_dir, resolved) = package_in("[package]\nname = \"gallery\"\n");
let message = resolved.err().expect("no version").to_string();
assert!(message.contains("`gallery` has no `version`"), "{message}");
}
#[test]
fn a_manifest_without_a_package_is_refused() {
let (_dir, resolved) = package_in("[workspace]\nmembers = []\n");
assert!(matches!(resolved, Err(PackageError::NoPackage { .. })));
}
#[test]
fn a_directory_without_a_manifest_is_refused() {
let dir = tempfile::tempdir().unwrap();
let resolved = resolve_package_in(dir.path().to_path_buf());
assert!(matches!(resolved, Err(PackageError::NoManifest { .. })));
}