use std::io;
use std::path::{Path, PathBuf};
use cap_std::fs::Dir;
use oakum::discover::cargo_members;
use semver::Version;
use serde_json::Value;
use super::fs::{read_resolved_text, repo_path_display};
use super::repository::Repository;
use super::workflow::npm_workspace;
use super::CliError;
const NPM_PACKAGE: &str = "@oakoss/oakum";
const UNPARSEABLE_YAML: &str = "unparseable-yaml";
const WITH_NOT_OBJECT: &str = "with-not-object";
const MISE_GITHUB_KEY: &str = "github:oakoss/oakum";
pub(super) fn agreement(
read: &Result<Option<Pins>, CliError>,
npm_workspace: bool,
) -> Result<(), CliError> {
match read {
Ok(Some(Pins::Agreed(AgreedPin {
cargo_unread: None, ..
}))) => Ok(()),
Ok(Some(Pins::Agreed(AgreedPin {
cargo_unread: Some(err),
..
})))
| Err(err) => Err(err.clone()),
Ok(Some(Pins::Disagree(pins))) => Err(CliError::unverified(disagreement(pins))),
Ok(None) => Err(CliError::unverified(no_pin(npm_workspace))),
}
}
#[derive(Debug, PartialEq, Eq)]
pub(super) enum Standing<'a> {
Settled,
Elsewhere(&'a Version),
Unsettled,
}
pub(super) fn standing(read: &Result<Option<Pins>, CliError>) -> Standing<'_> {
match read {
Ok(None) => Standing::Settled,
Ok(Some(Pins::Agreed(pin))) if pin.version != binary_version() => {
Standing::Elsewhere(&pin.version)
}
Ok(Some(Pins::Agreed(pin))) if pin.cargo_unread.is_none() => Standing::Settled,
Ok(Some(Pins::Agreed(_) | Pins::Disagree(_))) | Err(_) => Standing::Unsettled,
}
}
fn binary_version() -> Version {
Version::parse(env!("CARGO_PKG_VERSION")).expect("CARGO_PKG_VERSION is a semver version")
}
#[derive(Clone, Copy, Debug)]
pub(super) enum PinPolicy {
Writer,
Release,
Adopt,
Upgrade,
}
#[derive(Debug)]
pub(super) enum Owed {
Missing(CliError),
Unsettled(CliError),
}
impl Owed {
pub(super) fn step(&self, workflow: Option<&str>) -> String {
match self {
Self::Missing(advice) => workflow.and_then(workflow_pin_line).map_or_else(
|| advice.detail(),
|line| {
format!(
"no oakum install pin yet; `{line}` in the printed workflow is the pin: \
commit the workflow under `.github/workflows/`"
)
},
),
Self::Unsettled(err) => err.detail(),
}
}
pub(super) fn detail(&self) -> String {
self.step(None)
}
pub(super) fn refusal(&self) -> Option<CliError> {
match self {
Self::Missing(_) => None,
Self::Unsettled(err) => Some(err.clone()),
}
}
}
fn workflow_pin_line(workflow: &str) -> Option<&str> {
let version = versions_in_workflow(workflow).ok()?.into_iter().next()?;
let spec = format!("oakum@{version}");
workflow
.lines()
.map(str::trim)
.find(|line| line.contains(&spec))
.map(|line| line.trim_start_matches("- ").trim_start_matches("run: "))
}
pub(super) fn gate(repo: &Repository, policy: PinPolicy) -> Result<Option<Owed>, CliError> {
let binary = binary_version();
let owed = match read_pin(repo) {
Ok(Some(Pins::Agreed(pin))) => match (mismatch(&pin, &binary), pin.cargo_unread) {
(Some(message), _) => return Err(CliError::new(message)),
(None, None) => return Ok(None),
(None, Some(err)) => Owed::Unsettled(err),
},
Ok(Some(Pins::Disagree(pins))) => {
Owed::Unsettled(CliError::unverified(disagreement(&pins)))
}
Ok(None) => Owed::Missing(CliError::unverified(no_pin(npm_workspace(repo.path())))),
Err(err) => Owed::Unsettled(err),
};
match (policy, owed) {
(PinPolicy::Release, _) => Ok(None),
(PinPolicy::Adopt, owed) | (PinPolicy::Upgrade, owed @ Owed::Missing(_)) => Ok(Some(owed)),
(PinPolicy::Writer, Owed::Missing(err) | Owed::Unsettled(err))
| (PinPolicy::Upgrade, Owed::Unsettled(err)) => Err(err),
}
}
fn mismatch(pin: &AgreedPin, binary: &Version) -> Option<String> {
let mut sources: Vec<&Path> = Vec::new();
for source in &pin.sources {
if !sources.contains(&source.as_path()) {
sources.push(source);
}
}
let listed = sources
.iter()
.map(|source| repo_path_display(source))
.collect::<Vec<_>>()
.join(", ");
let pinned = &pin.version;
let fix = match binary.cmp(pinned) {
std::cmp::Ordering::Equal => return None,
std::cmp::Ordering::Less => {
let pnpm_exec = if sources.contains(&Path::new("package.json")) {
", or run the pinned one with `pnpm exec oakum`"
} else {
""
};
format!("install oakum `{pinned}`{pnpm_exec}")
}
std::cmp::Ordering::Greater => format!("raise the pin in {listed} to `{binary}`"),
};
Some(format!(
"this binary is `{binary}` but the install pin is `{pinned}` ({listed}); {fix}"
))
}
fn disagreement(pins: &[FoundPin]) -> String {
let mut listed: Vec<(&Version, &Path)> = Vec::new();
for pin in pins {
let entry = (&pin.version, pin.source.as_path());
if !listed.contains(&entry) {
listed.push(entry);
}
}
let listed = listed
.iter()
.map(|(version, source)| format!("`{version}` ({})", repo_path_display(source)))
.collect::<Vec<_>>()
.join(", ");
format!("unverified: install pins disagree: {listed}; keep one exact version")
}
fn no_pin(npm_workspace: bool) -> String {
let binary = env!("CARGO_PKG_VERSION");
let pin = if npm_workspace {
format!("`pnpm add -D --allow-build={NPM_PACKAGE} {NPM_PACKAGE}@{binary}`")
} else {
format!("add `\"{MISE_GITHUB_KEY}\" = \"{binary}\"` under `[tools]` in `.mise.toml`")
};
format!(
"unverified: no oakum install pin in `.github/workflows`, `.github/actions`, \
`package.json`, `.mise.toml`, `mise.toml`, or a Cargo workspace member named `oakum`; \
pin this binary's version: {pin}"
)
}
#[derive(Debug)]
pub(super) struct FoundPin {
source: PathBuf,
version: Version,
}
#[derive(Debug)]
pub(super) enum Pins {
Agreed(AgreedPin),
Disagree(Vec<FoundPin>),
}
#[derive(Debug)]
pub(super) struct AgreedPin {
version: Version,
sources: Vec<PathBuf>,
cargo_unread: Option<CliError>,
}
pub(super) fn read_pin(repo: &Repository) -> Result<Option<Pins>, CliError> {
settle(collect_pins(repo.dir()), cargo_member_pin(repo))
}
fn settle(
files: Result<Vec<FoundPin>, Box<dyn std::error::Error>>,
cargo: Result<Option<FoundPin>, CliError>,
) -> Result<Option<Pins>, CliError> {
let mut pins = files.map_err(CliError::from_boxed)?;
let cargo_unread = match cargo {
Ok(pin) => {
pins.extend(pin);
None
}
Err(err) => Some(err),
};
let Some(first) = pins.first() else {
return cargo_unread.map_or(Ok(None), Err);
};
if pins.iter().any(|pin| pin.version != first.version) {
return Ok(Some(Pins::Disagree(pins)));
}
let version = first.version.clone();
let sources = pins.into_iter().map(|pin| pin.source).collect();
Ok(Some(Pins::Agreed(AgreedPin {
version,
sources,
cargo_unread,
})))
}
#[cfg(test)]
mod owed_step {
use super::Owed;
use crate::cli::CliError;
const WORKFLOW: &str =
"jobs:\n release:\n steps:\n - run: npm i -g @oakoss/oakum@1.2.3\n";
#[test]
fn a_printed_install_line_is_the_pin_when_nothing_else_pins() {
let owed = Owed::Missing(CliError::unverified(
"unverified: no oakum install pin in x",
));
assert_eq!(
owed.step(Some(WORKFLOW)),
"no oakum install pin yet; `npm i -g @oakoss/oakum@1.2.3` in the printed workflow \
is the pin: commit the workflow under `.github/workflows/`"
);
assert_eq!(owed.step(None), "no oakum install pin in x");
assert_eq!(
owed.step(Some("jobs: {}\n")),
"no oakum install pin in x",
"a workflow with no install line"
);
}
#[test]
fn unsettled_pins_are_not_told_to_commit_another() {
let owed = Owed::Unsettled(CliError::unverified("unverified: install pins disagree"));
assert_eq!(owed.step(Some(WORKFLOW)), "install pins disagree");
assert!(owed.refusal().is_some());
}
}
#[cfg(test)]
mod mismatch_text {
use std::path::PathBuf;
use super::{mismatch, AgreedPin};
fn text(pinned: &str, sources: &[&str], binary: &str) -> Option<String> {
let pin = AgreedPin {
version: pinned.parse().expect("pinned"),
sources: sources.iter().map(PathBuf::from).collect(),
cargo_unread: None,
};
mismatch(&pin, &binary.parse().expect("binary"))
}
#[test]
fn a_matching_pin_says_nothing() {
assert_eq!(text("0.5.1", &[".mise.toml"], "0.5.1"), None);
}
#[test]
fn a_binary_older_than_the_pin_names_installing_the_pin() {
assert_eq!(
text(
"0.6.0",
&[".github/workflows/release.yml", ".mise.toml"],
"0.5.1"
)
.as_deref(),
Some(
"this binary is `0.5.1` but the install pin is `0.6.0` \
(.github/workflows/release.yml, .mise.toml); install oakum `0.6.0`"
)
);
}
#[test]
fn a_package_json_pin_adds_pnpm_exec_to_the_install() {
assert_eq!(
text("0.6.0", &["package.json"], "0.5.1").as_deref(),
Some(
"this binary is `0.5.1` but the install pin is `0.6.0` (package.json); \
install oakum `0.6.0`, or run the pinned one with `pnpm exec oakum`"
)
);
}
#[test]
fn a_binary_newer_than_the_pin_names_raising_it_in_each_source_once() {
assert_eq!(
text(
"0.4.0",
&[
".github/workflows/release.yml",
".github/workflows/release.yml",
"package.json",
],
"0.5.1",
)
.as_deref(),
Some(
"this binary is `0.5.1` but the install pin is `0.4.0` \
(.github/workflows/release.yml, package.json); raise the pin in \
.github/workflows/release.yml, package.json to `0.5.1`"
)
);
}
}
#[cfg(test)]
mod required_reads {
#[test]
fn a_listed_file_that_is_gone_is_unverified_rather_than_empty() {
let dir =
cap_std::fs::Dir::open_ambient_dir(std::env::temp_dir(), cap_std::ambient_authority())
.expect("temp dir");
let err = super::read_text(&dir, std::path::Path::new("oakum-no-such-workflow.yml"))
.expect_err("nothing to read");
assert!(
err.to_string().contains("disappeared during the look"),
"{err}"
);
}
}
#[cfg(test)]
mod pin_reading {
use std::path::PathBuf;
use cap_std::fs::Dir;
use semver::Version;
use super::{collect_pins, settle, Pins};
use crate::test_fixture::Fixture;
fn read_files(dir: &Dir) -> Result<Option<Pins>, crate::cli::CliError> {
settle(collect_pins(dir), Ok(None))
}
fn read(root: &Fixture) -> Option<Pins> {
let dir = Dir::open_ambient_dir(root, cap_std::ambient_authority()).unwrap();
read_files(&dir).expect("pins settle")
}
fn workflow_pin(root: &Fixture, name: &str, version: &str) {
std::fs::create_dir_all(root.join(".github/workflows")).unwrap();
std::fs::write(
root.join(".github/workflows").join(name),
format!("run: cargo binstall --no-confirm oakum@{version}\n"),
)
.unwrap();
}
fn package_json_pin(root: &Fixture, version: &str) {
std::fs::write(
root.join("package.json"),
format!(r#"{{"devDependencies":{{"@oakoss/oakum":"{version}"}}}}"#),
)
.unwrap();
}
#[test]
fn no_pin_is_none() {
let root = Fixture::new("read-pin", "none");
std::fs::write(root.join("package.json"), "{}").unwrap();
assert!(read(&root).is_none());
}
#[test]
fn one_pin_is_agreed_with_its_source() {
let root = Fixture::new("read-pin", "one");
package_json_pin(&root, "0.3.0");
let Some(Pins::Agreed(pin)) = read(&root) else {
panic!("one pin agrees with itself");
};
assert_eq!(pin.version, Version::new(0, 3, 0));
assert_eq!(pin.sources, [PathBuf::from("package.json")]);
}
#[test]
fn agreeing_pins_in_two_files_list_both_sources() {
let root = Fixture::new("read-pin", "agree");
workflow_pin(&root, "release.yml", "0.3.0");
package_json_pin(&root, "0.3.0");
let Some(Pins::Agreed(pin)) = read(&root) else {
panic!("same version in both files agrees");
};
assert_eq!(pin.version, Version::new(0, 3, 0));
assert_eq!(
pin.sources,
[
PathBuf::from(".github/workflows/release.yml"),
PathBuf::from("package.json"),
]
);
}
#[test]
fn a_disagreement_lists_each_version_and_source_once() {
let root = Fixture::new("read-pin", "disagree-twice");
std::fs::create_dir_all(root.join(".github/workflows")).unwrap();
std::fs::write(
root.join(".github/workflows/release.yml"),
"- run: cargo binstall --no-confirm oakum@0.3.0\n- run: cargo install oakum@0.3.0\n",
)
.unwrap();
package_json_pin(&root, "0.4.0");
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = super::agreement(&read_files(&dir), false).expect_err("two versions");
assert_eq!(
err.to_string(),
"unverified: install pins disagree: `0.3.0` (.github/workflows/release.yml), \
`0.4.0` (package.json); keep one exact version"
);
}
#[test]
fn agreeing_mise_files_are_both_sources() {
let root = Fixture::new("read-pin", "both-mise");
for name in [".mise.toml", "mise.toml"] {
std::fs::write(
root.join(name),
"[tools]\n\"github:oakoss/oakum\" = \"0.0.1\"\n",
)
.unwrap();
}
let Some(Pins::Agreed(pin)) = read(&root) else {
panic!("the same version in both mise files agrees");
};
assert_eq!(
pin.sources,
[PathBuf::from(".mise.toml"), PathBuf::from("mise.toml")]
);
}
#[test]
fn workflow_pins_are_listed_by_file_name() {
let root = Fixture::new("read-pin", "by-name");
for (name, version) in [("c.yml", "0.5.0"), ("b.yml", "0.4.0"), ("a.yml", "0.3.0")] {
workflow_pin(&root, name, version);
}
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = super::agreement(&read_files(&dir), false).expect_err("three versions");
assert_eq!(
err.to_string(),
"unverified: install pins disagree: `0.3.0` (.github/workflows/a.yml), \
`0.4.0` (.github/workflows/b.yml), `0.5.0` (.github/workflows/c.yml); \
keep one exact version"
);
}
#[test]
fn disagreeing_pins_in_two_files_keep_each_version_and_source() {
let root = Fixture::new("read-pin", "disagree");
workflow_pin(&root, "release.yml", "0.3.0");
package_json_pin(&root, "0.4.0");
let Some(Pins::Disagree(pins)) = read(&root) else {
panic!("two versions disagree");
};
let found: Vec<(Version, PathBuf)> = pins
.into_iter()
.map(|pin| (pin.version, pin.source))
.collect();
assert_eq!(
found,
[
(
Version::new(0, 3, 0),
PathBuf::from(".github/workflows/release.yml"),
),
(Version::new(0, 4, 0), PathBuf::from("package.json")),
]
);
}
}
fn collect_pins(dir: &Dir) -> Result<Vec<FoundPin>, Box<dyn std::error::Error>> {
let mut pins = Vec::new();
scan_workflows(dir, &mut pins)?;
scan_composite_actions(dir, &mut pins)?;
if let Some(pin) = read_package_json_pin(dir)? {
pins.push(pin);
}
pins.extend(read_mise_pins(dir)?);
Ok(pins)
}
fn cargo_member_pin(repo: &Repository) -> Result<Option<FoundPin>, CliError> {
if !cargo_manifest_present(repo.dir())? {
return Ok(None);
}
let unread = |detail: String| {
CliError::unverified(format!(
"unverified: could not read the Cargo workspace for a member named `oakum` (cargo: {detail})"
))
};
let root = repo.ambient_path().map_err(|err| unread(err.to_string()))?;
let members = cargo_members(root, root).map_err(|err| unread(err.to_string()))?;
let Some(member) = members.into_iter().find(|member| member.name == "oakum") else {
return Ok(None);
};
let source = Path::new(&member.manifest_dir).join("Cargo.toml");
require_declared_version(repo.dir(), &source)?;
Ok(Some(FoundPin {
source,
version: member.version,
}))
}
fn require_declared_version(dir: &Dir, source: &Path) -> Result<(), CliError> {
let shown = repo_path_display(source);
let text = read_pin_source(dir, source)?.ok_or_else(|| {
CliError::unverified(format!("unverified: `{shown}` disappeared during the look"))
})?;
let manifest: toml::Value = toml::from_str(&text).map_err(|err| {
CliError::unverified(format!("unverified: `{shown}` is not valid TOML: {err}"))
})?;
let version = manifest
.get("package")
.or_else(|| manifest.get("project"))
.and_then(|package| package.get("version"));
let declared = version.is_some_and(|version| {
version.is_str() || version.get("workspace").and_then(toml::Value::as_bool) == Some(true)
});
if declared {
Ok(())
} else {
Err(CliError::unverified(format!(
"unverified: `{shown}` package `oakum` has no exact `version`"
)))
}
}
fn cargo_manifest_present(dir: &Dir) -> Result<bool, CliError> {
Ok(read_pin_source(dir, Path::new("Cargo.toml"))?.is_some())
}
fn scan_workflows(dir: &Dir, pins: &mut Vec<FoundPin>) -> Result<(), Box<dyn std::error::Error>> {
let entries = match dir.read_dir(".github/workflows") {
Ok(entries) => entries,
Err(err) if err.kind() == io::ErrorKind::NotFound => {
refuse_dangling(dir, Path::new(".github/workflows"))?;
return Ok(());
}
Err(err) => {
return Err(Box::new(CliError::unverified(format!(
"unverified: failed to read `.github/workflows`: {err}"
))));
}
};
let mut entries = entries.collect::<Result<Vec<_>, _>>().map_err(|err| {
CliError::unverified(format!(
"unverified: failed to read `.github/workflows`: {err}"
))
})?;
entries.sort_by_key(cap_std::fs::DirEntry::file_name);
for entry in entries {
let name = entry.file_name();
let path = Path::new(".github/workflows").join(&name);
let Some(name) = name.to_str() else {
return Err(Box::new(CliError::unverified(format!(
"unverified: workflow path `{}` is not valid UTF-8",
repo_path_display(&path)
))));
};
let is_yaml = Path::new(name)
.extension()
.is_some_and(|ext| ext.eq_ignore_ascii_case("yml") || ext.eq_ignore_ascii_case("yaml"));
if !is_yaml {
continue;
}
let file_type = entry.file_type().map_err(|err| {
CliError::unverified(format!(
"unverified: failed to inspect `{}`: {err}",
repo_path_display(&path)
))
})?;
if !file_type.is_file() {
return Err(Box::new(CliError::unverified(format!(
"unverified: `{}` is not a file",
repo_path_display(&path)
))));
}
let text = read_text(dir, &path)?;
push_yaml_pins(&path, &text, pins)?;
}
Ok(())
}
fn scan_composite_actions(
dir: &Dir,
pins: &mut Vec<FoundPin>,
) -> Result<(), Box<dyn std::error::Error>> {
let entries = match dir.read_dir(".github/actions") {
Ok(entries) => entries,
Err(err) if err.kind() == io::ErrorKind::NotFound => {
refuse_dangling(dir, Path::new(".github/actions"))?;
return Ok(());
}
Err(err) => {
return Err(Box::new(CliError::unverified(format!(
"unverified: failed to read `.github/actions`: {err}"
))));
}
};
let mut entries = entries.collect::<Result<Vec<_>, _>>().map_err(|err| {
CliError::unverified(format!(
"unverified: failed to read `.github/actions`: {err}"
))
})?;
entries.sort_by_key(cap_std::fs::DirEntry::file_name);
for entry in entries {
let name = entry.file_name();
let action_dir = Path::new(".github/actions").join(&name);
let file_type = entry.file_type().map_err(|err| {
CliError::unverified(format!(
"unverified: failed to inspect `{}`: {err}",
repo_path_display(&action_dir)
))
})?;
let is_action_dir = if file_type.is_dir() {
true
} else if file_type.is_symlink() {
match dir.metadata(&action_dir) {
Ok(meta) => meta.is_dir(),
Err(err) if err.kind() == io::ErrorKind::NotFound => {
refuse_dangling(dir, &action_dir)?;
false
}
Err(err) => {
return Err(Box::new(CliError::unverified(format!(
"unverified: failed to inspect `{}`: {err}",
repo_path_display(&action_dir)
))));
}
}
} else {
false
};
if !is_action_dir {
continue;
}
for file_name in ["action.yml", "action.yaml"] {
let path = action_dir.join(file_name);
let Some(text) = read_pin_source(dir, &path)? else {
continue;
};
push_yaml_pins(&path, &text, pins)?;
}
}
Ok(())
}
fn push_yaml_pins(
path: &Path,
text: &str,
pins: &mut Vec<FoundPin>,
) -> Result<(), Box<dyn std::error::Error>> {
for version in versions_in_workflow(text).map_err(|raw| {
if raw == "unversioned" {
CliError::unverified(format!(
"unverified: `{}` installs oakum without a version",
repo_path_display(path)
))
} else if raw == UNPARSEABLE_YAML {
CliError::unverified(format!(
"unverified: `{}` is not valid YAML",
repo_path_display(path)
))
} else if raw == WITH_NOT_OBJECT {
CliError::unverified(format!(
"unverified: `{}` has a `with` value that is not a mapping",
repo_path_display(path)
))
} else {
CliError::unverified(format!(
"unverified: `{}` pins oakum as `{raw}`, which is not an exact version",
repo_path_display(path)
))
}
})? {
pins.push(FoundPin {
source: path.to_path_buf(),
version,
});
}
Ok(())
}
fn refuse_dangling(dir: &Dir, path: &Path) -> Result<(), CliError> {
for prefix in path
.ancestors()
.filter(|prefix| !prefix.as_os_str().is_empty())
{
let is_link = dir
.symlink_metadata(prefix)
.is_ok_and(|meta| meta.is_symlink());
if is_link
&& dir
.metadata(prefix)
.is_err_and(|err| err.kind() == io::ErrorKind::NotFound)
{
return Err(CliError::unverified(format!(
"unverified: `{}` is a symlink to a missing target",
repo_path_display(prefix)
)));
}
}
Ok(())
}
fn read_pin_source(dir: &Dir, path: &Path) -> Result<Option<String>, CliError> {
let text = read_resolved_text(dir, path)?;
if text.is_none() {
refuse_dangling(dir, path)?;
}
Ok(text)
}
fn read_text(dir: &Dir, path: &Path) -> Result<String, Box<dyn std::error::Error>> {
match read_resolved_text(dir, path)? {
Some(text) => Ok(text),
None => Err(Box::new(CliError::unverified(format!(
"unverified: `{}` disappeared during the look",
repo_path_display(path)
)))),
}
}
fn read_package_json_pin(dir: &Dir) -> Result<Option<FoundPin>, Box<dyn std::error::Error>> {
let Some(text) = read_pin_source(dir, Path::new("package.json"))? else {
return Ok(None);
};
let value: serde_json::Value = serde_json::from_str(&text).map_err(|err| {
CliError::unverified(format!(
"unverified: `package.json` is not valid JSON: {err}"
))
})?;
let Some(object) = value.as_object() else {
return Err(Box::new(CliError::unverified(
"unverified: `package.json` is not a JSON object",
)));
};
let mut pin: Option<(&str, Version)> = None;
for section in [
"dependencies",
"devDependencies",
"optionalDependencies",
"peerDependencies",
] {
let Some(section_value) = object.get(section) else {
continue;
};
let Some(deps) = section_value.as_object() else {
return Err(Box::new(CliError::unverified(format!(
"unverified: `package.json` `{section}` is not an object"
))));
};
for name in [NPM_PACKAGE, "oakum"] {
let Some(oakum) = deps.get(name) else {
continue;
};
let Some(raw) = oakum.as_str() else {
return Err(Box::new(CliError::unverified(format!(
"unverified: `package.json` pins `{name}` with a non-string value"
))));
};
let Some(version) = exact_version(raw) else {
return Err(Box::new(CliError::unverified(format!(
"unverified: `package.json` pins `{name}` as `{raw}`, which is not an exact version"
))));
};
match &pin {
None => pin = Some((name, version)),
Some((first, existing)) if *existing != version => {
return Err(Box::new(CliError::unverified(format!(
"unverified: `package.json` pins `{first}` as `{existing}` and `{name}` as `{version}`; keep one exact version"
))));
}
Some(_) => {}
}
}
}
Ok(pin.map(|(_, version)| FoundPin {
source: PathBuf::from("package.json"),
version,
}))
}
fn read_mise_pins(dir: &Dir) -> Result<Vec<FoundPin>, Box<dyn std::error::Error>> {
let mut found: Vec<FoundPin> = Vec::new();
for name in [".mise.toml", "mise.toml"] {
let Some(pin) = read_one_mise(dir, name)? else {
continue;
};
if let Some(existing) = found.first() {
if existing.version != pin.version {
return Err(Box::new(CliError::unverified(format!(
"unverified: `{}` pins oakum as `{}` but `{}` pins `{pin_version}`",
repo_path_display(&existing.source),
existing.version,
repo_path_display(&pin.source),
pin_version = pin.version,
))));
}
}
found.push(pin);
}
Ok(found)
}
fn read_one_mise(dir: &Dir, name: &str) -> Result<Option<FoundPin>, Box<dyn std::error::Error>> {
let Some(text) = read_pin_source(dir, Path::new(name))? else {
return Ok(None);
};
let value: toml::Value = toml::from_str(&text).map_err(|err| {
CliError::unverified(format!("unverified: `{name}` is not valid TOML: {err}"))
})?;
let Some(tools_value) = value.get("tools") else {
return Ok(None);
};
let Some(tools) = tools_value.as_table() else {
return Err(Box::new(CliError::unverified(format!(
"unverified: `{name}` has a `tools` value that is not a table"
))));
};
let mut pin = None;
for (key, spec) in tools {
if !is_mise_oakum_key(key) {
continue;
}
let raw = mise_version_spec(spec).ok_or_else(|| {
CliError::unverified(format!(
"unverified: `{name}` pins `{key}` with a value that is not an exact version"
))
})?;
let Some(version) = exact_version(raw) else {
return Err(Box::new(CliError::unverified(format!(
"unverified: `{name}` pins oakum as `{raw}`, which is not an exact version"
))));
};
match &pin {
None => pin = Some(version),
Some(existing) if *existing != version => {
return Err(Box::new(CliError::unverified(format!(
"unverified: `{name}` pins oakum as both `{existing}` and `{version}`"
))));
}
Some(_) => {}
}
}
Ok(pin.map(|version| FoundPin {
source: PathBuf::from(name),
version,
}))
}
fn is_mise_oakum_key(key: &str) -> bool {
key == "oakum" || key == "cargo:oakum" || key == "npm:@oakoss/oakum" || key == MISE_GITHUB_KEY
}
fn mise_version_spec(spec: &toml::Value) -> Option<&str> {
spec.as_str()
.or_else(|| spec.get("version").and_then(toml::Value::as_str))
}
pub(super) fn versions_in_workflow(text: &str) -> Result<Vec<Version>, String> {
if text.trim().is_empty() {
return Ok(Vec::new());
}
let value: Value = serde_saphyr::from_str(text).map_err(|_| UNPARSEABLE_YAML.to_string())?;
let mut versions = Vec::new();
walk_workflow_value(&value, &mut versions)?;
Ok(versions)
}
fn walk_workflow_value(value: &Value, versions: &mut Vec<Version>) -> Result<(), String> {
match value {
Value::Object(map) => {
if let Some(Value::String(run)) = map.get("run") {
append_run_versions(run, versions)?;
}
if let Some(tool) = map.get("tool") {
append_tool_value(tool, versions)?;
}
if let Some(with) = map.get("with") {
walk_with_value(with, versions)?;
}
if let Some(matrix) = map.get("matrix") {
walk_matrix_value(matrix, versions)?;
}
if let Some(Value::String(default)) = map.get("default") {
append_run_versions(default, versions)?;
}
for (key, child) in map {
if matches!(key.as_str(), "with" | "matrix") {
continue;
}
walk_workflow_value(child, versions)?;
}
}
Value::Array(items) => {
for item in items {
walk_workflow_value(item, versions)?;
}
}
_ => {}
}
Ok(())
}
fn walk_with_value(with: &Value, versions: &mut Vec<Version>) -> Result<(), String> {
let Value::Object(map) = with else {
return Err(WITH_NOT_OBJECT.to_owned());
};
for (key, child) in map {
if key == "tool" {
append_tool_value(child, versions)?;
} else {
append_stringish_as_run(child, versions)?;
}
}
Ok(())
}
fn walk_matrix_value(matrix: &Value, versions: &mut Vec<Version>) -> Result<(), String> {
match matrix {
Value::Object(map) => {
for (key, child) in map {
if key == "tool" {
append_tool_value(child, versions)?;
} else {
match child {
Value::String(text) => append_run_versions(text, versions)?,
Value::Array(_) | Value::Object(_) => walk_matrix_value(child, versions)?,
_ => {}
}
}
}
}
Value::Array(items) => {
for item in items {
walk_matrix_value(item, versions)?;
}
}
Value::String(text) => append_run_versions(text, versions)?,
_ => {}
}
Ok(())
}
fn append_tool_value(value: &Value, versions: &mut Vec<Version>) -> Result<(), String> {
match value {
Value::String(tool) => append_tool_versions(tool, versions),
Value::Array(items) => {
for item in items {
if let Value::String(tool) = item {
append_tool_versions(tool, versions)?;
}
}
Ok(())
}
_ => Ok(()),
}
}
fn append_stringish_as_run(value: &Value, versions: &mut Vec<Version>) -> Result<(), String> {
match value {
Value::String(text) => append_run_versions(text, versions),
Value::Array(items) => {
for item in items {
if let Value::String(text) = item {
append_run_versions(text, versions)?;
}
}
Ok(())
}
_ => Ok(()),
}
}
fn append_run_versions(run: &str, versions: &mut Vec<Version>) -> Result<(), String> {
for line in logical_lines(run) {
if line.trim().is_empty() {
continue;
}
append_install_line(&format!("run: {line}"), versions)?;
}
Ok(())
}
fn append_tool_versions(tool: &str, versions: &mut Vec<Version>) -> Result<(), String> {
for line in logical_lines(tool) {
if line.trim().is_empty() {
continue;
}
append_install_line(&format!("tool: {line}"), versions)?;
}
Ok(())
}
fn append_install_line(line: &str, versions: &mut Vec<Version>) -> Result<(), String> {
let code = strip_comment(line);
if !is_install_line(code) {
return Ok(());
}
for unit in install_units(code) {
if unversioned_oakum_install(unit) {
return Err("unversioned".to_owned());
}
for raw in install_version_specs(unit) {
match exact_version(raw) {
Some(version) => versions.push(version),
None => return Err(raw.to_owned()),
}
}
}
Ok(())
}
fn logical_lines(text: &str) -> Vec<String> {
let mut lines = Vec::new();
let mut pending = String::new();
for line in text.lines() {
let trimmed = line.trim_end();
if let Some(prefix) = trimmed.strip_suffix('\\') {
pending.push_str(prefix.trim_end());
pending.push(' ');
continue;
}
pending.push_str(trimmed);
lines.push(std::mem::take(&mut pending));
}
if !pending.is_empty() {
lines.push(pending);
}
lines
}
fn is_install_line(line: &str) -> bool {
let lowered = line.to_ascii_lowercase();
let trimmed = lowered.trim();
if let Some(tool) = trimmed
.strip_prefix("tool:")
.or_else(|| trimmed.strip_prefix("- tool:"))
{
return token_present(tool, "oakum");
}
let Some(command) = run_command(&lowered) else {
return false;
};
shell_segments(command).iter().any(|segment| {
if is_echo_or_printf(segment) {
return false;
}
segment.contains("binstall")
|| segment.contains("cargo install")
|| is_npm_install_unit(segment)
})
}
fn npm_install_specs(segment: &str) -> Option<Vec<&str>> {
let mut argv = segment
.split_whitespace()
.map(|token| token.trim_start_matches('('))
.filter(|token| !token.is_empty())
.skip_while(|token| {
token.eq_ignore_ascii_case("sudo")
|| token.starts_with('-')
|| (token.contains('=') && !token.starts_with('-'))
})
.map(crate_token);
let verb = argv.next()?.to_ascii_lowercase();
let mut argv = argv.peekable();
let single = match verb.as_str() {
"npx" => true,
"npm" => match next_subcommand(&mut argv)?.as_str() {
"i" | "install" | "add" => false,
_ => return None,
},
"pnpm" => match next_subcommand(&mut argv)?.as_str() {
"dlx" => true,
"add" | "install" | "i" => false,
_ => return None,
},
_ => return None,
};
let mut specs = Vec::new();
let mut positional_taken = false;
let mut argv = argv.peekable();
while let Some(token) = argv.next() {
if let Some(spec) = token.strip_prefix("--package=") {
specs.push(spec);
} else if token == "-p" || token == "--package" {
if let Some(spec) = argv.next() {
specs.push(spec);
}
} else if token.starts_with('-') {
} else if single {
if !positional_taken {
specs.push(token);
}
positional_taken = true;
} else {
specs.push(token);
}
}
Some(specs)
}
fn next_subcommand<'a>(argv: &mut impl Iterator<Item = &'a str>) -> Option<String> {
loop {
let token = argv.next()?;
if matches!(token, "--filter" | "--prefix" | "--dir" | "-C" | "-F") {
argv.next();
continue;
}
if token.starts_with('-') {
continue;
}
return Some(token.to_ascii_lowercase());
}
}
fn is_oakum_npm_spec(spec: &str) -> bool {
spec.eq_ignore_ascii_case(NPM_PACKAGE)
|| spec
.get(..NPM_PACKAGE.len() + 1)
.is_some_and(|head| head.eq_ignore_ascii_case("@oakoss/oakum@"))
}
fn is_npm_install_unit(segment: &str) -> bool {
npm_install_specs(segment).is_some_and(|specs| specs.iter().any(|spec| is_oakum_npm_spec(spec)))
}
fn npm_oakum_versions(segment: &str) -> Vec<&str> {
npm_install_specs(segment)
.unwrap_or_default()
.into_iter()
.filter(|spec| is_oakum_npm_spec(spec))
.filter_map(|spec| spec.get(NPM_PACKAGE.len() + 1..))
.map(version_token)
.collect()
}
fn install_units(line: &str) -> Vec<&str> {
let Some(command) = run_command(line) else {
return vec![line];
};
shell_segments(command)
.into_iter()
.filter(|segment| !is_echo_or_printf(segment))
.collect()
}
fn shell_segments(command: &str) -> Vec<&str> {
let mut segments = Vec::new();
let mut rest = command;
loop {
let lower = rest.to_ascii_lowercase();
let split = ["&&", ";"]
.iter()
.filter_map(|sep| lower.find(sep).map(|index| (index, sep.len())))
.min_by_key(|(index, _)| *index);
if let Some((index, sep_len)) = split {
segments.push(rest[..index].trim());
rest = rest[index + sep_len..].trim();
} else {
segments.push(rest.trim());
break;
}
}
segments
}
fn is_echo_or_printf(segment: &str) -> bool {
let trimmed = segment.trim().to_ascii_lowercase();
trimmed.starts_with("echo ")
|| trimmed.starts_with("echo\"")
|| trimmed.starts_with("echo'")
|| trimmed.starts_with("printf ")
}
fn run_command(line: &str) -> Option<&str> {
let trimmed = line.trim();
let lower = trimmed.to_ascii_lowercase();
let prefix_len = if lower.starts_with("- run:") {
"- run:".len()
} else if lower.starts_with("run:") {
"run:".len()
} else {
return None;
};
let command = trimmed[prefix_len..].trim();
(!command.is_empty()).then_some(command)
}
fn strip_comment(line: &str) -> &str {
let mut in_single = false;
let mut in_double = false;
for (index, character) in line.char_indices() {
match character {
'\'' if !in_double => in_single = !in_single,
'"' if !in_single => in_double = !in_double,
'#' if !in_single && !in_double => return line[..index].trim_end(),
_ => {}
}
}
line
}
fn is_tool_install_unit(unit: &str) -> bool {
let trimmed = unit.trim().to_ascii_lowercase();
trimmed.starts_with("tool:") || trimmed.starts_with("- tool:")
}
fn install_version_specs(unit: &str) -> Vec<&str> {
if is_tool_install_unit(unit) {
return oakum_at_specs(unit);
}
let lowered = unit.to_ascii_lowercase();
let mut specs = Vec::new();
if lowered.contains("binstall") {
specs.extend(binstall_specs(unit));
}
if lowered.contains("cargo install") {
specs.extend(cargo_install_specs(unit));
}
if is_npm_install_unit(unit) {
specs.extend(npm_oakum_versions(unit));
}
if specs.is_empty() {
specs = oakum_at_specs(unit);
}
specs
}
fn oakum_at_specs(line: &str) -> Vec<&str> {
let lowered = line.to_ascii_lowercase();
let mut specs = Vec::new();
let mut cursor = 0;
while let Some(relative) = lowered[cursor..].find("oakum@") {
let start = cursor + relative;
if !is_token_start(line, start) {
cursor = start + 6;
continue;
}
specs.push(version_token(&line[start + 6..]));
cursor = start + 6;
}
specs
}
fn unversioned_oakum_install(line: &str) -> bool {
unversioned_tool_line(line)
|| unversioned_binstall(line)
|| unversioned_cargo_install(line)
|| unversioned_npm_install(line)
}
fn unversioned_npm_install(line: &str) -> bool {
npm_install_specs(line).is_some_and(|specs| {
specs
.iter()
.any(|spec| spec.eq_ignore_ascii_case(NPM_PACKAGE))
})
}
fn unversioned_tool_line(line: &str) -> bool {
let lowered = line.to_ascii_lowercase();
let trimmed = lowered.trim();
let Some(tool) = trimmed
.strip_prefix("tool:")
.or_else(|| trimmed.strip_prefix("- tool:"))
else {
return false;
};
tool.split([',', ' ', '\t'])
.map(crate_token)
.any(|token| token == "oakum")
}
fn unversioned_binstall(line: &str) -> bool {
let lowered = line.to_ascii_lowercase();
let mut search = 0;
while let Some(relative) = lowered[search..].find("binstall") {
let start = search + relative;
let rest = &line[start + "binstall".len()..];
if binstall_oakum_unversioned(rest) {
return true;
}
search = start + "binstall".len();
}
false
}
fn binstall_oakum_unversioned(rest: &str) -> bool {
let lower_rest = rest.to_ascii_lowercase();
let end = ["&&", ";", "|"]
.iter()
.filter_map(|sep| lower_rest.find(sep))
.min()
.unwrap_or(rest.len());
argv_oakum_unversioned(rest[..end].trim())
}
fn crate_token(token: &str) -> &str {
token.trim_matches(|character| {
matches!(
character,
'"' | '\'' | '(' | ')' | '[' | ']' | '{' | '}' | '`' | ',' | ';'
)
})
}
fn unversioned_cargo_install(line: &str) -> bool {
let lowered = line.to_ascii_lowercase();
let mut search = 0;
while let Some(relative) = lowered[search..].find("cargo install") {
let start = search + relative;
let rest = &line[start + "cargo install".len()..];
if cargo_install_oakum_unversioned(rest) {
return true;
}
search = start + "cargo install".len();
}
false
}
fn cargo_install_oakum_unversioned(rest: &str) -> bool {
let lower_rest = rest.to_ascii_lowercase();
let end = ["&&", ";", "|"]
.iter()
.filter_map(|sep| lower_rest.find(sep))
.min()
.unwrap_or(rest.len());
argv_oakum_unversioned(rest[..end].trim())
}
fn argv_oakum_unversioned(segment: &str) -> bool {
let mut saw_oakum = false;
let mut version = false;
let mut tokens = segment.split_whitespace().peekable();
while let Some(token) = tokens.next() {
let lower = crate_token(token).to_ascii_lowercase();
if lower.starts_with("oakum@") {
continue;
}
if lower == "oakum" {
saw_oakum = true;
continue;
}
if let Some(spec) = lower
.strip_prefix("--version=")
.or_else(|| lower.strip_prefix("--vers="))
{
version = exact_version(spec).is_some();
continue;
}
if lower == "--version" || lower == "--vers" {
version = tokens
.next()
.and_then(|next| exact_version(crate_token(next)))
.is_some();
}
}
saw_oakum && !version
}
fn binstall_specs(line: &str) -> Vec<&str> {
install_command_specs(line, "binstall")
}
fn cargo_install_specs(line: &str) -> Vec<&str> {
install_command_specs(line, "cargo install")
}
fn install_command_specs<'a>(line: &'a str, verb: &str) -> Vec<&'a str> {
let lowered = line.to_ascii_lowercase();
let mut specs = Vec::new();
let mut search = 0;
while let Some(relative) = lowered[search..].find(verb) {
let start = search + relative;
if let Some(spec) = argv_oakum_version_spec(&line[start + verb.len()..]) {
specs.push(spec);
}
search = start + verb.len();
}
specs
}
fn argv_oakum_version_spec(rest: &str) -> Option<&str> {
let lower_rest = rest.to_ascii_lowercase();
let end = ["&&", ";", "|"]
.iter()
.filter_map(|sep| lower_rest.find(sep))
.min()
.unwrap_or(rest.len());
let segment = rest[..end].trim();
let mut saw_oakum = false;
let mut version = None;
let mut tokens = segment.split_whitespace().peekable();
while let Some(token) = tokens.next() {
let token = crate_token(token);
let lower = token.to_ascii_lowercase();
if let Some(spec) = lower.strip_prefix("oakum@") {
return Some(version_token(&token[token.len() - spec.len()..]));
}
if lower == "oakum" {
saw_oakum = true;
continue;
}
if let Some(spec) = lower
.strip_prefix("--version=")
.or_else(|| lower.strip_prefix("--vers="))
{
version = Some(version_token(&token[token.len() - spec.len()..]));
continue;
}
if lower == "--version" || lower == "--vers" {
if let Some(next) = tokens.next() {
version = Some(version_token(
next.trim_matches(|character| matches!(character, '"' | '\'')),
));
}
}
}
saw_oakum.then_some(())?;
version
}
fn token_present(lowered: &str, token: &str) -> bool {
let mut cursor = 0;
while let Some(relative) = lowered[cursor..].find(token) {
let start = cursor + relative;
if is_token_start(lowered, start) && is_token_end(lowered, start + token.len()) {
return true;
}
cursor = start + 1;
}
false
}
fn is_token_start(text: &str, index: usize) -> bool {
index == 0 || {
let previous = text.as_bytes()[index - 1];
!previous.is_ascii_alphanumeric() && previous != b'_' && previous != b'-'
}
}
fn is_token_end(text: &str, index: usize) -> bool {
index >= text.len() || {
let next = text.as_bytes()[index];
!next.is_ascii_alphanumeric() && next != b'_' && next != b'-'
}
}
fn version_token(rest: &str) -> &str {
let rest = rest.trim_start_matches(['"', '\'']);
let end = rest
.find(|character: char| {
character.is_whitespace()
|| matches!(
character,
'"' | '\'' | ',' | ';' | '#' | '|' | '`' | ')' | ']'
)
})
.unwrap_or(rest.len());
rest[..end].trim_end_matches(['"', '\''])
}
fn exact_version(raw: &str) -> Option<Version> {
let trimmed = raw.trim();
let trimmed = trimmed.strip_prefix('v').unwrap_or(trimmed);
Version::parse(trimmed).ok()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test_fixture::Fixture;
fn workflow(text: &str) -> Vec<Version> {
versions_in_workflow(text).expect("exact pins")
}
fn assert_no_pin(text: &str) {
let versions = workflow(text);
assert!(versions.is_empty(), "{text:?} read as {versions:?}");
}
#[test]
fn binstall_line_yields_the_version() {
let versions = workflow("run: cargo binstall --no-confirm oakum@1.2.3\n");
assert_eq!(versions, vec![Version::parse("1.2.3").unwrap()]);
}
#[test]
fn v_prefix_and_comment_are_stripped() {
let versions = workflow("run: cargo binstall oakum@v0.1.0 # pin\n");
assert_eq!(versions, vec![Version::parse("0.1.0").unwrap()]);
}
#[test]
fn double_v_prefix_is_not_an_exact_pin() {
let err = versions_in_workflow("run: cargo binstall oakum@vv0.1.0\n").unwrap_err();
assert_eq!(err, "vv0.1.0");
}
#[test]
fn commented_out_pin_is_ignored() {
assert_no_pin("# cargo binstall oakum@1.2.3\n");
}
#[test]
fn cargo_install_version_flag() {
let versions = workflow("run: cargo install oakum --version 2.0.0\n");
assert_eq!(versions, vec![Version::parse("2.0.0").unwrap()]);
let versions = workflow("run: cargo install oakum --vers=2.0.0\n");
assert_eq!(versions, vec![Version::parse("2.0.0").unwrap()]);
}
#[test]
fn cargo_install_oakum_at_is_one_pin_not_two() {
let versions = workflow("run: cargo install oakum@1.2.3\n");
assert_eq!(versions, vec![Version::parse("1.2.3").unwrap()]);
}
#[test]
fn binstall_version_flag() {
let versions = workflow("run: cargo binstall oakum --version 2.0.0\n");
assert_eq!(versions, vec![Version::parse("2.0.0").unwrap()]);
let versions = workflow("run: cargo binstall --no-confirm oakum --vers=2.0.0\n");
assert_eq!(versions, vec![Version::parse("2.0.0").unwrap()]);
}
#[test]
fn install_action_without_tool_is_not_a_pin() {
assert_no_pin("uses: oakoss/install-action@v1\n");
assert_no_pin("- uses: oakoss/install-action@v1\n");
}
#[test]
fn mixed_binstall_and_cargo_install_collect_both_pins() {
let versions = workflow("run: cargo binstall oakum@1.0.0 || cargo install oakum@2.0.0\n");
assert_eq!(
versions,
vec![
Version::parse("1.0.0").unwrap(),
Version::parse("2.0.0").unwrap()
]
);
}
#[test]
fn cargo_install_continuation_is_one_command() {
let versions = workflow("run: cargo install oakum \\\n --version 0.0.0\n");
assert_eq!(versions, vec![Version::parse("0.0.0").unwrap()]);
}
#[test]
fn run_block_scalar_is_an_install() {
let versions = workflow("run: |\n cargo binstall --no-confirm oakum@1.2.3\n");
assert_eq!(versions, vec![Version::parse("1.2.3").unwrap()]);
}
#[test]
fn inexact_pin_in_run_block_is_unverified_even_when_another_pin_matches() {
let err = versions_in_workflow(
"jobs:\n ci:\n steps:\n - run: cargo binstall --no-confirm oakum@0.0.0\n - run: |\n cargo binstall oakum@latest\n",
)
.unwrap_err();
assert_eq!(err, "latest");
}
#[test]
fn inexact_pin_in_tool_block_is_unverified_even_when_another_pin_matches() {
let err = versions_in_workflow(
"jobs:\n ci:\n steps:\n - run: cargo binstall --no-confirm oakum@0.0.0\n - uses: taiki-e/install-action\n with:\n tool: |\n oakum@latest\n",
)
.unwrap_err();
assert_eq!(err, "latest");
}
#[test]
fn cargo_install_version_must_belong_to_oakum() {
assert_no_pin("run: cargo install ripgrep --version 0.0.0 && oakum check\n");
}
#[test]
fn env_or_echo_oakum_at_is_not_a_pin() {
assert_no_pin("env:\n OLD: oakum@0.0.0\n");
assert_no_pin("run: echo oakum@0.0.0\n");
assert_no_pin("run: echo cargo binstall oakum@0.0.0\n");
assert_no_pin("OLD: cargo binstall oakum@0.0.0\n");
}
#[test]
fn with_tool_array_is_a_pin() {
let versions = workflow(
"- uses: taiki-e/install-action\n with:\n tool:\n - oakum@0.3.1\n - ripgrep\n",
);
assert_eq!(versions, vec![Version::parse("0.3.1").unwrap()]);
}
#[test]
fn with_install_cmd_string_is_a_pin() {
let versions = workflow(
"- uses: ./local-install\n with:\n install_cmd: cargo binstall --no-confirm oakum@1.4.0\n",
);
assert_eq!(versions, vec![Version::parse("1.4.0").unwrap()]);
}
#[test]
fn with_run_string_is_a_pin() {
let versions = workflow(
"- uses: ./local-install\n with:\n run: cargo binstall --no-confirm oakum@1.5.0\n",
);
assert_eq!(versions, vec![Version::parse("1.5.0").unwrap()]);
}
#[test]
fn with_install_cmd_array_is_a_pin() {
let versions = workflow(
"- uses: ./local-install\n with:\n install_cmd:\n - cargo binstall --no-confirm oakum@1.6.0\n",
);
assert_eq!(versions, vec![Version::parse("1.6.0").unwrap()]);
}
#[test]
fn matrix_install_array_is_a_pin() {
let versions = workflow(
"strategy:\n matrix:\n install:\n - cargo binstall --no-confirm oakum@2.2.0\n",
);
assert_eq!(versions, vec![Version::parse("2.2.0").unwrap()]);
}
#[test]
fn matrix_include_run_key_is_one_pin_not_two() {
let versions = workflow(
"strategy:\n matrix:\n include:\n - run: cargo binstall --no-confirm oakum@2.0.0\n",
);
assert_eq!(versions, vec![Version::parse("2.0.0").unwrap()]);
}
#[test]
fn non_object_with_is_unverified() {
let err = versions_in_workflow(
"- uses: ./local-install\n with: cargo binstall --no-confirm oakum@1.4.0\n",
)
.unwrap_err();
assert_eq!(err, WITH_NOT_OBJECT);
}
#[test]
fn matrix_install_cell_is_a_pin() {
let versions = workflow(
"strategy:\n matrix:\n install: cargo binstall --no-confirm oakum@2.0.0\n",
);
assert_eq!(versions, vec![Version::parse("2.0.0").unwrap()]);
}
#[test]
fn matrix_include_install_cell_is_a_pin() {
let versions = workflow(
"strategy:\n matrix:\n include:\n - install: cargo binstall --no-confirm oakum@2.1.0\n",
);
assert_eq!(versions, vec![Version::parse("2.1.0").unwrap()]);
}
#[test]
fn matrix_tool_key_is_still_a_pin() {
let versions = workflow("strategy:\n matrix:\n tool: oakum@0.3.1\n");
assert_eq!(versions, vec![Version::parse("0.3.1").unwrap()]);
}
#[test]
fn workflow_call_input_default_install_is_a_pin() {
let versions = workflow(
"on:\n workflow_call:\n inputs:\n install:\n type: string\n default: cargo binstall --no-confirm oakum@3.0.0\n",
);
assert_eq!(versions, vec![Version::parse("3.0.0").unwrap()]);
}
#[test]
fn dynamic_matrix_run_expression_alone_is_not_a_pin() {
assert_no_pin("run: ${{ matrix.install }}\n");
}
#[test]
fn install_action_tool_line_is_a_pin() {
let versions = workflow(" tool: oakum@0.3.1\n");
assert_eq!(versions, vec![Version::parse("0.3.1").unwrap()]);
}
#[test]
fn tool_block_scalar_is_a_pin() {
let versions = workflow(" tool: |\n oakum@0.3.1\n");
assert_eq!(versions, vec![Version::parse("0.3.1").unwrap()]);
}
#[test]
fn folded_run_block_is_one_command() {
let versions = workflow("run: >\n cargo install oakum\n --version 0.0.0\n");
assert_eq!(versions, vec![Version::parse("0.0.0").unwrap()]);
}
#[test]
fn every_cargo_install_on_a_line_is_scanned() {
let versions = workflow(
"run: cargo install oakum --version 0.0.0 && cargo install oakum --version 1.2.3\n",
);
assert_eq!(
versions,
vec![
Version::parse("0.0.0").unwrap(),
Version::parse("1.2.3").unwrap()
]
);
}
#[test]
fn unversioned_binstall_is_unverified() {
let err = versions_in_workflow("run: cargo binstall oakum\n").unwrap_err();
assert_eq!(err, "unversioned");
let err = versions_in_workflow(
"jobs:\n ci:\n steps:\n - run: cargo binstall oakum@0.0.0\n - run: cargo binstall oakum\n",
)
.unwrap_err();
assert_eq!(err, "unversioned");
}
#[test]
fn unversioned_install_on_the_same_line_is_unverified() {
let err = versions_in_workflow(
"run: cargo binstall --no-confirm oakum@0.0.0 && cargo binstall oakum\n",
)
.unwrap_err();
assert_eq!(err, "unversioned");
}
#[test]
fn unversioned_tool_line_is_unverified_even_when_another_pin_matches() {
let err = versions_in_workflow(
"jobs:\n ci:\n steps:\n - run: cargo binstall --no-confirm oakum@0.0.0\n - uses: taiki-e/install-action\n with:\n tool: oakum\n",
)
.unwrap_err();
assert_eq!(err, "unversioned");
}
#[test]
fn echo_then_binstall_is_a_pin() {
let versions =
workflow("run: echo installing && cargo binstall --no-confirm oakum@0.0.0\n");
assert_eq!(versions, vec![Version::parse("0.0.0").unwrap()]);
}
#[test]
fn echoed_oakum_at_is_not_a_pin() {
assert_no_pin("run: echo oakum@0.0.0 && cargo binstall --no-confirm ripgrep\n");
}
#[test]
fn unversioned_binstall_target_after_a_pin_is_unverified() {
let err = versions_in_workflow("run: cargo binstall oakum@0.0.0 oakum\n").unwrap_err();
assert_eq!(err, "unversioned");
let err = versions_in_workflow("run: cargo binstall ripgrep oakum\n").unwrap_err();
assert_eq!(err, "unversioned");
let err = versions_in_workflow("run: (cargo binstall oakum@0.0.0 oakum)\n").unwrap_err();
assert_eq!(err, "unversioned");
}
#[test]
fn unversioned_cargo_install_target_after_a_pin_is_unverified() {
let err = versions_in_workflow(
"run: cargo install oakum --version 0.0.0 && cargo install oakum\n",
)
.unwrap_err();
assert_eq!(err, "unversioned");
let err = versions_in_workflow("run: cargo install oakum@0.0.0 oakum\n").unwrap_err();
assert_eq!(err, "unversioned");
let err = versions_in_workflow("run: cargo install ripgrep oakum\n").unwrap_err();
assert_eq!(err, "unversioned");
let versions = workflow("run: cargo install --version 1.2.3 ripgrep oakum\n");
assert_eq!(versions, vec![Version::parse("1.2.3").unwrap()]);
let versions = workflow("run: cargo install ripgrep oakum --version 1.2.3\n");
assert_eq!(versions, vec![Version::parse("1.2.3").unwrap()]);
let err = versions_in_workflow("run: cargo install oakum --version\n").unwrap_err();
assert_eq!(err, "unversioned");
let err = versions_in_workflow(
"run: cargo binstall --no-confirm oakum@0.0.0 && cargo install oakum --versioned\n",
)
.unwrap_err();
assert_eq!(err, "unversioned");
}
#[test]
fn unversioned_tool_entry_after_a_pin_is_unverified() {
let err = versions_in_workflow(" tool: oakum@0.0.0, oakum\n").unwrap_err();
assert_eq!(err, "unversioned");
}
#[test]
fn bare_oakum_invocation_is_not_a_pin() {
assert_no_pin("run: oakum check\n");
}
#[test]
fn not_oakum_at_is_ignored() {
assert_no_pin("run: cargo binstall fake-oakum@1.0.0\n");
}
#[test]
fn range_or_latest_is_unverified() {
let err = versions_in_workflow("run: cargo binstall oakum@latest\n").unwrap_err();
assert_eq!(err, "latest");
let err = versions_in_workflow("run: cargo binstall oakum@^1.0.0\n").unwrap_err();
assert_eq!(err, "^1.0.0");
}
fn scratch(label: &str) -> Fixture {
Fixture::new("pin", label)
}
#[test]
fn package_json_later_section_cannot_hide_an_inexact_pin() {
let root = scratch("pkg-conflict");
std::fs::write(
root.join("package.json"),
r#"{"dependencies":{"oakum":"0.0.0"},"devDependencies":{"oakum":"latest"}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("latest in later section");
assert!(err.to_string().contains("latest"), "{err}");
}
#[test]
fn package_json_peer_section_cannot_hide_an_inexact_pin() {
let root = scratch("pkg-peer");
std::fs::write(
root.join("package.json"),
r#"{"dependencies":{"oakum":"0.0.0"},"peerDependencies":{"oakum":"latest"}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("peer latest");
assert!(err.to_string().contains("latest"), "{err}");
}
#[test]
fn package_json_range_is_not_an_exact_pin() {
let root = scratch("pkg-range");
std::fs::write(
root.join("package.json"),
r#"{"devDependencies":{"oakum":"^0.1.0"}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("range");
assert!(err.to_string().contains("not an exact version"), "{err}");
assert!(err.to_string().contains("^0.1.0"), "{err}");
}
#[test]
fn inexact_pin_is_unverified_even_when_another_pin_matches() {
let root = scratch("latest-and-exact");
std::fs::create_dir_all(root.join(".github/workflows")).unwrap();
std::fs::write(
root.join(".github/workflows/release.yml"),
"run: cargo binstall --no-confirm oakum@0.0.0\n",
)
.unwrap();
std::fs::write(
root.join(".github/workflows/ci.yml"),
"run: cargo binstall --no-confirm oakum@latest\n",
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("latest");
assert!(err.to_string().contains("latest"), "{err}");
assert!(err.to_string().contains("not an exact version"), "{err}");
}
#[test]
fn invalid_workflow_yaml_is_unverified() {
let root = scratch("workflow-invalid-yaml");
std::fs::create_dir_all(root.join(".github/workflows")).unwrap();
std::fs::write(root.join(".github/workflows/ci.yml"), "on: [\n").unwrap();
std::fs::write(
root.join("package.json"),
r#"{"devDependencies":{"oakum":"0.0.0"}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("invalid yaml");
assert!(err.to_string().contains("not valid YAML"), "{err}");
assert!(err.to_string().contains("ci.yml"), "{err}");
}
#[test]
fn unversioned_workflow_message_uses_forward_slashes() {
let root = scratch("unversioned-slash");
std::fs::create_dir_all(root.join(".github/workflows")).unwrap();
std::fs::write(
root.join(".github/workflows/ci.yml"),
"- uses: oakoss/install-action@v1\n with:\n tool: oakum\n",
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("unversioned");
let text = err.to_string();
assert!(
text.contains(".github/workflows/ci.yml"),
"unversioned pin must name the workflow with /: {text}"
);
assert!(
!text.contains(".github/workflows\\ci.yml"),
"unversioned pin must not use a backslash: {text}"
);
}
#[test]
fn invalid_package_json_is_unverified() {
let root = scratch("pkg-invalid");
std::fs::write(root.join("package.json"), "{").unwrap();
std::fs::create_dir_all(root.join(".github/workflows")).unwrap();
std::fs::write(
root.join(".github/workflows/release.yml"),
"run: cargo binstall --no-confirm oakum@0.0.0\n",
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("invalid json");
assert!(err.to_string().contains("not valid JSON"), "{err}");
}
#[test]
fn package_json_exact_pin_is_collected() {
let root = scratch("pkg-exact");
std::fs::write(
root.join("package.json"),
r#"{"devDependencies":{"oakum":"0.4.2"}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let pins = collect_pins(&dir).unwrap();
assert_eq!(pins.len(), 1);
assert_eq!(pins[0].source, PathBuf::from("package.json"));
assert_eq!(pins[0].version, Version::parse("0.4.2").unwrap());
}
#[test]
fn package_json_conflicting_exact_versions_are_unverified() {
let root = scratch("pkg-both-exact");
std::fs::write(
root.join("package.json"),
r#"{"dependencies":{"oakum":"0.0.0"},"devDependencies":{"oakum":"1.0.0"}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("conflicting exacts");
assert!(
err.to_string()
.contains("pins `oakum` as `0.0.0` and `oakum` as `1.0.0`"),
"{err}"
);
}
#[test]
fn package_json_non_string_pin_is_unverified() {
let root = scratch("pkg-object");
std::fs::write(
root.join("package.json"),
r#"{"devDependencies":{"oakum":{"version":"0.0.0"}}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("non-string");
assert!(err.to_string().contains("non-string"), "{err}");
}
#[test]
fn package_json_optional_section_inexact_pin_is_unverified() {
let root = scratch("pkg-optional");
std::fs::write(
root.join("package.json"),
r#"{"optionalDependencies":{"oakum":"latest"}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("optional latest");
assert!(err.to_string().contains("latest"), "{err}");
}
#[test]
fn mise_exact_pin_is_collected() {
let root = scratch("mise-exact");
std::fs::write(root.join(".mise.toml"), "[tools]\noakum = \"0.4.2\"\n").unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let pins = collect_pins(&dir).unwrap();
assert_eq!(pins.len(), 1);
assert_eq!(pins[0].source, PathBuf::from(".mise.toml"));
assert_eq!(pins[0].version, Version::parse("0.4.2").unwrap());
}
#[test]
fn mise_cargo_backend_and_table_form_are_pins() {
let root = scratch("mise-cargo");
std::fs::write(
root.join("mise.toml"),
"[tools]\n\"cargo:oakum\" = { version = \"0.1.0\" }\n",
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let pins = collect_pins(&dir).unwrap();
assert_eq!(pins[0].source, PathBuf::from("mise.toml"));
assert_eq!(pins[0].version, Version::parse("0.1.0").unwrap());
}
#[test]
fn mise_latest_is_unverified() {
let root = scratch("mise-latest");
std::fs::write(root.join(".mise.toml"), "[tools]\noakum = \"latest\"\n").unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("latest");
assert!(err.to_string().contains("latest"), "{err}");
}
#[test]
fn mise_conflicting_files_are_unverified() {
let root = scratch("mise-conflict");
std::fs::write(root.join(".mise.toml"), "[tools]\noakum = \"0.1.0\"\n").unwrap();
std::fs::write(root.join("mise.toml"), "[tools]\noakum = \"0.2.0\"\n").unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("conflict");
assert!(err.to_string().contains("0.1.0"), "{err}");
assert!(err.to_string().contains("0.2.0"), "{err}");
}
#[test]
fn mise_tools_that_is_not_a_table_is_unverified() {
let root = scratch("mise-tools-string");
std::fs::create_dir_all(root.join(".github/workflows")).unwrap();
std::fs::write(
root.join(".github/workflows/release.yml"),
"run: cargo binstall --no-confirm oakum@0.0.0\n",
)
.unwrap();
std::fs::write(root.join(".mise.toml"), "tools = \"oakum@latest\"\n").unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("tools not a table");
assert!(err.to_string().contains("not a table"), "{err}");
}
fn matching_workflow(root: &Path) {
std::fs::create_dir_all(root.join(".github/workflows")).unwrap();
std::fs::write(
root.join(".github/workflows/release.yml"),
"run: cargo binstall --no-confirm oakum@0.0.0\n",
)
.unwrap();
}
#[test]
fn composite_action_run_step_is_a_pin() {
let root = scratch("composite-pin");
std::fs::create_dir_all(root.join(".github/actions/setup-oakum")).unwrap();
std::fs::write(
root.join(".github/actions/setup-oakum/action.yml"),
"runs:\n using: composite\n steps:\n - run: cargo binstall --no-confirm oakum@0.7.0\n shell: bash\n",
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let pins = collect_pins(&dir).unwrap();
assert_eq!(pins.len(), 1);
assert_eq!(
pins[0].source,
PathBuf::from(".github/actions/setup-oakum/action.yml")
);
assert_eq!(pins[0].version, Version::parse("0.7.0").unwrap());
}
#[test]
fn composite_action_yaml_extension_is_a_pin() {
let root = scratch("composite-yaml-ext");
std::fs::create_dir_all(root.join(".github/actions/setup-oakum")).unwrap();
std::fs::write(
root.join(".github/actions/setup-oakum/action.yaml"),
"runs:\n using: composite\n steps:\n - run: cargo binstall --no-confirm oakum@0.8.0\n shell: bash\n",
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let pins = collect_pins(&dir).unwrap();
assert_eq!(pins.len(), 1);
assert_eq!(
pins[0].source,
PathBuf::from(".github/actions/setup-oakum/action.yaml")
);
assert_eq!(pins[0].version, Version::parse("0.8.0").unwrap());
}
#[test]
#[cfg(unix)]
fn composite_action_directory_symlink_is_a_pin() {
let root = scratch("composite-symlink");
std::fs::create_dir_all(root.join("real/setup-oakum")).unwrap();
std::fs::write(
root.join("real/setup-oakum/action.yml"),
"runs:\n using: composite\n steps:\n - run: cargo binstall --no-confirm oakum@0.9.0\n shell: bash\n",
)
.unwrap();
std::fs::create_dir_all(root.join(".github/actions")).unwrap();
std::os::unix::fs::symlink(
"../../real/setup-oakum",
root.join(".github/actions/setup-oakum"),
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let pins = collect_pins(&dir).unwrap();
assert_eq!(pins.len(), 1);
assert_eq!(
pins[0].source,
PathBuf::from(".github/actions/setup-oakum/action.yml")
);
assert_eq!(pins[0].version, Version::parse("0.9.0").unwrap());
}
#[test]
#[cfg(unix)]
fn a_dangling_symlink_at_a_pin_source_is_unverified() {
for (label, parent, link) in [
("dangling-workflows", ".github", ".github/workflows"),
("dangling-actions", ".github", ".github/actions"),
(
"dangling-action-dir",
".github/actions",
".github/actions/setup",
),
(
"dangling-action-yml",
".github/actions/setup",
".github/actions/setup/action.yml",
),
("dangling-mise", "", ".mise.toml"),
("dangling-bare-mise", "", "mise.toml"),
("dangling-package-json", "", "package.json"),
] {
let root = scratch(label);
std::fs::create_dir_all(root.join(parent)).unwrap();
std::os::unix::fs::symlink("nowhere", root.join(link)).unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err(link);
assert_eq!(
err.to_string(),
format!("unverified: `{link}` is a symlink to a missing target"),
"{link}"
);
}
}
#[test]
fn a_root_cargo_toml_that_is_not_a_file_is_unverified() {
let absent = scratch("cargo-absent");
let dir = Dir::open_ambient_dir(&absent, cap_std::ambient_authority()).unwrap();
assert!(!super::cargo_manifest_present(&dir).expect("absent"));
let directory = scratch("cargo-directory");
std::fs::create_dir(directory.join("Cargo.toml")).unwrap();
let dir = Dir::open_ambient_dir(&directory, cap_std::ambient_authority()).unwrap();
let err = super::cargo_manifest_present(&dir).expect_err("directory");
assert_eq!(
err.to_string(),
"unverified: `Cargo.toml` is not a regular file"
);
}
#[test]
#[cfg(unix)]
fn a_dangling_root_cargo_toml_is_unverified() {
let dangling = scratch("cargo-dangling");
std::os::unix::fs::symlink("nowhere", dangling.join("Cargo.toml")).unwrap();
let dir = Dir::open_ambient_dir(&dangling, cap_std::ambient_authority()).unwrap();
let err = super::cargo_manifest_present(&dir).expect_err("dangling");
assert_eq!(
err.to_string(),
"unverified: `Cargo.toml` is a symlink to a missing target"
);
}
#[test]
fn an_unread_cargo_source_does_not_blank_the_others() {
let unread = || Err(crate::cli::CliError::unverified("unverified: cargo"));
let pin = super::FoundPin {
source: PathBuf::from(".mise.toml"),
version: Version::new(9, 9, 9),
};
match super::settle(Ok(vec![pin]), unread()) {
Ok(Some(Pins::Agreed(agreed))) => {
assert_eq!(agreed.version, Version::new(9, 9, 9));
assert!(agreed.cargo_unread.is_some());
}
other => panic!("{other:?}"),
}
let err = super::settle(Ok(Vec::new()), unread()).expect_err("nothing else");
assert_eq!(err.to_string(), "unverified: cargo");
let pin_err = super::agreement(
&super::settle(
Ok(vec![super::FoundPin {
source: PathBuf::from(".mise.toml"),
version: Version::new(9, 9, 9),
}]),
unread(),
),
false,
)
.expect_err("check does not pass an unread source");
assert_eq!(pin_err.to_string(), "unverified: cargo");
let at_binary = super::settle(
Ok(vec![super::FoundPin {
source: PathBuf::from(".mise.toml"),
version: super::binary_version(),
}]),
unread(),
);
assert_eq!(super::standing(&at_binary), super::Standing::Unsettled);
let settled = super::settle(
Ok(vec![super::FoundPin {
source: PathBuf::from(".mise.toml"),
version: super::binary_version(),
}]),
Ok(None),
);
assert_eq!(super::standing(&settled), super::Standing::Settled);
}
#[test]
#[cfg(unix)]
fn a_symlink_to_an_existing_pin_file_is_followed() {
let root = scratch("linked-pin-files");
std::fs::create_dir_all(root.join("real")).unwrap();
std::fs::write(
root.join("real/mise.toml"),
"[tools]\n\"github:oakoss/oakum\" = \"0.9.0\"\n",
)
.unwrap();
std::fs::write(
root.join("real/package.json"),
r#"{"devDependencies":{"@oakoss/oakum":"0.9.0"}}"#,
)
.unwrap();
std::os::unix::fs::symlink("real/mise.toml", root.join(".mise.toml")).unwrap();
std::os::unix::fs::symlink("real/package.json", root.join("package.json")).unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let pins = collect_pins(&dir).unwrap();
let sources: Vec<_> = pins.iter().map(|pin| pin.source.clone()).collect();
assert_eq!(
sources,
[PathBuf::from("package.json"), PathBuf::from(".mise.toml")]
);
}
#[test]
fn invalid_composite_action_yaml_is_unverified() {
let root = scratch("composite-bad-yaml");
matching_workflow(&root);
std::fs::create_dir_all(root.join(".github/actions/broken")).unwrap();
std::fs::write(root.join(".github/actions/broken/action.yml"), "runs: [\n").unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("invalid composite yaml");
assert!(err.to_string().contains("not valid YAML"), "{err}");
assert!(
err.to_string()
.contains(".github/actions/broken/action.yml"),
"{err}"
);
}
#[test]
fn yaml_named_directory_is_unverified() {
let root = scratch("yaml-dir");
matching_workflow(&root);
std::fs::create_dir_all(root.join(".github/workflows/ci.yml")).unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("yaml directory");
assert!(err.to_string().contains("not a file"), "{err}");
}
#[test]
fn package_json_non_object_root_is_unverified() {
let root = scratch("pkg-array");
matching_workflow(&root);
std::fs::write(root.join("package.json"), "[]").unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("array root");
assert!(err.to_string().contains("not a JSON object"), "{err}");
}
#[test]
fn package_json_non_object_section_is_unverified() {
let root = scratch("pkg-section-string");
matching_workflow(&root);
std::fs::write(
root.join("package.json"),
r#"{"devDependencies":"oakum@latest"}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).expect_err("section string");
assert!(err.to_string().contains("not an object"), "{err}");
}
#[test]
fn npm_and_pnpm_install_lines_yield_the_version() {
for line in [
"run: pnpm add -D @oakoss/oakum@1.2.3\n",
"run: pnpm add -D --allow-build=@oakoss/oakum @oakoss/oakum@1.2.3\n",
"run: pnpm add -Dw @oakoss/oakum@1.2.3\n",
"run: npm i -g @oakoss/oakum@1.2.3\n",
"run: npm install --global @oakoss/oakum@1.2.3\n",
"run: npx @oakoss/oakum@1.2.3 check --strict\n",
"run: pnpm dlx @oakoss/oakum@1.2.3 check\n",
"run: pnpm install -g @oakoss/oakum@1.2.3\n",
"run: sudo npm i -g @oakoss/oakum@1.2.3\n",
"run: CI=1 npm i -g @oakoss/oakum@1.2.3 --save-exact\n",
"run: (npm i -g \"@oakoss/oakum@1.2.3\")\n",
"run: npx -y @oakoss/oakum@1.2.3 check\n",
"run: npx --package=@oakoss/oakum@1.2.3 oakum check\n",
"run: npx -p @oakoss/oakum@1.2.3 oakum check\n",
"run: pnpm add -D @oakoss/oakum@1.2.3 @other/oakum@9.9.9\n",
"run: pnpm -w add -D @oakoss/oakum@1.2.3\n",
"run: pnpm --filter demo add -D @oakoss/oakum@1.2.3\n",
"run: npm --prefix . i -g @oakoss/oakum@1.2.3\n",
"run: npm -g i @oakoss/oakum@1.2.3\n",
"run: sudo -E npm i -g @oakoss/oakum@1.2.3\n",
] {
assert_eq!(
versions_in_workflow(line).expect(line),
vec![Version::parse("1.2.3").unwrap()],
"{line}"
);
}
}
#[test]
fn unversioned_npm_install_is_unverified() {
for line in [
"run: pnpm add -D @oakoss/oakum\n",
"run: npm i -g @oakoss/oakum\n",
"run: npx @oakoss/oakum check\n",
"run: pnpm add -D @oakoss/oakum@1.2.3 && npm i -g @oakoss/oakum\n",
"run: pnpm -w add -D @oakoss/oakum\n",
"run: sudo -E npm i -g @oakoss/oakum\n",
] {
assert_eq!(
versions_in_workflow(line).unwrap_err(),
"unversioned",
"{line}"
);
}
}
#[test]
fn npm_dist_tag_is_not_an_exact_pin() {
let err = versions_in_workflow("run: pnpm add -D @oakoss/oakum@latest\n").unwrap_err();
assert_eq!(err, "latest");
}
#[test]
fn npm_invocations_and_other_packages_are_not_pins() {
for line in [
"run: pnpm exec oakum check --strict\n",
"run: pnpm install\n",
"run: pnpm add -D @oakoss/other@1.2.3\n",
"run: pnpm add -D @oakoss/oakum-extra@1.2.3\n",
"run: npm run oakum\n",
"run: npx some-tool @oakoss/oakum@1.2.3\n",
"run: pnpm dlx some-tool @oakoss/oakum\n",
] {
assert_eq!(
versions_in_workflow(line).expect(line),
Vec::new(),
"{line}"
);
}
}
#[test]
fn package_json_scoped_pin_is_collected() {
let root = scratch("npm-scoped");
std::fs::write(
root.join("package.json"),
r#"{"devDependencies":{"@oakoss/oakum":"0.4.2"}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let pins = collect_pins(&dir).unwrap();
assert_eq!(pins.len(), 1);
assert_eq!(pins[0].version, Version::parse("0.4.2").unwrap());
}
#[test]
fn package_json_npm_alias_spec_is_not_an_exact_pin() {
let root = scratch("npm-alias");
std::fs::write(
root.join("package.json"),
r#"{"devDependencies":{"oakum":"npm:@oakoss/oakum@0.4.2"}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).unwrap_err();
assert!(
err.to_string().contains(
"pins `oakum` as `npm:@oakoss/oakum@0.4.2`, which is not an exact version"
),
"{err}"
);
}
#[test]
fn package_json_scoped_and_bare_names_must_agree() {
let root = scratch("npm-both");
std::fs::write(
root.join("package.json"),
r#"{"devDependencies":{"@oakoss/oakum":"0.4.2","oakum":"0.4.3"}}"#,
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let err = collect_pins(&dir).unwrap_err();
assert!(
err.to_string()
.contains("pins `@oakoss/oakum` as `0.4.2` and `oakum` as `0.4.3`"),
"{err}"
);
}
#[test]
fn mise_github_backend_is_a_pin() {
let root = scratch("mise-github");
std::fs::write(
root.join(".mise.toml"),
"[tools]\n\"github:oakoss/oakum\" = \"0.4.2\"\n",
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let pins = collect_pins(&dir).unwrap();
assert_eq!(pins.len(), 1);
assert_eq!(pins[0].version, Version::parse("0.4.2").unwrap());
}
#[test]
fn mise_npm_backend_is_a_pin() {
let root = scratch("mise-npm");
std::fs::write(
root.join(".mise.toml"),
"[tools]\n\"npm:@oakoss/oakum\" = \"0.4.2\"\n",
)
.unwrap();
let dir = Dir::open_ambient_dir(&root, cap_std::ambient_authority()).unwrap();
let pins = collect_pins(&dir).unwrap();
assert_eq!(pins.len(), 1);
assert_eq!(pins[0].version, Version::parse("0.4.2").unwrap());
}
}