use serde::{Deserialize, Serialize};
use crate::binding;
use crate::bundle::{self, BundleParams};
use crate::cbor;
use crate::container::BundleKind;
use crate::error::{FcbError, Result};
use crate::evidence::{StreamData, StreamManifest};
use crate::task::TaskSpec;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CasePayload {
#[serde(default)]
pub streams: Vec<StreamData>,
}
impl CasePayload {
pub fn to_canonical_bytes(&self) -> Result<Vec<u8>> {
cbor::encode(self)
}
}
pub fn case_bundle_hash(payload: &CasePayload) -> Result<String> {
Ok(binding::compute_bundle_hash(&payload.to_canonical_bytes()?))
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CaseInput {
pub case_id: String,
pub manifest: Vec<StreamManifest>,
pub task: Option<TaskSpec>,
pub payload: CasePayload,
}
#[derive(Serialize)]
struct CaseMeta<'a> {
streams: &'a [StreamManifest],
#[serde(skip_serializing_if = "Option::is_none")]
task: Option<&'a TaskSpec>,
}
fn check_manifest_matches_payload(
manifest: &[StreamManifest],
payload: &CasePayload,
) -> Result<()> {
use std::collections::HashMap;
let mut counts: HashMap<&str, usize> = HashMap::with_capacity(payload.streams.len());
for stream in &payload.streams {
if counts
.insert(stream.id.as_str(), stream.records.len())
.is_some()
{
return Err(FcbError::Malformed(format!(
"payload declares stream id {:?} more than once",
stream.id
)));
}
}
for entry in manifest {
match counts.remove(entry.id.as_str()) {
None => {
return Err(FcbError::Malformed(format!(
"manifest declares stream {:?} with no matching payload stream",
entry.id
)))
}
Some(actual) if actual as u64 != entry.records => {
return Err(FcbError::Malformed(format!(
"manifest declares {} records for stream {:?} but payload carries {}",
entry.records, entry.id, actual
)))
}
Some(_) => {}
}
}
if let Some(extra) = counts.keys().next() {
return Err(FcbError::Malformed(format!(
"payload carries stream {:?} not declared in the manifest",
extra
)));
}
Ok(())
}
pub fn pack_case(input: &CaseInput, passphrase: &str) -> Result<Vec<u8>> {
if input.manifest.is_empty() {
return Err(FcbError::Malformed("case has no streams".into()));
}
check_manifest_matches_payload(&input.manifest, &input.payload)?;
let payload_bytes = input.payload.to_canonical_bytes()?;
let bundle_hash = binding::compute_bundle_hash(&payload_bytes);
let meta = cbor::to_value(&CaseMeta {
streams: &input.manifest,
task: input.task.as_ref(),
})?;
let params = BundleParams::new(BundleKind::Case, input.case_id.clone(), bundle_hash, meta);
bundle::pack_bytes(¶ms, &payload_bytes, passphrase)
}
#[cfg(test)]
mod tests {
use super::*;
use ciborium::value::Value;
fn payload() -> CasePayload {
CasePayload {
streams: vec![
StreamData {
id: "s0".into(),
records: vec![Value::Text("evt1".into())],
},
StreamData {
id: "s1".into(),
records: vec![Value::Integer(7.into())],
},
],
}
}
#[test]
fn canonical_bytes_round_trip() {
let p = payload();
let bytes = p.to_canonical_bytes().unwrap();
let back: CasePayload = cbor::decode(&bytes).unwrap();
assert_eq!(back, p);
assert_eq!(p.to_canonical_bytes().unwrap(), bytes);
}
#[test]
fn bundle_hash_is_content_addressed() {
let h = case_bundle_hash(&payload()).unwrap();
assert!(h.starts_with("sha256:"));
assert_eq!(h.len(), 7 + 64);
assert_eq!(h, case_bundle_hash(&payload()).unwrap());
assert_eq!(
h,
binding::compute_bundle_hash(&payload().to_canonical_bytes().unwrap())
);
let other = CasePayload { streams: vec![] };
assert_ne!(h, case_bundle_hash(&other).unwrap());
}
#[test]
fn pack_case_rejects_empty_manifest() {
let input = CaseInput {
case_id: "c".into(),
manifest: vec![],
task: None,
payload: CasePayload { streams: vec![] },
};
assert!(matches!(
pack_case(&input, "pw"),
Err(FcbError::Malformed(_))
));
}
fn manifest(entries: &[(&str, u64)]) -> Vec<StreamManifest> {
entries
.iter()
.map(|(id, n)| StreamManifest {
id: (*id).into(),
stream_type: "fcb.json.v1".into(),
records: *n,
})
.collect()
}
fn case_with(manifest: Vec<StreamManifest>, payload: CasePayload) -> CaseInput {
CaseInput {
case_id: "c".into(),
manifest,
task: None,
payload,
}
}
#[test]
fn pack_case_accepts_consistent_manifest() {
let input = case_with(manifest(&[("s0", 1), ("s1", 1)]), payload());
assert!(pack_case(&input, "pw").is_ok());
}
#[test]
fn pack_case_rejects_record_count_mismatch() {
let input = case_with(manifest(&[("s0", 2), ("s1", 1)]), payload());
assert!(matches!(
pack_case(&input, "pw"),
Err(FcbError::Malformed(_))
));
}
#[test]
fn pack_case_rejects_extra_payload_stream() {
let input = case_with(manifest(&[("s0", 1)]), payload());
assert!(matches!(
pack_case(&input, "pw"),
Err(FcbError::Malformed(_))
));
}
#[test]
fn pack_case_rejects_missing_payload_stream() {
let input = case_with(manifest(&[("s0", 1), ("s1", 1), ("s2", 1)]), payload());
assert!(matches!(
pack_case(&input, "pw"),
Err(FcbError::Malformed(_))
));
}
#[test]
fn pack_case_rejects_duplicate_payload_id() {
let dup = CasePayload {
streams: vec![
StreamData {
id: "s0".into(),
records: vec![Value::Text("a".into())],
},
StreamData {
id: "s0".into(),
records: vec![Value::Text("b".into())],
},
],
};
let input = case_with(manifest(&[("s0", 1)]), dup);
assert!(matches!(
pack_case(&input, "pw"),
Err(FcbError::Malformed(_))
));
}
#[test]
fn pack_case_rejects_duplicate_manifest_id() {
let single = CasePayload {
streams: vec![StreamData {
id: "s0".into(),
records: vec![Value::Text("a".into())],
}],
};
let input = case_with(manifest(&[("s0", 1), ("s0", 1)]), single);
assert!(matches!(
pack_case(&input, "pw"),
Err(FcbError::Malformed(_))
));
}
#[test]
fn pack_case_accepts_zero_record_stream() {
let p = CasePayload {
streams: vec![StreamData {
id: "s0".into(),
records: vec![],
}],
};
let input = case_with(manifest(&[("s0", 0)]), p);
assert!(pack_case(&input, "pw").is_ok());
}
#[test]
fn pack_case_rejects_mismatch_in_non_first_stream() {
let p = CasePayload {
streams: vec![
StreamData {
id: "s0".into(),
records: vec![Value::Text("a".into())],
},
StreamData {
id: "s1".into(),
records: vec![Value::Text("b".into())],
},
StreamData {
id: "s2".into(),
records: vec![Value::Text("c".into())],
},
],
};
let input = case_with(manifest(&[("s0", 1), ("s1", 1), ("s2", 2)]), p);
assert!(matches!(
pack_case(&input, "pw"),
Err(FcbError::Malformed(_))
));
}
}