use std::collections::BTreeSet;
use std::fmt;
#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct VarvePin {
pub version: String,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ManifestRealm {
pub name: String,
pub channel: String,
pub registry: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Layout {
Tarball,
RawPerPlatform,
Sdk,
}
impl Layout {
fn parse(s: &str) -> Option<Layout> {
match s {
"tarball" => Some(Layout::Tarball),
"raw-per-platform" => Some(Layout::RawPerPlatform),
"sdk" => Some(Layout::Sdk),
_ => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ManifestTool {
pub name: String,
pub version: String,
#[serde(default)]
pub repo: Option<String>,
#[serde(default)]
pub binary: Option<String>,
#[serde(default)]
pub asset: Option<String>,
#[serde(default)]
pub layout: Option<String>,
#[serde(default)]
pub platforms: Option<Vec<String>>,
#[serde(rename = "unverified-reason", default)]
pub unverified_reason: Option<String>,
#[serde(rename = "release", default)]
pub release: Option<String>,
#[serde(rename = "upstream-sums", default)]
pub upstream_sums: Option<String>,
#[serde(rename = "contains", default)]
pub contains: Option<String>,
#[serde(rename = "asset-for", default)]
pub asset_for: std::collections::BTreeMap<String, String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ManifestVsix {
pub name: String,
pub version: String,
#[serde(default)]
pub repo: Option<String>,
pub asset: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum DocsFormat {
Html,
Rustdoc,
Pdf,
Markdown,
Reqif,
}
impl DocsFormat {
pub fn is_tree(self) -> bool {
matches!(self, DocsFormat::Html | DocsFormat::Rustdoc)
}
pub fn file_extension(self) -> Option<&'static str> {
match self {
DocsFormat::Pdf => Some("pdf"),
DocsFormat::Markdown => Some("md"),
DocsFormat::Reqif => Some("reqif"),
DocsFormat::Html | DocsFormat::Rustdoc => None,
}
}
pub fn parse(raw: &str) -> Option<DocsFormat> {
[
DocsFormat::Html,
DocsFormat::Rustdoc,
DocsFormat::Pdf,
DocsFormat::Markdown,
DocsFormat::Reqif,
]
.into_iter()
.find(|f| f.as_str() == raw)
}
pub fn as_str(self) -> &'static str {
match self {
DocsFormat::Html => "html",
DocsFormat::Rustdoc => "rustdoc",
DocsFormat::Pdf => "pdf",
DocsFormat::Markdown => "markdown",
DocsFormat::Reqif => "reqif",
}
}
}
pub fn docs_entry_present(members: &[String], entry: &str) -> bool {
let norm: Vec<&str> = members
.iter()
.map(|m| m.trim_start_matches("./").trim_end_matches('/'))
.filter(|m| !m.is_empty())
.collect();
let mut tops = norm
.iter()
.filter_map(|m| m.split('/').next())
.collect::<std::collections::BTreeSet<_>>();
let wrapper = if tops.len() == 1 {
tops.pop_first().map(|t| format!("{t}/"))
} else {
None
};
let want = entry.trim_start_matches("./");
norm.iter().any(|m| {
let rel = match &wrapper {
Some(w) => m.strip_prefix(w.as_str()).unwrap_or(m),
None => m,
};
rel == want
})
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DocsEntryMissing {
pub entry: String,
pub saw: Vec<String>,
pub members: usize,
}
pub fn check_docs_entry(
members: &[String],
entry: Option<&str>,
is_tree: bool,
) -> Result<(), DocsEntryMissing> {
let Some(want) = entry else { return Ok(()) };
if !is_tree {
return Ok(());
}
if docs_entry_present(members, want) {
return Ok(());
}
let mut saw: Vec<String> = members.iter().take(8).cloned().collect();
saw.sort();
Err(DocsEntryMissing {
entry: want.to_string(),
saw,
members: members.len(),
})
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ManifestDocs {
pub name: String,
pub version: String,
#[serde(default)]
pub repo: Option<String>,
pub format: DocsFormat,
#[serde(default)]
pub entry: Option<String>,
#[serde(default)]
pub title: Option<String>,
#[serde(default)]
pub documents: Option<String>,
pub asset: String,
#[serde(rename = "release", default)]
pub release: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ManifestCrate {
pub name: String,
pub version: String,
#[serde(default)]
pub repo: Option<String>,
#[serde(default)]
pub asset: Option<String>,
#[serde(rename = "release", default)]
pub release: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ManifestInclude {
pub digest: String,
#[serde(default)]
pub realm: Option<String>,
#[serde(default)]
pub layer: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct LayerManifest {
pub varve: VarvePin,
pub realm: ManifestRealm,
#[serde(default, rename = "tool")]
pub tools: Vec<ManifestTool>,
#[serde(default, rename = "vsix")]
pub vsix: Vec<ManifestVsix>,
#[serde(default, rename = "docs")]
pub docs: Vec<ManifestDocs>,
#[serde(default, rename = "crate")]
pub crates: Vec<ManifestCrate>,
#[serde(default, rename = "include")]
pub includes: Vec<ManifestInclude>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum LayerSpecError {
Parse(String),
Unencodable {
field: String,
value: String,
why: &'static str,
},
UnknownLayout { tool: String, layout: String },
BadInclude { digest: String, why: String },
ManyRawPerPlatform { first: String, second: String },
RawPerPlatformNotWsc { tool: String, repo: String },
VsixForeignOwner { name: String, repo: String },
RepoNameMismatch {
name: String,
repo: String,
basename: String,
},
Duplicate { kind: &'static str, name: String },
LayoutNotEncodable { tool: String, layout: String },
ReleaseNeedsBinaryAndAsset { tool: String },
UpstreamSumsNotEncodable { tool: String, asset: String },
PlatformsNotEncodable {
tool: String,
platforms: Vec<String>,
},
UnverifiedWithoutReason { tool: String },
ReasonIsAboutAnotherRelease {
tool: String,
pinned: String,
reason: String,
},
ConflictingReason {
repo: String,
first: String,
second: String,
},
Empty,
}
impl fmt::Display for LayerSpecError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
LayerSpecError::Parse(e) => write!(f, "layer.toml does not parse: {e}"),
LayerSpecError::Unencodable { field, value, why } => write!(
f,
"{field} = {value:?} cannot be passed to the assembler: {why}. \
The assembler reads space-separated entries of colon-separated \
fields, so such a value would be split or truncated silently \
and the layer would carry the wrong bytes under a good signature."
),
LayerSpecError::UnknownLayout { tool, layout } => write!(
f,
"tool {tool:?} declares layout = {layout:?}, which varve does not \
implement. Use \"tarball\" (one .tar.gz per target triple) or \
\"raw-per-platform\" (bare per-platform binaries)."
),
LayerSpecError::BadInclude { digest, why } => {
write!(f, "[[include]] {digest:?} cannot be used: {why}.")
}
LayerSpecError::ManyRawPerPlatform { first, second } => write!(
f,
"tools {first:?} and {second:?} both declare \
layout = \"raw-per-platform\", and the assembler carries only \
one (as WSC_VERSION). Depositing would silently drop one of \
them. Teach the assembler a general raw-per-platform list \
before adding the second."
),
LayerSpecError::RawPerPlatformNotWsc { tool, repo } => write!(
f,
"tool {tool:?} from {repo:?} declares \
layout = \"raw-per-platform\", but the assembler's only slot \
for that layout is hardcoded to fetch `wsc` from \
`pulseengine/sigil` — it would emit WSC_VERSION and download \
the wrong tool, from the wrong repository, at this tool's \
version, and deposit it under the wrong name. Teach the \
assembler a general raw-per-platform list before carrying \
this."
),
LayerSpecError::VsixForeignOwner { name, repo } => write!(
f,
"vsix {name:?} names repo {repo:?}, but the assembler resolves \
extension repositories as pulseengine/<name> and would fetch \
the wrong release. Either publish it under pulseengine, or \
teach the assembler an owner field for extensions."
),
LayerSpecError::RepoNameMismatch {
name,
repo,
basename,
} => write!(
f,
"tool {name:?} names repo {repo:?}, but the assembler takes a \
tarball tool's identity from the repository basename — it \
would download, name the payload, and default the asset \
template as {basename:?}, and {name:?} would mean nothing. A \
consumer asking for {name:?} would then find no such tool in \
a layer that deposited and verified. Rename the entry to \
{basename:?}, or set `binary` if only the executable differs."
),
LayerSpecError::UpstreamSumsNotEncodable { tool, asset } => write!(
f,
"tool {tool:?} declares upstream-sums {asset:?}, which the \
environment encoding cannot express. Dropping it would not \
lose a hint: it is the MECHANISM that vouches for the \
release, so the shell assembler would look for a cosign \
bundle and an attestation, find neither, and ingest the \
payload with no proof at all — while every other field \
survives the trip and the entry looks ordinary.\n\n\
Deposit this realm with `varve-producer deposit --manifest \
layer.toml`, which reads the mechanism directly."
),
LayerSpecError::PlatformsNotEncodable { tool, platforms } => write!(
f,
"tool {tool:?} is carried for {} only, and the env encoding \
has no field for that.\n\
Translating it away does not rename anything — it CARRIES THE \
TOOL ON PLATFORMS THE REALM EXCLUDED, and those are the \
platforms where the payload cannot work. binaryen's macOS \
build is the case this exists for: a 1.7 MB stub needing a \
dylib a single-executable payload cannot carry, so the layer \
would install, verify, and fail at the first exec.\n\
Deposit this realm with `varve-producer deposit --manifest \
layer.toml`, which reads the restriction directly.",
platforms.join(", ")
),
LayerSpecError::LayoutNotEncodable { tool, layout } => write!(
f,
"tool {tool:?} declares layout {layout:?}, which the environment \
encoding cannot express — it has fields for a repository, a \
version, a binary, an asset template and a payload version, \
and none for a LAYOUT. Translating would emit an ordinary \
tarball entry, and the shell assembler would mine the tree for \
a binary and destroy it, silently, because every other field \
survives the trip.\n\n\
Deposit this realm with `varve-producer deposit --manifest \
layer.toml`, which reads the layout directly. See `varve docs \
sdk`."
),
LayerSpecError::ReleaseNeedsBinaryAndAsset { tool } => write!(
f,
"tool {tool:?} sets `release` separately from `version`, which \
the environment encoding carries in its FIFTH positional \
field — so `binary` and `asset` must be set too, because a \
positional field cannot be skipped. Set them explicitly, or \
drop `release` if the tag and the version are the same."
),
LayerSpecError::Duplicate { kind, name } => {
write!(f, "two {kind} entries are both named {name:?}")
}
LayerSpecError::UnverifiedWithoutReason { tool } => write!(
f,
"tool {tool:?} sets an empty `unverified-reason`. \"We could \
not verify this\" must never be the silent path: the reason \
is what travels with the bytes into the signed layer, where \
every consumer reads it. Say why this is acceptable and what \
removes the need, or do not carry the tool."
),
LayerSpecError::ReasonIsAboutAnotherRelease {
tool,
pinned,
reason,
} => write!(
f,
"tool {tool:?} is pinned at {pinned} and its `unverified-reason` \
never mentions {pinned}: {reason:?}\n\nA reason for carrying \
unverified bytes is a MEASUREMENT of one release — who published \
it, what they did not sign, and when that was checked. It does \
not carry forward to the next release by itself, and the usual \
way to arrive here is a scanner bumping the version while the \
justification stayed behind. Re-check {pinned} upstream and say \
what you found; if it now publishes sums or provenance, drop \
the opt-in instead."
),
LayerSpecError::ConflictingReason {
repo,
first,
second,
} => write!(
f,
"two tools from {repo:?} give different reasons for ingesting \
it unverified:\n {first:?}\n {second:?}\nThe opt-in is per \
RELEASE, not per tool, so one of these would be recorded and \
the other silently discarded. Give the repository one reason."
),
LayerSpecError::Empty => write!(
f,
"layer.toml declares no [[tool]] and no [[vsix]]: there is \
nothing to deposit. A layer with no payloads is signed, \
published, and useless."
),
}
}
}
impl std::error::Error for LayerSpecError {}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AssemblerEnv {
pub layer_tools: String,
pub wsc_version: Option<String>,
pub vsix_packages: String,
pub realm: String,
pub channel: String,
pub registry: String,
pub varve_version: String,
pub unverified_ingest: Vec<(String, String)>,
}
impl AssemblerEnv {
pub fn render(&self) -> String {
let mut out = String::new();
out.push_str(&format!("TARBALL_TOOLS={}\n", self.layer_tools));
out.push_str(&format!(
"WSC_VERSION={}\n",
self.wsc_version.as_deref().unwrap_or("")
));
out.push_str(&format!("VSIX_PACKAGES={}\n", self.vsix_packages));
out.push_str(&format!("VARVE_REALM={}\n", self.realm));
out.push_str(&format!("VARVE_CHANNEL={}\n", self.channel));
out.push_str(&format!("VARVE_REGISTRY={}\n", self.registry));
out.push_str(&format!("VARVE_VERSION={}\n", self.varve_version));
if !self.unverified_ingest.is_empty() {
let body: String = self
.unverified_ingest
.iter()
.map(|(repo, why)| format!("{repo}={why}\n"))
.collect();
let mut delim = String::from("VARVE_UNVERIFIED_EOF");
while body.contains(&delim) {
delim.push('_');
}
out.push_str(&format!("UNVERIFIED_INGEST<<{delim}\n{body}{delim}\n"));
}
out
}
}
pub fn parse_layer_manifest(text: &str) -> Result<LayerManifest, LayerSpecError> {
let manifest: LayerManifest =
toml::from_str(text).map_err(|e| LayerSpecError::Parse(e.to_string()))?;
check_includes(&manifest.includes)?;
check_unverified(&manifest.tools)?;
Ok(manifest)
}
fn check_unverified(tools: &[ManifestTool]) -> Result<(), LayerSpecError> {
let mut seen: Vec<(String, String)> = Vec::new();
for t in tools {
let Some(why) = &t.unverified_reason else {
continue;
};
let why = why.trim();
if why.is_empty() {
return Err(LayerSpecError::UnverifiedWithoutReason {
tool: t.name.clone(),
});
}
if !t
.release
.iter()
.chain(std::iter::once(&t.version))
.any(|v| why.contains(v.as_str()))
{
return Err(LayerSpecError::ReasonIsAboutAnotherRelease {
tool: t.name.clone(),
pinned: t.release.clone().unwrap_or_else(|| t.version.clone()),
reason: why.to_string(),
});
}
let full = match &t.repo {
Some(r) => r.clone(),
None => format!("pulseengine/{}", t.name),
};
if let Some((_, prev)) = seen.iter().find(|(r, _)| *r == full) {
if prev != why {
return Err(LayerSpecError::ConflictingReason {
repo: full,
first: prev.clone(),
second: why.to_string(),
});
}
} else {
seen.push((full, why.to_string()));
}
}
Ok(())
}
fn check_includes(includes: &[ManifestInclude]) -> Result<(), LayerSpecError> {
for i in includes {
let hex = i.digest.strip_prefix("sha256:").unwrap_or("");
if hex.len() != 64 || !hex.chars().all(|c| c.is_ascii_hexdigit()) {
return Err(LayerSpecError::BadInclude {
digest: i.digest.clone(),
why: "a composition names the included layer by the digest of its SIGNED \
MANIFEST — `sha256:` and 64 hex characters. A tag or a layer id would \
let the composition drift after signing, which is the one thing an \
include exists to prevent"
.to_string(),
});
}
if i.realm.as_deref().unwrap_or("").trim().is_empty() {
return Err(LayerSpecError::BadInclude {
digest: i.digest.clone(),
why: "no `realm`. Nothing then writes an include.realm annotation, so verify \
falls back to the PINNING project's trust root: the layer installs and \
fails verification afterwards with nothing tampered, or — if the two \
roots happen to match — verifies while widening trust across a realm \
boundary. Name the realm whose root verifies the included layer"
.to_string(),
});
}
}
Ok(())
}
fn encodable(field: &str, value: &str) -> Result<(), LayerSpecError> {
let unencodable = |why| LayerSpecError::Unencodable {
field: field.to_string(),
value: value.to_string(),
why,
};
if value.is_empty() {
return Err(unencodable("it is empty"));
}
if value.contains(':') {
return Err(unencodable("it contains ':', which separates fields"));
}
if value.chars().any(char::is_whitespace) {
return Err(unencodable(
"it contains whitespace, which separates entries",
));
}
Ok(())
}
fn split_repo(repo: &str, default_name: &str) -> (String, String) {
match repo.split_once('/') {
Some((owner, name)) => (owner.to_string(), name.to_string()),
None => ("pulseengine".to_string(), default_name.to_string()),
}
}
pub fn assembler_env(m: &LayerManifest) -> Result<AssemblerEnv, LayerSpecError> {
if m.tools.is_empty() && m.vsix.is_empty() {
return Err(LayerSpecError::Empty);
}
encodable("realm.name", &m.realm.name)?;
encodable("realm.channel", &m.realm.channel)?;
encodable("varve.version", &m.varve.version)?;
let mut unverified: Vec<(String, String)> = Vec::new();
let mut tarballs: Vec<String> = Vec::new();
let mut wsc_version: Option<String> = None;
let mut raw_owner: Option<String> = None;
let mut seen_tools: BTreeSet<&str> = BTreeSet::new();
for t in &m.tools {
encodable("tool.name", &t.name)?;
encodable("tool.version", &t.version)?;
if !seen_tools.insert(t.name.as_str()) {
return Err(LayerSpecError::Duplicate {
kind: "tool",
name: t.name.clone(),
});
}
let layout = match t.layout.as_deref() {
None => Layout::Tarball,
Some(s) => Layout::parse(s).ok_or_else(|| LayerSpecError::UnknownLayout {
tool: t.name.clone(),
layout: s.to_string(),
})?,
};
if layout == Layout::Sdk {
return Err(LayerSpecError::LayoutNotEncodable {
tool: t.name.clone(),
layout: "sdk".into(),
});
}
if let Some(sums) = &t.upstream_sums {
return Err(LayerSpecError::UpstreamSumsNotEncodable {
tool: t.name.clone(),
asset: sums.clone(),
});
}
if let Some(only) = &t.platforms {
return Err(LayerSpecError::PlatformsNotEncodable {
tool: t.name.clone(),
platforms: only.clone(),
});
}
if let Some(why) = &t.unverified_reason {
let why = why.trim();
let full = match &t.repo {
Some(r) => r.clone(),
None => format!("pulseengine/{}", t.name),
};
if !unverified.iter().any(|(r, _)| *r == full) {
unverified.push((full, why.to_string()));
}
}
let (owner, repo_name) = match &t.repo {
Some(r) => {
encodable("tool.repo", r)?;
split_repo(r, &t.name)
}
None => ("pulseengine".to_string(), t.name.clone()),
};
if layout == Layout::RawPerPlatform {
if let Some(first) = &raw_owner {
return Err(LayerSpecError::ManyRawPerPlatform {
first: first.clone(),
second: t.name.clone(),
});
}
if t.name != "wsc" || owner != "pulseengine" || repo_name != "sigil" {
return Err(LayerSpecError::RawPerPlatformNotWsc {
tool: t.name.clone(),
repo: format!("{owner}/{repo_name}"),
});
}
raw_owner = Some(t.name.clone());
wsc_version = Some(t.version.clone());
continue;
}
if repo_name != t.name && t.binary.is_none() {
return Err(LayerSpecError::RepoNameMismatch {
name: t.name.clone(),
repo: t.repo.clone().unwrap_or_else(|| repo_name.clone()),
basename: repo_name.clone(),
});
}
let head = if owner == "pulseengine" && repo_name == t.name {
t.name.clone()
} else {
format!("{owner}/{repo_name}")
};
let fetch_tag = t.release.as_deref().unwrap_or(&t.version);
let mut entry = format!("{head}:{fetch_tag}");
match (&t.binary, &t.asset) {
(None, None) => {}
(Some(b), None) => {
encodable("tool.binary", b)?;
entry.push(':');
entry.push_str(b);
}
(b, Some(a)) => {
encodable("tool.asset", a)?;
let bin = b.clone().unwrap_or_else(|| t.name.clone());
encodable("tool.binary", &bin)?;
entry.push(':');
entry.push_str(&bin);
entry.push(':');
entry.push_str(a);
}
}
if t.release.is_some() {
if t.binary.is_none() || t.asset.is_none() {
return Err(LayerSpecError::ReleaseNeedsBinaryAndAsset {
tool: t.name.clone(),
});
}
entry.push(':');
entry.push_str(t.version.trim_start_matches('v'));
}
tarballs.push(entry);
}
let mut vsix_entries: Vec<String> = Vec::new();
let mut seen_vsix: BTreeSet<&str> = BTreeSet::new();
for v in &m.vsix {
encodable("vsix.name", &v.name)?;
encodable("vsix.version", &v.version)?;
encodable("vsix.asset", &v.asset)?;
if !seen_vsix.insert(v.name.as_str()) {
return Err(LayerSpecError::Duplicate {
kind: "vsix",
name: v.name.clone(),
});
}
let repo_name = match &v.repo {
Some(r) => {
encodable("vsix.repo", r)?;
let (owner, name) = split_repo(r, &v.name);
if owner != "pulseengine" {
return Err(LayerSpecError::VsixForeignOwner {
name: v.name.clone(),
repo: r.clone(),
});
}
name
}
None => v.name.clone(),
};
vsix_entries.push(format!("{repo_name}:{}:{}:{}", v.version, v.name, v.asset));
}
Ok(AssemblerEnv {
layer_tools: tarballs.join(" "),
wsc_version,
vsix_packages: vsix_entries.join(" "),
realm: m.realm.name.clone(),
channel: m.realm.channel.clone(),
registry: m.realm.registry.clone(),
varve_version: m.varve.version.clone(),
unverified_ingest: unverified,
})
}
#[cfg(test)]
mod tests {
use super::*;
const REAL: &str = r#"
[varve]
version = "v0.28.0"
[realm]
name = "pulseengine"
channel = "rolling"
registry = "oci://ghcr.io/pulseengine/layers"
[[tool]]
name = "rivet"
version = "v0.34.0"
[[tool]]
name = "kiln"
version = "v0.4.4"
binary = "kilnd"
[[tool]]
name = "wsc"
repo = "pulseengine/sigil"
version = "v0.11.0"
layout = "raw-per-platform"
[[vsix]]
name = "rivet-sdlc"
repo = "pulseengine/rivet"
version = "v0.34.0"
asset = "rivet-sdlc-%V.vsix"
[[vsix]]
name = "spar-aadl"
repo = "pulseengine/spar"
version = "v0.40.0"
asset = "spar-aadl-%P-%V.vsix"
"#;
fn env_of(text: &str) -> AssemblerEnv {
assembler_env(&parse_layer_manifest(text).expect("parses")).expect("converts")
}
#[test]
fn a_plain_tool_becomes_name_and_version() {
assert!(env_of(REAL).layer_tools.starts_with("rivet:v0.34.0 "));
}
#[test]
fn a_differing_binary_name_is_carried_as_the_third_field() {
assert!(env_of(REAL).layer_tools.contains("kiln:v0.4.4:kilnd"));
}
#[test]
fn the_raw_per_platform_tool_becomes_wsc_version_and_not_a_tarball() {
let e = env_of(REAL);
assert_eq!(e.wsc_version.as_deref(), Some("v0.11.0"));
assert!(!e.layer_tools.contains("wsc"), "{}", e.layer_tools);
assert!(!e.layer_tools.contains("sigil"), "{}", e.layer_tools);
}
#[test]
fn vsix_entries_drop_the_default_owner_the_assembler_re_adds() {
let e = env_of(REAL);
assert_eq!(
e.vsix_packages,
"rivet:v0.34.0:rivet-sdlc:rivet-sdlc-%V.vsix \
spar:v0.40.0:spar-aadl:spar-aadl-%P-%V.vsix"
);
}
#[test]
fn a_mistyped_key_is_refused_rather_than_ignored() {
let text = REAL.replace("name = \"rivet\"", "nmae = \"rivet\"");
let err = parse_layer_manifest(&text).unwrap_err();
assert!(
matches!(&err, LayerSpecError::Parse(m) if m.contains("nmae")),
"{err}"
);
}
#[test]
fn an_unknown_layout_is_refused_and_names_the_two_that_work() {
let text = REAL.replace("raw-per-platform", "zipfile");
let err = assembler_env(&parse_layer_manifest(&text).unwrap()).unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("zipfile") && msg.contains("raw-per-platform"),
"{msg}"
);
}
#[test]
fn a_second_raw_per_platform_tool_is_refused_rather_than_dropped() {
let text = format!(
"{REAL}\n[[tool]]\nname = \"other\"\nversion = \"v1.0.0\"\nlayout = \"raw-per-platform\"\n"
);
let err = assembler_env(&parse_layer_manifest(&text).unwrap()).unwrap_err();
assert_eq!(
err,
LayerSpecError::ManyRawPerPlatform {
first: "wsc".into(),
second: "other".into()
}
);
}
#[test]
fn a_raw_per_platform_tool_that_is_not_wsc_is_refused() {
let text = format!(
"{REAL}\n[[tool]]\nname = \"wac\"\nrepo = \"bytecodealliance/wac\"\n\
version = \"v0.10.1\"\nlayout = \"raw-per-platform\"\n"
);
let only = text.replace(
"[[tool]]\nname = \"wsc\"\nrepo = \"pulseengine/sigil\"\nversion = \"v0.11.0\"\nlayout = \"raw-per-platform\"\n",
"",
);
assert!(!only.contains("wsc"), "the wsc block must be gone: {only}");
let err = assembler_env(&parse_layer_manifest(&only).unwrap()).unwrap_err();
assert_eq!(
err,
LayerSpecError::RawPerPlatformNotWsc {
tool: "wac".into(),
repo: "bytecodealliance/wac".into()
},
"{err}"
);
assert!(err.to_string().contains("wrong repository"), "{err}");
}
#[test]
fn the_wsc_slot_rejects_a_tool_that_differs_in_any_single_field() {
let base = REAL.replace(
"[[tool]]\nname = \"wsc\"\nrepo = \"pulseengine/sigil\"\nversion = \"v0.11.0\"\nlayout = \"raw-per-platform\"\n",
"",
);
for (name, repo, what) in [
("wsc", "acme/sigil", "a different OWNER"),
("wsc", "pulseengine/other", "a different REPOSITORY"),
("other", "pulseengine/sigil", "a different TOOL NAME"),
] {
let text = format!(
"{base}\n[[tool]]\nname = \"{name}\"\nrepo = \"{repo}\"\n\
version = \"v1.0.0\"\nlayout = \"raw-per-platform\"\n"
);
let err = assembler_env(&parse_layer_manifest(&text).unwrap()).expect_err(what);
assert!(
matches!(err, LayerSpecError::RawPerPlatformNotWsc { .. }),
"{what} ({name} from {repo}) was not refused as a wsc-slot \
mismatch: {err:?}"
);
}
}
#[test]
fn a_foreign_owner_on_an_extension_is_refused() {
let text = REAL.replace(
"repo = \"pulseengine/rivet\"",
"repo = \"acme/rivet\"",
);
let err = assembler_env(&parse_layer_manifest(&text).unwrap()).unwrap_err();
assert_eq!(
err,
LayerSpecError::VsixForeignOwner {
name: "rivet-sdlc".into(),
repo: "acme/rivet".into()
}
);
}
#[test]
fn a_value_carrying_a_separator_is_refused() {
for (bad, why) in [("v1.0 rc1", "whitespace"), ("v1.0:rc1", "':'")] {
let text = REAL.replace("v0.34.0\"\n\n[[tool]]", &format!("{bad}\"\n\n[[tool]]"));
let err = assembler_env(&parse_layer_manifest(&text).unwrap()).unwrap_err();
let msg = err.to_string();
assert!(msg.contains(why), "{bad}: {msg}");
}
}
#[test]
fn an_explicit_tarball_layout_means_the_same_as_omitting_it() {
let explicit = REAL.replace(
"name = \"rivet\"\nversion = \"v0.34.0\"",
"name = \"rivet\"\nversion = \"v0.34.0\"\nlayout = \"tarball\"",
);
assert_ne!(explicit, REAL, "the fixture substitution must apply");
assert_eq!(env_of(&explicit).layer_tools, env_of(REAL).layer_tools);
}
#[test]
fn a_foreign_owner_is_carried_as_a_qualified_repository() {
let text = format!(
"{REAL}\n[[tool]]\nname = \"wasm-tools\"\nrepo = \"bytecodealliance/wasm-tools\"\nversion = \"v1.257.1\"\n"
);
assert!(
env_of(&text)
.layer_tools
.contains("bytecodealliance/wasm-tools:v1.257.1"),
"{}",
env_of(&text).layer_tools
);
}
#[test]
fn a_tool_whose_repo_basename_disagrees_with_its_name_is_refused() {
let text = format!(
"{REAL}\n[[tool]]\nname = \"wsc2\"\nrepo = \"pulseengine/sigil\"\nversion = \"v0.11.0\"\n"
);
let err = assembler_env(&parse_layer_manifest(&text).unwrap()).unwrap_err();
assert_eq!(
err,
LayerSpecError::RepoNameMismatch {
name: "wsc2".into(),
repo: "pulseengine/sigil".into(),
basename: "sigil".into(),
},
"{err}"
);
}
#[test]
fn two_tools_of_one_name_are_refused() {
let text = format!("{REAL}\n[[tool]]\nname = \"rivet\"\nversion = \"v0.1.0\"\n");
let err = assembler_env(&parse_layer_manifest(&text).unwrap()).unwrap_err();
assert_eq!(
err,
LayerSpecError::Duplicate {
kind: "tool",
name: "rivet".into()
}
);
}
#[test]
fn an_unverified_reason_reaches_the_assembler_intact() {
let text = format!(
"{REAL}\n[[tool]]\nname = \"wac\"\nrepo = \"bytecodealliance/wac\"\n\
version = \"v0.10.1\"\nunverified-reason = \"v0.10.1 publishes no sums, \
no cosign bundle and no attestation; tracked upstream, re-check each cut\"\n"
);
let env = env_of(&text);
assert_eq!(env.unverified_ingest.len(), 1);
assert_eq!(env.unverified_ingest[0].0, "bytecodealliance/wac");
assert!(env.unverified_ingest[0].1.contains("re-check each cut"));
let r = env.render();
assert!(r.contains("UNVERIFIED_INGEST<<"), "{r}");
assert!(
r.contains("bytecodealliance/wac=v0.10.1 publishes no sums"),
"{r}"
);
}
#[test]
fn a_reason_containing_the_delimiter_cannot_close_the_block_early() {
let text = format!(
"{REAL}\n[[tool]]\nname = \"wac\"\nrepo = \"bytecodealliance/wac\"\n\
version = \"v0.10.1\"\nunverified-reason = \"v0.10.1 VARVE_UNVERIFIED_EOF\\nPATH=/evil\"\n"
);
let r = env_of(&text).render();
let opened = r
.lines()
.find(|l| l.starts_with("UNVERIFIED_INGEST<<"))
.expect("heredoc opened");
let delim = opened.trim_start_matches("UNVERIFIED_INGEST<<");
let body = r.split(&format!("<<{delim}\n")).nth(1).expect("body");
let body = body.split(&format!("\n{delim}")).next().expect("closes");
assert!(
!body.contains(delim),
"delimiter occurs inside its own body"
);
assert!(
body.contains("PATH=/evil"),
"the reason must survive verbatim"
);
}
#[test]
fn a_reason_measuring_another_release_is_refused() {
let reason = "wac v0.11.0 publishes neither cosign-signed sums nor build \
provenance (measured 2026-09-18)";
let bumped = format!(
"{REAL}\n[[tool]]\nname = \"wac\"\nrepo = \"bytecodealliance/wac\"\n\
version = \"v0.12.0\"\nunverified-reason = \"{reason}\"\n"
);
let err = parse_layer_manifest(&bumped).unwrap_err();
assert_eq!(
err,
LayerSpecError::ReasonIsAboutAnotherRelease {
tool: "wac".into(),
pinned: "v0.12.0".into(),
reason: reason.to_string(),
},
"{err}"
);
assert!(format!("{err}").contains("v0.12.0"), "{err}");
let remeasured = bumped.replace("v0.11.0 publishes", "v0.12.0 publishes");
parse_layer_manifest(&remeasured).expect("a current measurement parses");
assert_eq!(env_of(&remeasured).unverified_ingest.len(), 1);
}
#[test]
fn a_reason_may_name_the_release_or_the_version() {
for names in ["r2026.1", "v9.9.9"] {
let text = format!(
"{REAL}\n[[tool]]\nname = \"wac\"\nrepo = \"bytecodealliance/wac\"\n\
version = \"v9.9.9\"\nrelease = \"r2026.1\"\nbinary = \"wac\"\n\
asset = \"wac-%T\"\nunverified-reason = \"{names}: nothing signed\"\n"
);
assert_eq!(
env_of(&text).unverified_ingest.len(),
1,
"a reason naming {names} was refused"
);
}
}
#[test]
fn an_empty_unverified_reason_is_refused() {
for bad in ["\"\"", "\" \""] {
let text = format!(
"{REAL}\n[[tool]]\nname = \"wac\"\nversion = \"v1\"\nunverified-reason = {bad}\n"
);
let err = parse_layer_manifest(&text).unwrap_err();
assert_eq!(
err,
LayerSpecError::UnverifiedWithoutReason { tool: "wac".into() },
"{bad}"
);
}
}
#[test]
fn two_tools_from_one_repo_must_agree_on_the_reason() {
let text = REAL.replace(
"layout = \"raw-per-platform\"",
"layout = \"raw-per-platform\"\nunverified-reason = \"v0.11.0 first\"",
) + "\n[[tool]]\nname = \"sigil\"\nrepo = \"pulseengine/sigil\"\nversion = \"v0.11.0\"\n\
unverified-reason = \"v0.11.0 second\"\n";
let err = parse_layer_manifest(&text).unwrap_err();
assert!(
matches!(err, LayerSpecError::ConflictingReason { .. }),
"{err:?}"
);
let ok = text.replace("\"v0.11.0 second\"", "\"v0.11.0 first\"");
assert_eq!(env_of(&ok).unverified_ingest.len(), 1);
}
#[test]
fn a_manifest_with_nothing_unverified_emits_no_opt_in() {
let r = env_of(REAL).render();
assert!(!r.contains("UNVERIFIED_INGEST"), "{r}");
}
#[test]
fn a_manifest_with_no_payloads_is_refused() {
let text = "[varve]\nversion = \"v0.28.0\"\n\n[realm]\nname = \"p\"\nchannel = \"rolling\"\nregistry = \"oci://x\"\n";
assert_eq!(
assembler_env(&parse_layer_manifest(text).unwrap()).unwrap_err(),
LayerSpecError::Empty
);
}
#[test]
fn a_layer_with_no_extensions_still_sets_the_variable() {
let text = REAL
.split("[[vsix]]")
.next()
.expect("has a tools section")
.to_string();
let rendered = env_of(&text).render();
assert!(rendered.contains("\nVSIX_PACKAGES=\n"), "{rendered}");
}
#[test]
fn render_emits_one_key_per_line_in_a_stable_order() {
let rendered = env_of(REAL).render();
let keys: Vec<&str> = rendered
.lines()
.map(|l| l.split('=').next().unwrap_or(""))
.collect();
assert_eq!(
keys,
[
"TARBALL_TOOLS",
"WSC_VERSION",
"VSIX_PACKAGES",
"VARVE_REALM",
"VARVE_CHANNEL",
"VARVE_REGISTRY",
"VARVE_VERSION"
]
);
}
#[test]
fn an_include_without_a_realm_is_refused_where_it_is_written() {
let text = format!(
"{}\n[[include]]\ndigest = \"sha256:{}\"\n",
REAL,
"a".repeat(64)
);
let e = parse_layer_manifest(&text).expect_err("must refuse");
let msg = e.to_string();
assert!(matches!(e, LayerSpecError::BadInclude { .. }), "{e:?}");
assert!(msg.contains("realm"), "{msg}");
assert!(
msg.contains("widening trust") || msg.contains("widening"),
"{msg}"
);
}
#[test]
fn an_include_must_name_a_manifest_digest_not_a_version() {
for bad in ["2026.09.4", "v0.36.0", "sha256:abc", "sha256:", ""] {
let text = format!("{REAL}\n[[include]]\ndigest = \"{bad}\"\nrealm = \"r\"\n");
let e = parse_layer_manifest(&text)
.expect_err(&format!("{bad:?} must be refused as a digest"));
assert!(
matches!(e, LayerSpecError::BadInclude { .. }),
"{bad:?}: {e:?}"
);
}
}
#[test]
fn a_well_formed_include_parses_with_its_realm_and_layer() {
let text = format!(
"{}\n[[include]]\ndigest = \"sha256:{}\"\nrealm = \"pulseengine\"\nlayer = \"2026.09.4\"\n",
REAL,
"b".repeat(64)
);
let m = parse_layer_manifest(&text).expect("parses");
assert_eq!(m.includes.len(), 1);
assert_eq!(m.includes[0].realm.as_deref(), Some("pulseengine"));
assert_eq!(m.includes[0].layer.as_deref(), Some("2026.09.4"));
}
}
#[cfg(test)]
mod payload_identity_tests {
use super::*;
fn env_of(text: &str) -> Result<AssemblerEnv, LayerSpecError> {
assembler_env(&parse_layer_manifest(text).expect("parses"))
}
const HEAD: &str = "[varve]\nversion = \"v0.33.0\"\n[realm]\nname=\"pulseengine\"\n\
channel=\"rolling\"\nregistry=\"oci://x/y\"\n";
#[test]
fn one_repository_can_contribute_more_than_one_payload() {
let env = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"with-device\"\nrepo=\"pulseengine/jess\"\n\
binary=\"with-device\"\nversion=\"v0.7.2\"\nasset=\"with-device-0.2.2-%T.tar.gz\"\n\
\n[[tool]]\nname=\"bench-report\"\nrepo=\"pulseengine/jess\"\nbinary=\"bench-report\"\n\
version=\"v0.7.2\"\nasset=\"bench-report-0.1.0-%T.tar.gz\"\n"
))
.expect("two payloads from one repository must be expressible");
assert_eq!(env.layer_tools.split(' ').count(), 2, "{}", env.layer_tools);
}
#[test]
fn a_payload_named_differently_from_its_repo_still_names_its_repo() {
let env = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"with-device\"\nrepo=\"pulseengine/jess\"\n\
binary=\"with-device\"\nversion=\"v0.7.2\"\nasset=\"w-%T.tar.gz\"\n"
))
.expect("parses");
assert!(
env.layer_tools.starts_with("pulseengine/jess:"),
"the repository was lost: {}",
env.layer_tools
);
}
#[test]
fn a_hub_repos_tag_and_its_payloads_version_can_differ() {
let env = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"with-device\"\nrepo=\"pulseengine/jess\"\n\
binary=\"with-device\"\nrelease=\"v0.7.2\"\nversion=\"0.2.2\"\n\
asset=\"with-device-%V-%T.tar.gz\"\n"
))
.expect("a hub repo's payload must be expressible");
assert_eq!(
env.layer_tools, "pulseengine/jess:v0.7.2:with-device:with-device-%V-%T.tar.gz:0.2.2",
"the tag is fetched, the payload version is recorded"
);
}
#[test]
fn a_payload_version_cannot_skip_the_positional_fields_before_it() {
let e = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"jess\"\nrepo=\"pulseengine/jess\"\n\
release=\"v0.7.2\"\nversion=\"0.2.2\"\n"
))
.expect_err("must refuse");
assert!(
matches!(e, LayerSpecError::ReleaseNeedsBinaryAndAsset { .. }),
"{e:?}"
);
assert!(e.to_string().contains("positional"), "{e}");
let e = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"jess\"\nrepo=\"pulseengine/jess\"\n\
binary=\"with-device\"\nrelease=\"v0.7.2\"\nversion=\"0.2.2\"\n"
))
.expect_err("binary without asset must still refuse");
assert!(
matches!(e, LayerSpecError::ReleaseNeedsBinaryAndAsset { .. }),
"{e:?}"
);
let e = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"jess\"\nrepo=\"pulseengine/jess\"\n\
asset=\"a-%T.tar.gz\"\nrelease=\"v0.7.2\"\nversion=\"0.2.2\"\n"
))
.expect_err("asset without binary must still refuse");
assert!(
matches!(e, LayerSpecError::ReleaseNeedsBinaryAndAsset { .. }),
"{e:?}"
);
}
#[test]
fn an_ordinary_entry_is_unchanged() {
let env = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"rivet\"\nversion=\"v0.35.0\"\n"
))
.expect("parses");
assert_eq!(env.layer_tools, "rivet:v0.35.0");
}
#[test]
fn a_name_the_encoding_would_silently_discard_is_still_refused() {
let e = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"zephyr-sdk\"\nrepo=\"zephyrproject-rtos/sdk-ng\"\n\
version=\"v1.0.1\"\n"
))
.expect_err("no binary means the shell deposits under the basename");
assert!(
matches!(e, LayerSpecError::RepoNameMismatch { .. }),
"{e:?}"
);
}
#[test]
fn two_payloads_under_one_deposited_name_still_collide() {
let e = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"dup\"\nrepo=\"pulseengine/a\"\nbinary=\"dup\"\n\
version=\"v1\"\nasset=\"a-%T.tar.gz\"\n\n[[tool]]\nname=\"dup\"\nrepo=\"pulseengine/b\"\n\
binary=\"dup\"\nversion=\"v2\"\nasset=\"b-%T.tar.gz\"\n"
))
.expect_err("must refuse");
assert!(matches!(e, LayerSpecError::Duplicate { .. }), "{e:?}");
}
#[test]
fn every_format_states_what_it_is() {
assert!(DocsFormat::Html.is_tree());
assert!(DocsFormat::Rustdoc.is_tree());
assert!(!DocsFormat::Pdf.is_tree());
assert!(!DocsFormat::Markdown.is_tree());
assert!(!DocsFormat::Reqif.is_tree());
assert_eq!(DocsFormat::Html.file_extension(), None);
assert_eq!(DocsFormat::Rustdoc.file_extension(), None);
assert_eq!(DocsFormat::Pdf.file_extension(), Some("pdf"));
assert_eq!(DocsFormat::Markdown.file_extension(), Some("md"));
assert_eq!(DocsFormat::Reqif.file_extension(), Some("reqif"));
assert_eq!(DocsFormat::Html.as_str(), "html");
assert_eq!(DocsFormat::Rustdoc.as_str(), "rustdoc");
assert_eq!(DocsFormat::Pdf.as_str(), "pdf");
assert_eq!(DocsFormat::Markdown.as_str(), "markdown");
assert_eq!(DocsFormat::Reqif.as_str(), "reqif");
for f in [
DocsFormat::Html,
DocsFormat::Rustdoc,
DocsFormat::Pdf,
DocsFormat::Markdown,
DocsFormat::Reqif,
] {
assert_eq!(
f.is_tree(),
f.file_extension().is_none(),
"{} disagrees with itself about being a tree",
f.as_str()
);
assert!(!f.as_str().is_empty());
}
}
#[test]
fn a_declared_entry_must_be_in_the_payload() {
let has: Vec<String> = ["./index.html", "./sub/index.html"]
.iter()
.map(|s| s.to_string())
.collect();
assert_eq!(check_docs_entry(&has, Some("index.html"), true), Ok(()));
let e = check_docs_entry(&has, Some("missing.html"), true)
.expect_err("a declared entry that is absent must be refused");
assert_eq!(e.entry, "missing.html");
assert_eq!(e.members, 2);
assert!(!e.saw.is_empty(), "the refusal must show what IS there");
assert_eq!(check_docs_entry(&has, None, true), Ok(()));
assert_eq!(check_docs_entry(&has, Some("whatever"), false), Ok(()));
let two_tops: Vec<String> = ["a/index.html", "b/index.html"]
.iter()
.map(|s| s.to_string())
.collect();
assert!(check_docs_entry(&two_tops, Some("index.html"), true).is_err());
let wrapped: Vec<String> = vec!["book-1.0/index.html".to_string()];
assert_eq!(check_docs_entry(&wrapped, Some("index.html"), true), Ok(()));
}
#[test]
fn a_subdirectory_namesake_does_not_satisfy_a_root_entry() {
let members: Vec<String> = ["./", "./eu-ai-act/index.html", "./artifacts/index.html"]
.iter()
.map(|s| s.to_string())
.collect();
assert!(
!docs_entry_present(&members, "index.html"),
"a namesake in a subdirectory is not the declared root entry"
);
assert!(docs_entry_present(&members, "eu-ai-act/index.html"));
}
#[test]
fn the_real_traceability_layout_resolves_its_root_entry() {
let members: Vec<String> = [
"./",
"./_assets/styles.css",
"./eu-ai-act/index.html",
"./artifacts/REQ-ROLLBACK-001.html",
"./index.html",
]
.iter()
.map(|s| s.to_string())
.collect();
assert!(docs_entry_present(&members, "index.html"));
}
#[test]
fn a_single_wrapper_directory_is_not_part_of_the_entry_path() {
let members: Vec<String> = [
"book-1.2.3/",
"book-1.2.3/index.html",
"book-1.2.3/ch1.html",
]
.iter()
.map(|s| s.to_string())
.collect();
assert!(docs_entry_present(&members, "index.html"));
}
#[test]
fn two_top_level_directories_are_content_not_a_wrapper() {
let members: Vec<String> = ["a/index.html", "b/index.html"]
.iter()
.map(|s| s.to_string())
.collect();
assert!(!docs_entry_present(&members, "index.html"));
assert!(docs_entry_present(&members, "a/index.html"));
}
#[test]
fn a_docs_payload_declares_its_format_and_its_entry_point() {
let m = parse_layer_manifest(&format!(
"{HEAD}\n[[docs]]\nname=\"traceability\"\nrepo=\"pulseengine/varve\"\n\
version=\"v0.35.0\"\nformat=\"html\"\nentry=\"index.html\"\n\
title=\"Requirements & traceability\"\n\
asset=\"varve-%V-traceability-html.tar.gz\"\n"
))
.expect("parses");
assert_eq!(m.docs.len(), 1);
let d = &m.docs[0];
assert_eq!(d.format, DocsFormat::Html);
assert_eq!(d.entry.as_deref(), Some("index.html"));
assert_eq!(d.title.as_deref(), Some("Requirements & traceability"));
}
#[test]
fn rustdoc_is_its_own_format_not_merely_html() {
let m = parse_layer_manifest(&format!(
"{HEAD}\n[[docs]]\nname=\"varve-core-api\"\nrepo=\"pulseengine/varve\"\n\
version=\"v0.36.0\"\nformat=\"rustdoc\"\nentry=\"varve_core/index.html\"\n\
asset=\"varve-core-%V-rustdoc.tar.gz\"\n"
))
.expect("parses");
assert_eq!(m.docs[0].format, DocsFormat::Rustdoc);
assert_ne!(m.docs[0].format, DocsFormat::Html);
}
#[test]
fn a_single_file_format_needs_no_entry() {
let m = parse_layer_manifest(&format!(
"{HEAD}\n[[docs]]\nname=\"handbook\"\nrepo=\"pulseengine/docs\"\n\
version=\"v1.0.0\"\nformat=\"pdf\"\nasset=\"handbook-%V.pdf\"\n"
))
.expect("parses");
assert_eq!(m.docs[0].format, DocsFormat::Pdf);
assert_eq!(m.docs[0].entry, None);
}
#[test]
fn an_unknown_docs_format_is_refused() {
let e = parse_layer_manifest(&format!(
"{HEAD}\n[[docs]]\nname=\"x\"\nrepo=\"a/b\"\nversion=\"v1\"\n\
format=\"asciidoc\"\nasset=\"x-%V.adoc\"\n"
))
.expect_err("must refuse");
assert!(matches!(e, LayerSpecError::Parse(_)), "{e:?}");
assert!(
e.to_string().contains("asciidoc"),
"the refusal must name the bad value: {e}"
);
}
#[test]
fn an_sdk_entry_refuses_to_translate_into_the_env_encoding() {
let e = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"zephyr-sdk\"\nrepo=\"zephyrproject-rtos/sdk-ng\"\n\
binary=\"zephyr-sdk\"\nversion=\"v1.0.1\"\nlayout=\"sdk\"\n\
asset=\"toolchain_gnu_%U_arm-zephyr-eabi.tar.xz\"\n"
))
.expect_err("must refuse");
let msg = e.to_string();
assert!(msg.contains("none for a LAYOUT"), "{msg}");
assert!(msg.contains("varve-producer deposit"), "{msg}");
}
#[test]
fn a_platform_restriction_refuses_to_translate_into_the_env_encoding() {
let e = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"wasm-opt\"\nrepo=\"WebAssembly/binaryen\"\n\
version=\"133\"\nrelease=\"version_133\"\n\
platforms=[\"x86_64-unknown-linux-gnu\"]\n"
))
.expect_err("must refuse rather than widen the platform set");
let msg = e.to_string();
assert!(
msg.contains("x86_64-unknown-linux-gnu"),
"the refusal must name the restriction it cannot carry: {msg}"
);
assert!(msg.contains("varve-producer deposit"), "{msg}");
}
#[test]
fn an_upstream_sums_entry_refuses_rather_than_losing_the_mechanism() {
let e = env_of(&format!(
"{HEAD}\n[[tool]]\nname=\"wac\"\nrepo=\"bytecodealliance/wac\"\n\
binary=\"wac\"\nversion=\"v0.10.1\"\nasset=\"wac-%V-%T.tar.gz\"\n\
upstream-sums=\"sha256.sum\"\n"
))
.expect_err("must refuse");
let msg = e.to_string();
assert!(msg.contains("upstream-sums"), "{msg}");
assert!(msg.contains("varve-producer deposit"), "{msg}");
}
#[test]
fn every_docs_format_parses_back_from_the_name_it_is_signed_as() {
let all = [
DocsFormat::Html,
DocsFormat::Rustdoc,
DocsFormat::Pdf,
DocsFormat::Markdown,
DocsFormat::Reqif,
];
for f in all {
assert_eq!(DocsFormat::parse(f.as_str()), Some(f), "{f:?}");
}
assert_eq!(DocsFormat::parse("epub"), None);
#[derive(serde::Deserialize)]
struct W {
f: DocsFormat,
}
for f in all {
let w: W = toml::from_str(&format!("f = \"{}\"", f.as_str())).expect("serde agrees");
assert_eq!(w.f, f);
}
assert_eq!(
DocsFormat::parse("HTML"),
None,
"the signed names are exact"
);
}
}