chore: added full test e2e make target

Signed-off-by: jeluard <[email protected]>

Author: jeluard

crates/amaru-ledger/src/rules/block.rs

@@ -25,12 +25,13 @@ use crate::{
     state::FailedTransactions,
 };
 use amaru_kernel::{
-    protocol_parameters::ProtocolParameters, AuxiliaryData, HasExUnits, Hash, MintedBlock,
-    OriginalHash, StakeCredential, TransactionPointer,
+    protocol_parameters::ProtocolParameters, AuxiliaryData, Hash, MintedBlock, OriginalHash,
+    StakeCredential, TransactionPointer,
 };
 use std::ops::{ControlFlow, Deref, FromResidual, Try};
 use tracing::{instrument, Level};
 
+#[derive(Debug)]
 pub enum InvalidBlock {
     Size(InvalidBlockSize),
     ExUnits(InvalidExUnits),
@@ -43,6 +44,7 @@ pub enum InvalidBlock {
     UncategorizedError(String),
 }
 
+#[derive(Debug)]
 pub enum BlockValidation {
     Valid,
     Invalid(InvalidBlock),
@@ -76,6 +78,15 @@ impl FromResidual for BlockValidation {
     }
 }
 
+impl From<BlockValidation> for Result<(), InvalidBlock> {
+    fn from(validation: BlockValidation) -> Self {
+        match validation {
+            BlockValidation::Valid => Ok(()),
+            BlockValidation::Invalid(e) => Err(e),
+        }
+    }
+}
+
 #[instrument(level = Level::TRACE, skip_all)]
 pub fn execute<C: ValidationContext<FinalState = S>, S: From<C>>(
     context: &mut C,

crates/amaru-ledger/src/rules/block/body_size.rs

@@ -18,6 +18,7 @@ use crate::context::ValidationContext;
 
 use super::{BlockValidation, InvalidBlock};
 
+#[derive(Debug)]
 pub enum InvalidBlockSize {
     SizeMismatch { supplied: usize, actual: usize },
 }
@@ -58,9 +59,11 @@ fn calculate_block_body_size(block: &MintedBlock<'_>) -> usize {
 
 #[cfg(test)]
 mod tests {
-    use amaru_kernel::{include_cbor, MintedBlock};
+    use amaru_kernel::{include_cbor, protocol_parameters::ProtocolParameters, MintedBlock};
     use test_case::test_case;
 
+    use crate::{context::DefaultValidationContext, rules::block::InvalidBlock};
+
     use super::InvalidBlockSize;
 
     macro_rules! fixture {
@@ -72,13 +75,23 @@ mod tests {
         };
     }
 
+    /*fn aa() {
+        let mut context = DefaultValidationContext::new(Default::default());
+        let res = super::block_body_size_valid(&mut context, &block, &ProtocolParameters::default());
+        matches res {
+            BlockValidation::Invalid(InvalidBlock::Size(InvalidBlockSize::SizeMismatch {supplied, actual}));
+            if supplied == 0 && actual == 3411;
+        } Err(InvalidBlockSize::SizeMismatch {supplied, actual})
+        if supplied == 0 && actual == 3411;
+    }*/
+
     #[test_case(fixture!("2667660"); "valid")]
-    #[test_case(fixture!("2667660", "invalid_block_body_size") =>
-        matches Err(InvalidBlockSize::SizeMismatch {supplied, actual})
+    #[test_case(fixture!("2667660", "invalid_block_body_size") => 
+        matches Err(InvalidBlock::Size(InvalidBlockSize::SizeMismatch {supplied, actual}))
             if supplied == 0 && actual == 3411;
-        "block body size mismatch"
-    )]
-    fn test_block_size(block: MintedBlock<'_>) -> Result<(), InvalidBlockSize> {
-        super::block_body_size_valid(&block.header.header_body, &block)
+    "block body size mismatch")]
+    fn test_block_size(block: MintedBlock<'_>) -> Result<(), InvalidBlock> {
+        let mut context = DefaultValidationContext::new(Default::default());
+        super::block_body_size_valid(&mut context, &block, &ProtocolParameters::default()).into()
     }
 }

crates/amaru-ledger/src/rules/block/ex_units.rs

@@ -12,16 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::ops::Deref;
-
 use amaru_kernel::{
-    protocol_parameters::ProtocolParameters, sum_ex_units, ExUnits, MintedBlock, Redeemers,
+    protocol_parameters::ProtocolParameters, sum_ex_units, ExUnits, HasExUnits, MintedBlock,
 };
 
 use crate::context::ValidationContext;
 
 use super::{BlockValidation, InvalidBlock};
 
+#[derive(Debug)]
 pub enum InvalidExUnits {
     TooMany { provided: ExUnits, max: ExUnits },
 }
@@ -32,20 +31,7 @@ pub fn block_ex_units_valid<C: ValidationContext>(
     protocol_parameters: &ProtocolParameters,
 ) -> BlockValidation {
     // TODO: rewrite this to use iterators defined on `Redeemers` and `MaybeIndefArray`, ideally
-    let ex_units = block
-        .transaction_witness_sets
-        .iter()
-        .flat_map(|witness_set| {
-            witness_set
-                .redeemer
-                .iter()
-                .map(|redeemers| match redeemers.deref() {
-                    Redeemers::List(list) => list.iter().map(|r| r.ex_units).collect::<Vec<_>>(),
-                    Redeemers::Map(map) => map.iter().map(|(_, r)| r.ex_units).collect::<Vec<_>>(),
-                })
-        })
-        .flatten()
-        .collect::<Vec<_>>();
+    let ex_units = block.ex_units();
 
     let pp_max_ex_units = protocol_parameters.max_block_ex_units;
     let ex_units = ex_units
@@ -67,9 +53,11 @@ pub fn block_ex_units_valid<C: ValidationContext>(
 
 #[cfg(test)]
 mod tests {
+    use crate::{context::DefaultValidationContext, rules::block::InvalidBlock};
+
     use super::InvalidExUnits;
     use amaru_kernel::{
-        include_cbor, protocol_parameters::ProtocolParameters, ExUnits, HasExUnits, MintedBlock,
+        include_cbor, protocol_parameters::ProtocolParameters, ExUnits, MintedBlock,
     };
     use test_case::test_case;
 
@@ -95,11 +83,12 @@ mod tests {
             steps: 0
         },
         ..Default::default()
-    }) => matches Err(InvalidExUnits::TooMany{provided, max: _})
-        if provided == ExUnits {mem: 1267029, steps: 289959162}; "invalid ex units")]
+    }) => matches Err(InvalidBlock::ExUnits(InvalidExUnits::TooMany{provided, max: _}))
+    if provided == ExUnits {mem: 1267029, steps: 289959162}; "invalid ex units")]
     fn test_ex_units(
         (block, protocol_parameters): (MintedBlock<'_>, ProtocolParameters),
-    ) -> Result<(), InvalidExUnits> {
-        super::block_ex_units_valid(block.ex_units(), &protocol_parameters)
+    ) -> Result<(), InvalidBlock> {
+        let mut context = DefaultValidationContext::new(Default::default());
+        super::block_ex_units_valid(&mut context, &block, &protocol_parameters).into()
     }
 }

crates/amaru-ledger/src/rules/block/header_size.rs

@@ -18,6 +18,7 @@ use crate::context::ValidationContext;
 
 use super::{BlockValidation, InvalidBlock};
 
+#[derive(Debug)]
 pub enum InvalidBlockHeader {
     SizeTooBig { supplied: usize, max: usize },
 }