use std::{fs, path::Path, process::Command}; use toml::Value; const PACKAGE_MANIFESTS: [&str; 3] = [ "Cargo.toml", "crates/john-slop-core/Cargo.toml", "crates/john-slop-lsp/Cargo.toml", ]; const INHERITED_PACKAGE_FIELDS: [&str; 5] = [ "version", "edition", "rust-version", "license", "repository", ]; fn manifest(path: impl AsRef) -> Value { let path = path.as_ref(); let source = fs::read_to_string(path) .unwrap_or_else(|error| panic!("failed to read {}: {error}", path.display())); toml::from_str(&source) .unwrap_or_else(|error| panic!("failed to parse {}: {error}", path.display())) } fn string_array<'a>(value: &'a Value, label: &str) -> Vec<&'a str> { value .as_array() .unwrap_or_else(|| panic!("{label} must be an array")) .iter() .map(|entry| { entry .as_str() .unwrap_or_else(|| panic!("{label} entries must be strings")) }) .collect() } #[test] fn workspace_members_and_resolved_versions_are_synchronized() { let root = manifest("Cargo.toml"); let workspace = root["workspace"] .as_table() .expect("workspace must be a table"); let workspace_version = workspace["package"]["version"] .as_str() .expect("workspace.package.version must be a string"); assert_eq!( string_array(&workspace["members"], "workspace.members"), ["crates/john-slop-core", "crates/john-slop-lsp"] ); assert_eq!( string_array(&workspace["default-members"], "workspace.default-members"), [".", "crates/john-slop-core", "crates/john-slop-lsp"] ); let output = Command::new(env!("CARGO")) .args(["metadata", "--locked", "--no-deps", "--format-version", "1"]) .output() .expect("cargo metadata must run"); assert!( output.status.success(), "cargo metadata failed: {}", String::from_utf8_lossy(&output.stderr) ); let metadata: serde_json::Value = serde_json::from_slice(&output.stdout).expect("cargo metadata must emit JSON"); let packages = metadata["packages"] .as_array() .expect("metadata packages must be an array"); assert_eq!(packages.len(), 3); assert!( packages .iter() .all(|package| package["version"] == workspace_version), "all workspace packages must resolve to {workspace_version}" ); for dependency in ["john-slop-core", "john-slop-lsp-engine"] { assert_eq!( workspace["dependencies"][dependency]["version"].as_str(), Some(workspace_version), "workspace.dependencies.{dependency} must match the workspace version" ); } let lockfile = manifest("Cargo.lock"); let locked_packages = lockfile["package"] .as_array() .expect("Cargo.lock package must be an array"); for package_name in ["john_slop", "john-slop-core", "john-slop-lsp"] { let package = locked_packages .iter() .find(|package| package["name"].as_str() == Some(package_name)) .unwrap_or_else(|| panic!("Cargo.lock must contain {package_name}")); assert_eq!( package["version"].as_str(), Some(workspace_version), "Cargo.lock {package_name} version must match the workspace version" ); } let badge = fs::read_to_string("badges/version.svg").expect("version badge must be readable"); assert!( badge.contains(&format!("aria-label=\"version: {workspace_version}\"")), "version badge must advertise workspace version {workspace_version}" ); assert!( badge.contains(&format!("version: {workspace_version}")), "version badge title must match workspace version {workspace_version}" ); } #[test] fn packages_inherit_metadata_and_dependency_sources() { let root = manifest("Cargo.toml"); let workspace_dependencies = root["workspace"]["dependencies"] .as_table() .expect("workspace.dependencies must be a table"); for path in PACKAGE_MANIFESTS { let package_manifest = manifest(path); let package = package_manifest["package"] .as_table() .unwrap_or_else(|| panic!("{path} package must be a table")); for field in INHERITED_PACKAGE_FIELDS { assert_eq!( package[field]["workspace"].as_bool(), Some(true), "{path} must inherit package.{field}" ); } for section in ["dependencies", "dev-dependencies"] { let Some(dependencies) = package_manifest.get(section).and_then(Value::as_table) else { continue; }; for (name, specification) in dependencies { assert!( workspace_dependencies.contains_key(name), "{path} {section}.{name} is missing from workspace.dependencies" ); assert_eq!( specification.get("workspace").and_then(Value::as_bool), Some(true), "{path} {section}.{name} must inherit its workspace requirement" ); } } } } #[test] fn core_and_lsp_feature_boundaries_remain_explicit() { let root = manifest("Cargo.toml"); let core = manifest("crates/john-slop-core/Cargo.toml"); let lsp = manifest("crates/john-slop-lsp/Cargo.toml"); let core_dependencies = core["dependencies"] .as_table() .expect("core dependencies must be a table"); for forbidden in ["clap", "john-slop-lsp-engine", "tokio", "tower-lsp-server"] { assert!( !core_dependencies.contains_key(forbidden), "john-slop-core must not depend on {forbidden}" ); } assert!( root["workspace"]["dependencies"]["tokio"] .get("features") .is_none() ); assert_eq!( string_array( &lsp["dependencies"]["tokio"]["features"], "john-slop-lsp tokio features" ), ["sync"] ); assert_eq!( root["dependencies"]["john-slop-lsp-engine"]["optional"].as_bool(), Some(true) ); assert_eq!( root["dependencies"]["tokio"]["optional"].as_bool(), Some(true) ); assert_eq!( root["dependencies"]["tower-lsp-server"]["optional"].as_bool(), Some(true) ); }