feat(rust/signed-doc): Added more decoding test cases, cleaned up DecodeContext (#401)

* fix signed_doc_with_random_header_field_case * add signed_doc_with_non_empty_unprotected_headers, signed_doc_with_signatures_non_empty_unprotected_headers test cases * refactor DecodeContext * wip * add new test cases * wip * fix clippy

Author: Mr-Leshiy

rust/signed_doc/bins/mk_signed_doc.rs

@@ -129,7 +129,7 @@ fn save_signed_doc(signed_doc: CatalystSignedDocument, path: &PathBuf) -> anyhow
 }
 
 fn signed_doc_from_bytes(cose_bytes: &[u8]) -> anyhow::Result<CatalystSignedDocument> {
- minicbor::decode(cose_bytes).context("Invalid Catalyst Document")
+ cose_bytes.try_into().context("Invalid Catalyst Document")
 }
 
 fn load_json_from_file<T>(path: &PathBuf) -> anyhow::Result<T>

rust/signed_doc/src/decode_context.rs

@@ -3,9 +3,8 @@
 use catalyst_types::problem_report::ProblemReport;
 
 /// Compatibility policy
-#[allow(dead_code)]
 #[derive(Copy, Clone)]
-pub(crate) enum CompatibilityPolicy {
+pub enum CompatibilityPolicy {
  /// Silently allow obsoleted type conversions or non deterministic encoding.
  Accept,
  /// Allow but log Warnings for all obsoleted type conversions or non deterministic
@@ -17,9 +16,35 @@ pub(crate) enum CompatibilityPolicy {
 }
 
 /// A context use to pass to decoder.
-pub(crate) struct DecodeContext<'r> {
+pub(crate) struct DecodeContext {
  /// Compatibility policy.
- pub compatibility_policy: CompatibilityPolicy,
+ compatibility_policy: CompatibilityPolicy,
  /// Problem report.
- pub report: &'r mut ProblemReport,
+ report: ProblemReport,
+}
+
+impl DecodeContext {
+ /// Creates a new instance of the `DecodeContext`
+ pub(crate) fn new(compatibility_policy: CompatibilityPolicy, report: ProblemReport) -> Self {
+ Self {
+ compatibility_policy,
+ report,
+ }
+ }
+
+ /// Returns `CompatibilityPolicy`
+ pub(crate) fn policy(&self) -> &CompatibilityPolicy {
+ &self.compatibility_policy
+ }
+
+ /// Returns `ProblemReport`
+ pub(crate) fn report(&mut self) -> &mut ProblemReport {
+ &mut self.report
+ }
+
+ /// Consuming the current `DecodeContext` by returning the underlying `ProblemReport`
+ /// instance
+ pub(crate) fn into_report(self) -> ProblemReport {
+ self.report
+ }
 }

rust/signed_doc/src/lib.rs

@@ -2,7 +2,7 @@
 
 mod builder;
 mod content;
-mod decode_context;
+pub mod decode_context;
 pub mod doc_types;
 mod metadata;
 pub mod providers;
@@ -208,13 +208,12 @@ impl CatalystSignedDocument {
  }
 }
 
-impl Decode<'_, ()> for CatalystSignedDocument {
- fn decode(d: &mut Decoder<'_>, _ctx: &mut ()) -> Result<Self, decode::Error> {
- let mut report = ProblemReport::new("Catalyst Signed Document Decoding");
- let mut ctx = DecodeContext {
- compatibility_policy: CompatibilityPolicy::Accept,
- report: &mut report,
- };
+impl Decode<'_, CompatibilityPolicy> for CatalystSignedDocument {
+ fn decode(d: &mut Decoder<'_>, ctx: &mut CompatibilityPolicy) -> Result<Self, decode::Error> {
+ let mut ctx = DecodeContext::new(
+ *ctx,
+ ProblemReport::new("Catalyst Signed Document Decoding"),
+ );
 
  let p = d.position();
  if let Ok(tag) = d.tag() {
@@ -246,7 +245,7 @@ impl Decode<'_, ()> for CatalystSignedDocument {
  )?
  .into_iter();
  if map.next().is_some() {
- ctx.report.unknown_field(
+ ctx.report().unknown_field(
  "unprotected headers",
  "non empty unprotected headers",
  "COSE unprotected headers must be empty",
@@ -260,7 +259,7 @@ impl Decode<'_, ()> for CatalystSignedDocument {
  metadata,
  content,
  signatures,
- report,
+ report: ctx.into_report(),
  }
  .into())
  }
@@ -294,7 +293,10 @@ impl TryFrom<&[u8]> for CatalystSignedDocument {
  type Error = anyhow::Error;
 
  fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
- Ok(minicbor::decode(value)?)
+ Ok(minicbor::decode_with(
+ value,
+ &mut CompatibilityPolicy::Accept,
+ )?)
  }
 }
 

rust/signed_doc/src/metadata/doc_type.rs

@@ -144,7 +144,7 @@ impl Display for DocType {
 // document_type = [ 1* uuid_v4 ]
 // ; UUIDv4
 // uuid_v4 = #6.37(bytes .size 16)
-impl Decode<'_, DecodeContext<'_>> for DocType {
+impl Decode<'_, DecodeContext> for DocType {
  fn decode(
  d: &mut Decoder, decode_context: &mut DecodeContext,
  ) -> Result<Self, minicbor::decode::Error> {
@@ -155,15 +155,15 @@ impl Decode<'_, DecodeContext<'_>> for DocType {
  minicbor::data::Type::Array => {
  let len = d.array()?.ok_or_else(|| {
  decode_context
- .report
+ .report()
  .other("Unable to decode array length", CONTEXT);
  minicbor::decode::Error::message(format!(
  "{CONTEXT}: Unable to decode array length"
  ))
  })?;
 
  if len == 0 {
- decode_context.report.invalid_value(
+ decode_context.report().invalid_value(
  "array length",
  "0",
  "must contain at least one UUIDv4",
@@ -180,7 +180,7 @@ impl Decode<'_, DecodeContext<'_>> for DocType {
  .map(Self)
  .map_err(|e| {
  decode_context
- .report
+ .report()
  .other(&format!("Invalid UUIDv4 in array: {e}"), CONTEXT);
  minicbor::decode::Error::message(format!(
  "{CONTEXT}: Invalid UUIDv4 in array: {e}"
@@ -189,18 +189,15 @@ impl Decode<'_, DecodeContext<'_>> for DocType {
  },
  minicbor::data::Type::Tag => {
  // Handle single tagged UUID
- match decode_context.compatibility_policy {
+ match decode_context.policy() {
  CompatibilityPolicy::Accept | CompatibilityPolicy::Warn => {
- if matches!(
- decode_context.compatibility_policy,
- CompatibilityPolicy::Warn
- ) {
+ if matches!(decode_context.policy(), CompatibilityPolicy::Warn) {
  warn!("{CONTEXT}: Conversion of document type single UUID to type DocType");
  }
 
  let uuid = parse_uuid(d).map_err(|e| {
  let msg = format!("Cannot decode single UUIDv4: {e}");
- decode_context.report.invalid_value(
+ decode_context.report().invalid_value(
  "Decode single UUIDv4",
  &e.to_string(),
  &msg,
@@ -214,15 +211,15 @@ impl Decode<'_, DecodeContext<'_>> for DocType {
 
  CompatibilityPolicy::Fail => {
  let msg = "Conversion of document type single UUID to type DocType is not allowed";
- decode_context.report.other(msg, CONTEXT);
+ decode_context.report().other(msg, CONTEXT);
  Err(minicbor::decode::Error::message(format!(
  "{CONTEXT}: {msg}"
  )))
  },
  }
  },
  other => {
- decode_context.report.invalid_value(
+ decode_context.report().invalid_value(
  "decoding type",
  &format!("{other:?}"),
  "array or tag cbor",
@@ -342,49 +339,45 @@ mod tests {
  fn test_empty_doc_type_cbor_decode() {
  assert!(<DocType as TryFrom<Vec<UuidV4>>>::try_from(vec![]).is_err());
 
- let mut report = ProblemReport::new("Test empty doc type");
- let mut decoded_context = DecodeContext {
- compatibility_policy: CompatibilityPolicy::Accept,
- report: &mut report,
- };
+ let mut decoded_context = DecodeContext::new(
+ CompatibilityPolicy::Accept,
+ ProblemReport::new("Test empty doc type"),
+ );
  let mut decoder = Decoder::new(&[]);
  assert!(DocType::decode(&mut decoder, &mut decoded_context).is_err());
  }
 
  #[test]
  fn test_single_uuid_doc_type_fail_policy_cbor_decode() {
- let mut report = ProblemReport::new("Test single uuid doc type - fail");
  let data = hex::decode(PSA).unwrap();
  let decoder = Decoder::new(&data);
- let mut decoded_context = DecodeContext {
- compatibility_policy: CompatibilityPolicy::Fail,
- report: &mut report,
- };
+ let mut decoded_context = DecodeContext::new(
+ CompatibilityPolicy::Fail,
+ ProblemReport::new("Test single uuid doc type - fail"),
+ );
  assert!(DocType::decode(&mut decoder.clone(), &mut decoded_context).is_err());
  }
 
  #[test]
  fn test_single_uuid_doc_type_warn_policy_cbor_decode() {
- let mut report = ProblemReport::new("Test single uuid doc type - warn");
  let data = hex::decode(PSA).unwrap();
  let decoder = Decoder::new(&data);
- let mut decoded_context = DecodeContext {
- compatibility_policy: CompatibilityPolicy::Warn,
- report: &mut report,
- };
+ let mut decoded_context = DecodeContext::new(
+ CompatibilityPolicy::Warn,
+ ProblemReport::new("Test single uuid doc type - warn"),
+ );
  let decoded_doc_type = DocType::decode(&mut decoder.clone(), &mut decoded_context).unwrap();
  assert_eq!(decoded_doc_type.doc_types().len(), 3);
  }
 
  #[test]
  fn test_single_uuid_doc_type_accept_policy_cbor_decode() {
- let mut report = ProblemReport::new("Test single uuid doc type - accept");
  let data = hex::decode(PSA).unwrap();
  let decoder = Decoder::new(&data);
- let mut decoded_context = DecodeContext {
- compatibility_policy: CompatibilityPolicy::Accept,
- report: &mut report,
- };
+ let mut decoded_context = DecodeContext::new(
+ CompatibilityPolicy::Accept,
+ ProblemReport::new("Test single uuid doc type - accept"),
+ );
  let decoded_doc_type = DocType::decode(&mut decoder.clone(), &mut decoded_context).unwrap();
  assert_eq!(decoded_doc_type.doc_types().len(), 3);
  }
@@ -398,10 +391,7 @@ mod tests {
  let mut encoder = Encoder::new(&mut buffer);
  doc_type_list.encode(&mut encoder, &mut report).unwrap();
  let mut decoder = Decoder::new(&buffer);
- let mut decoded_context = DecodeContext {
- compatibility_policy: CompatibilityPolicy::Accept,
- report: &mut report.clone(),
- };
+ let mut decoded_context = DecodeContext::new(CompatibilityPolicy::Accept, report);
  let decoded_doc_type = DocType::decode(&mut decoder, &mut decoded_context).unwrap();
  assert_eq!(decoded_doc_type, doc_type_list);
  }

rust/signed_doc/src/metadata/document_refs/doc_ref.rs

@@ -62,21 +62,21 @@ impl Display for DocumentRef {
  }
 }
 
-impl Decode<'_, DecodeContext<'_>> for DocumentRef {
+impl Decode<'_, DecodeContext> for DocumentRef {
  fn decode(
- d: &mut minicbor::Decoder<'_>, decode_context: &mut DecodeContext<'_>,
+ d: &mut minicbor::Decoder<'_>, decode_context: &mut DecodeContext,
  ) -> Result<Self, minicbor::decode::Error> {
  const CONTEXT: &str = "DocumentRef decoding";
  let parse_uuid = |d: &mut Decoder| UuidV7::decode(d, &mut CborContext::Tagged);
 
  let arr = d.array()?.ok_or_else(|| {
  decode_context
- .report
+ .report()
  .other("Unable to decode array length", CONTEXT);
  minicbor::decode::Error::message(format!("{CONTEXT}: Unable to decode array length"))
  })?;
  if arr != DOC_REF_ARR_ITEM {
- decode_context.report.invalid_value(
+ decode_context.report().invalid_value(
  "Array length",
  &arr.to_string(),
  &DOC_REF_ARR_ITEM.to_string(),
@@ -88,21 +88,21 @@ impl Decode<'_, DecodeContext<'_>> for DocumentRef {
  }
  let id = parse_uuid(d).map_err(|e| {
  decode_context
- .report
+ .report()
  .other(&format!("Invalid ID UUIDv7: {e}"), CONTEXT);
  e.with_message("Invalid ID UUIDv7")
  })?;
 
  let ver = parse_uuid(d).map_err(|e| {
  decode_context
- .report
+ .report()
  .other(&format!("Invalid Ver UUIDv7: {e}"), CONTEXT);
  e.with_message("Invalid Ver UUIDv7")
  })?;
 
- let locator = DocLocator::decode(d, decode_context.report).map_err(|e| {
+ let locator = DocLocator::decode(d, decode_context.report()).map_err(|e| {
  decode_context
- .report
+ .report()
  .other(&format!("Failed to decode locator {e}"), CONTEXT);
  e.with_message("Failed to decode locator")
  })?;