212 lines
7.0 KiB
Rust
212 lines
7.0 KiB
Rust
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<Path>) -> 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!("<title>version: {workspace_version}</title>")),
|
|
"version badge title must match workspace version {workspace_version}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn cargo_binstall_metadata_matches_release_archives() {
|
|
let root = manifest("Cargo.toml");
|
|
let binstall = root["package"]["metadata"]["binstall"]
|
|
.as_table()
|
|
.expect("package.metadata.binstall must be a table");
|
|
|
|
assert_eq!(
|
|
binstall["pkg-url"].as_str(),
|
|
Some("{ repo }/releases/download/v{ version }/{ name }-{ target }-v{ version }.tgz")
|
|
);
|
|
assert_eq!(binstall["pkg-fmt"].as_str(), Some("tgz"));
|
|
assert_eq!(
|
|
binstall["bin-dir"].as_str(),
|
|
Some("{ name }-{ target }-v{ version }/{ bin }{ binary-ext }")
|
|
);
|
|
}
|
|
|
|
#[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)
|
|
);
|
|
}
|