-
Notifications
You must be signed in to change notification settings - Fork 744
/
main.rs
110 lines (91 loc) · 2.69 KB
/
main.rs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
use cargo_lock::{Lockfile, Package, Version};
use std::convert::Infallible;
use std::fmt;
use std::path::PathBuf;
use std::process::{Command, Stdio};
use std::str::FromStr;
use thiserror::Error;
#[derive(Debug, Error)]
enum TestError {
#[error("Package \"{name}\" not found in the lockfile")]
NoPackageFound { name: String },
#[error("Package \"{first}\" and \"{second}\" had different versions in the lockfile")]
VersionMismatch { first: PackageId, second: PackageId },
#[error("I/O error: {0}")]
Io(#[from] std::io::Error),
#[error("Error parsing lockfile: {0}")]
Lock(#[from] cargo_lock::Error),
}
impl From<Infallible> for TestError {
fn from(value: Infallible) -> Self {
match value {}
}
}
#[derive(Debug)]
struct PackageId {
name: String,
version: Version,
}
impl PackageId {
fn new(package: &Package) -> Self {
Self {
name: package.name.to_string(),
version: package.version.clone(),
}
}
}
impl fmt::Display for PackageId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"{name}@{version}",
name = self.name,
version = self.version,
)
}
}
fn find_package<'a>(lockfile: &'a Lockfile, package_name: &str) -> Result<&'a Package, TestError> {
lockfile
.packages
.iter()
.find(|package| package.name.as_str() == package_name)
.ok_or_else(|| TestError::NoPackageFound {
name: package_name.to_owned(),
})
}
fn main() {
if let Err(error) = main_inner() {
panic!("{}", error);
}
}
fn main_inner() -> Result<(), TestError> {
let path = PathBuf::from_str(&std::env::args().nth(1).unwrap())?;
Command::new("cargo")
.arg("clean")
.current_dir(&path)
.stdout(Stdio::inherit())
.output()?;
Command::new("cargo")
.arg("update")
.current_dir(&path)
.stdout(Stdio::inherit())
.output()?;
let lockfile = Lockfile::load(path.join("Cargo.lock"))?;
let serde = find_package(&lockfile, "serde")?;
println!("packages should match {id}", id = PackageId::new(&serde));
let package_names = &["serde_derive"];
let packages = package_names
.iter()
.map(|name| find_package(&lockfile, name));
for package in packages {
let package = package?;
println!("discovered package {id}", id = PackageId::new(&package));
if package.version != serde.version {
return Err(TestError::VersionMismatch {
first: PackageId::new(&serde),
second: PackageId::new(&package),
});
}
}
Ok(())
}