Move the check to the constructor

Author: stanislav-tkach

rust/signed_doc/src/validator/rules/chain/mod.rs

@@ -1,10 +1,10 @@
 //! `chain` rule type impl.
 
+use anyhow::ensure;
 use catalyst_signed_doc_spec::{is_required::IsRequired, metadata::chain::Chain};
-
+use catalyst_signed_doc_spec::metadata::collaborators::Collaborators;
 use crate::{
     CatalystSignedDocument, providers::CatalystSignedDocumentProvider,
-    validator::rules::CollaboratorsRule,
 };
 
 #[cfg(test)]
@@ -24,25 +24,25 @@ pub(crate) enum ChainRule {
 
 impl ChainRule {
     /// Generating `ChainRule` from specs
-    pub(crate) fn new(spec: &Chain) -> Self {
+    pub(crate) fn new(spec: &Chain, collaborators_spec: &Collaborators) -> anyhow::Result<Self> {
         let optional = match spec.required {
             IsRequired::Yes => false,
             IsRequired::Optional => true,
             IsRequired::Excluded => {
-                return Self::NotSpecified;
-            },
+                return Ok(Self::NotSpecified);
+            }
         };
 
-        Self::Specified { optional }
+        ensure!(matches!(collaborators_spec.required, IsRequired::Excluded), "Chained Documents do not support collaborators");
+
+        Ok(Self::Specified { optional })
     }
 
     /// Field validation rule
-    #[allow(clippy::too_many_lines)]
     pub(crate) async fn check<Provider>(
         &self,
         doc: &CatalystSignedDocument,
         provider: &Provider,
-        collaborators_rule: &CollaboratorsRule,
     ) -> anyhow::Result<bool>
     where
         Provider: CatalystSignedDocumentProvider,
@@ -141,14 +141,6 @@ impl ChainRule {
                     }
                 }
             }
-
-            if let CollaboratorsRule::Specified { .. } = collaborators_rule {
-                doc.report().functional_validation(
-                    "Chained Documents do not support collaborators",
-                    "Chained Documents validation",
-                );
-                return Ok(false);
-            }
         }
         if let Self::NotSpecified = self
             && chain.is_some()

rust/signed_doc/src/validator/rules/chain/tests.rs

@@ -1,10 +1,11 @@
+use catalyst_signed_doc_spec::{is_required::IsRequired, metadata::chain::Chain as ChainSpec};
 use catalyst_types::uuid::{UuidV4, UuidV7};
 use test_case::test_case;
 
 use super::*;
 use crate::{
-    Chain, DocType, builder::tests::Builder, metadata::SupportedField,
-    providers::tests::TestCatalystProvider,
+    builder::tests::Builder, metadata::SupportedField, providers::tests::TestCatalystProvider,
+    Chain, DocType,
 };
 
 mod helper {
@@ -41,49 +42,22 @@ async fn test_without_chaining_documents() {
         .build();
 
     let rule = ChainRule::NotSpecified;
-    let collaborators_rule = CollaboratorsRule::NotSpecified;
-
-    assert!(
-        rule.check(&doc, &provider, &collaborators_rule)
-            .await
-            .unwrap()
-    );
+    assert!(rule.check(&doc, &provider).await.unwrap());
     let rule = ChainRule::Specified { optional: true };
-    assert!(
-        rule.check(&doc, &provider, &collaborators_rule)
-            .await
-            .unwrap()
-    );
+    assert!(rule.check(&doc, &provider).await.unwrap());
     let rule = ChainRule::Specified { optional: false };
-    assert!(
-        !rule
-            .check(&doc, &provider, &collaborators_rule)
-            .await
-            .unwrap()
-    );
+    assert!(!rule.check(&doc, &provider).await.unwrap());
 }
 
 #[tokio::test]
 async fn chain_rule_collaborators_rule_conflict() {
-    let doc_type = UuidV4::new();
-    let doc_id = UuidV7::new();
-    let doc_ver = UuidV7::new();
-
-    let provider = TestCatalystProvider::default();
-    let doc = Builder::new()
-        .with_metadata_field(SupportedField::Type(DocType::from(doc_type)))
-        .with_metadata_field(SupportedField::Id(doc_id))
-        .with_metadata_field(SupportedField::Ver(doc_ver))
-        .build();
-
-    let rule = ChainRule::Specified { optional: true };
-    let collaborators_rule = CollaboratorsRule::Specified { optional: true };
-    assert!(
-        !rule
-            .check(&doc, &provider, &collaborators_rule)
-            .await
-            .unwrap()
-    );
+    let chain = ChainSpec {
+        required: IsRequired::Optional,
+    };
+    let collaborators = Collaborators {
+        required: IsRequired::Optional,
+    };
+    ChainRule::new(&chain, &collaborators).unwrap_err();
 }
 
 #[test_case(
@@ -169,11 +143,8 @@ async fn test_valid_chained_documents(
     (provider, doc): (TestCatalystProvider, CatalystSignedDocument)
 ) -> bool {
     let rule = ChainRule::Specified { optional: false };
-    let collaborators_rule = CollaboratorsRule::NotSpecified;
 
-    rule.check(&doc, &provider, &collaborators_rule)
-        .await
-        .unwrap()
+    rule.check(&doc, &provider).await.unwrap()
 }
 
 #[test_case(
@@ -319,9 +290,6 @@ async fn test_invalid_chained_documents(
     (provider, doc): (TestCatalystProvider, CatalystSignedDocument)
 ) -> bool {
     let rule = ChainRule::Specified { optional: false };
-    let collaborators_rule = CollaboratorsRule::NotSpecified;
 
-    rule.check(&doc, &provider, &collaborators_rule)
-        .await
-        .unwrap()
+    rule.check(&doc, &provider).await.unwrap()
 }

rust/signed_doc/src/validator/rules/mod.rs

@@ -2,12 +2,12 @@
 //! <https://input-output-hk.github.io/catalyst-libs/architecture/08_concepts/signed_doc/meta/>
 
 use anyhow::Context;
-use catalyst_signed_doc_spec::{DocSpec, DocSpecs, cddl_definitions::CddlDefinitions};
+use catalyst_signed_doc_spec::{cddl_definitions::CddlDefinitions, DocSpec, DocSpecs};
 use futures::FutureExt;
 
 use crate::{
-    CatalystSignedDocument,
     providers::{CatalystIdProvider, CatalystSignedDocumentProvider},
+    CatalystSignedDocument,
 };
 
 mod chain;
@@ -98,7 +98,7 @@ impl Rules {
             self.reply.check(doc, provider).boxed(),
             self.section.check(doc).boxed(),
             self.parameters.check(doc, provider).boxed(),
-            self.chain.check(doc, provider, &self.collaborators).boxed(),
+            self.chain.check(doc, provider).boxed(),
             self.collaborators.check(doc).boxed(),
             self.content.check(doc).boxed(),
             self.kid.check(doc).boxed(),
@@ -129,7 +129,7 @@ impl Rules {
             content_encoding: ContentEncodingRule::new(&doc_spec.headers.content_encoding)?,
             template: TemplateRule::new(all_docs_specs, &doc_spec.metadata.template)?,
             parameters: ParametersRule::new(all_docs_specs, &doc_spec.metadata.parameters)?,
-            chain: ChainRule::new(&doc_spec.metadata.chain),
+            chain: ChainRule::new(&doc_spec.metadata.chain, &doc_spec.metadata.collaborators)?,
             doc_ref: RefRule::new(all_docs_specs, &doc_spec.metadata.doc_ref)?,
             reply: ReplyRule::new(all_docs_specs, &doc_spec.metadata.reply)?,
             section: SectionRule::NotSpecified,