From 8666d66d2e5b94fbb458a31c55fec63789904477 Mon Sep 17 00:00:00 2001 From: Andrew Jones Date: Wed, 5 Jan 2022 12:43:04 +0000 Subject: [PATCH 1/8] Add basic event decoding test --- src/events.rs | 113 ++++++++++++++++++++++++++++++++++++-------------- src/lib.rs | 2 +- 2 files changed, 82 insertions(+), 33 deletions(-) diff --git a/src/events.rs b/src/events.rs index 9ecc63d4ff..a352323672 100644 --- a/src/events.rs +++ b/src/events.rs @@ -339,35 +339,84 @@ pub enum EventsDecodingError { InvalidCompactType(String), } -// #[cfg(test)] -// mod tests { -// use super::*; -// use std::convert::TryFrom; -// -// type DefaultConfig = crate::NodeTemplateRuntime; -// -// #[test] -// fn test_decode_option() { -// let decoder = EventsDecoder::::new( -// Metadata::default(), -// ); -// -// let value = Some(0u8); -// let input = value.encode(); -// let mut output = Vec::::new(); -// let mut errors = Vec::::new(); -// -// decoder -// .decode_raw_bytes( -// &[EventArg::Option(Box::new(EventArg::Primitive( -// "u8".to_string(), -// )))], -// &mut &input[..], -// &mut output, -// &mut errors, -// ) -// .unwrap(); -// -// assert_eq!(output, vec![1, 0]); -// } -// } +#[cfg(test)] +mod tests { + use super::*; + use std::convert::TryFrom; + use crate::{Config, DefaultConfig, Phase}; + use frame_metadata::{ + RuntimeMetadataPrefixed, + v14::{ + ExtrinsicMetadata, + RuntimeMetadataLastVersion, + PalletMetadata, + PalletEventMetadata, + } + }; + use scale_info::{ + TypeInfo, + meta_type + }; + + #[derive(Encode)] + pub struct EventRecord { + phase: Phase, + pallet_index: u8, + event: E, + topics: Vec<::Hash>, + } + + fn event_record(pallet_index: u8, event: E) -> EventRecord { + EventRecord { + phase: Phase::Finalization, + pallet_index, + event, + topics: vec![] + } + } + + #[test] + fn it_works() { + #[derive(Clone, Encode, TypeInfo)] + enum Event { + A(u8), + } + + let extrinsic = ExtrinsicMetadata { + ty: meta_type::<()>(), + version: 0, + signed_extensions: vec![] + }; + let event = PalletEventMetadata { + ty: meta_type::() + }; + let pallet_index = 0; + let pallet = PalletMetadata { + name: "Test", + storage: None, + calls: None, + event: Some(event), + constants: vec![], + error: None, + index: pallet_index + }; + let v14 = RuntimeMetadataLastVersion::new(vec![pallet], extrinsic, meta_type::<()>()); + let runtime_metadata: RuntimeMetadataPrefixed = v14.into(); + let metadata = Metadata::try_from(runtime_metadata).unwrap(); + let decoder = EventsDecoder::::new(metadata); + + let event = Event::A(1); + let encoded_event = event.encode(); + let event_records = vec![ + event_record(pallet_index, event) + ]; + + let mut input = Vec::new(); + event_records.encode_to(&mut input); + + let events = decoder.decode_events(&mut &input[..]).unwrap(); + + assert_eq!(events[0].1.variant_index, encoded_event[0]); + assert_eq!(events[0].1.data.0, encoded_event[1..]); + } +} diff --git a/src/lib.rs b/src/lib.rs index f3b2dbef25..0d8db57693 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -166,7 +166,7 @@ impl codec::Encode for Encoded { } /// A phase of a block's execution. -#[derive(Clone, Debug, Eq, PartialEq, Decode)] +#[derive(Clone, Debug, Eq, PartialEq, Decode, Encode)] pub enum Phase { /// Applying an extrinsic. ApplyExtrinsic(u32), From 0459a10ca59dff0b653a9d2ea30844017b8d330b Mon Sep 17 00:00:00 2001 From: Andrew Jones Date: Wed, 5 Jan 2022 12:54:54 +0000 Subject: [PATCH 2/8] Failing compact event field test --- src/events.rs | 68 ++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 51 insertions(+), 17 deletions(-) diff --git a/src/events.rs b/src/events.rs index a352323672..7dd7b7dbf1 100644 --- a/src/events.rs +++ b/src/events.rs @@ -375,23 +375,11 @@ mod tests { } } - #[test] - fn it_works() { - #[derive(Clone, Encode, TypeInfo)] - enum Event { - A(u8), - } - - let extrinsic = ExtrinsicMetadata { - ty: meta_type::<()>(), - version: 0, - signed_extensions: vec![] - }; + fn pallet_metadata(pallet_index: u8) -> PalletMetadata { let event = PalletEventMetadata { - ty: meta_type::() + ty: meta_type::() }; - let pallet_index = 0; - let pallet = PalletMetadata { + PalletMetadata { name: "Test", storage: None, calls: None, @@ -399,11 +387,31 @@ mod tests { constants: vec![], error: None, index: pallet_index + } + } + + fn init_decoder(pallets: Vec) -> EventsDecoder { + let extrinsic = ExtrinsicMetadata { + ty: meta_type::<()>(), + version: 0, + signed_extensions: vec![] }; - let v14 = RuntimeMetadataLastVersion::new(vec![pallet], extrinsic, meta_type::<()>()); + let v14 = RuntimeMetadataLastVersion::new(pallets, extrinsic, meta_type::<()>()); let runtime_metadata: RuntimeMetadataPrefixed = v14.into(); let metadata = Metadata::try_from(runtime_metadata).unwrap(); - let decoder = EventsDecoder::::new(metadata); + EventsDecoder::::new(metadata) + } + + #[test] + fn decode_single_event() { + #[derive(Clone, Encode, TypeInfo)] + enum Event { + A(u8), + } + + let pallet_index = 0; + let pallet = pallet_metadata::(pallet_index); + let decoder = init_decoder(vec![pallet]); let event = Event::A(1); let encoded_event = event.encode(); @@ -419,4 +427,30 @@ mod tests { assert_eq!(events[0].1.variant_index, encoded_event[0]); assert_eq!(events[0].1.data.0, encoded_event[1..]); } + + #[test] + fn compact_event_field() { + #[derive(Clone, Encode, TypeInfo)] + enum Event { + A(#[codec(compact)] u32), + } + + let pallet_index = 0; + let pallet = pallet_metadata::(pallet_index); + let decoder = init_decoder(vec![pallet]); + + let event = Event::A(u32::MAX); + let encoded_event = event.encode(); + let event_records = vec![ + event_record(pallet_index, event) + ]; + + let mut input = Vec::new(); + event_records.encode_to(&mut input); + + let events = decoder.decode_events(&mut &input[..]).unwrap(); + + assert_eq!(events[0].1.variant_index, encoded_event[0]); + assert_eq!(events[0].1.data.0, encoded_event[1..]); + } } From 3773bad676ac00b98a20bbf03056630a9cde58f2 Mon Sep 17 00:00:00 2001 From: Andrew Jones Date: Wed, 5 Jan 2022 12:55:14 +0000 Subject: [PATCH 3/8] Fmt --- src/events.rs | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/src/events.rs b/src/events.rs index 7dd7b7dbf1..2387f6c29f 100644 --- a/src/events.rs +++ b/src/events.rs @@ -342,21 +342,25 @@ pub enum EventsDecodingError { #[cfg(test)] mod tests { use super::*; - use std::convert::TryFrom; - use crate::{Config, DefaultConfig, Phase}; + use crate::{ + Config, + DefaultConfig, + Phase, + }; use frame_metadata::{ - RuntimeMetadataPrefixed, v14::{ ExtrinsicMetadata, - RuntimeMetadataLastVersion, - PalletMetadata, PalletEventMetadata, - } + PalletMetadata, + RuntimeMetadataLastVersion, + }, + RuntimeMetadataPrefixed, }; use scale_info::{ + meta_type, TypeInfo, - meta_type }; + use std::convert::TryFrom; #[derive(Encode)] pub struct EventRecord { @@ -371,13 +375,13 @@ mod tests { phase: Phase::Finalization, pallet_index, event, - topics: vec![] + topics: vec![], } } fn pallet_metadata(pallet_index: u8) -> PalletMetadata { let event = PalletEventMetadata { - ty: meta_type::() + ty: meta_type::(), }; PalletMetadata { name: "Test", @@ -386,7 +390,7 @@ mod tests { event: Some(event), constants: vec![], error: None, - index: pallet_index + index: pallet_index, } } @@ -394,7 +398,7 @@ mod tests { let extrinsic = ExtrinsicMetadata { ty: meta_type::<()>(), version: 0, - signed_extensions: vec![] + signed_extensions: vec![], }; let v14 = RuntimeMetadataLastVersion::new(pallets, extrinsic, meta_type::<()>()); let runtime_metadata: RuntimeMetadataPrefixed = v14.into(); @@ -415,9 +419,7 @@ mod tests { let event = Event::A(1); let encoded_event = event.encode(); - let event_records = vec![ - event_record(pallet_index, event) - ]; + let event_records = vec![event_record(pallet_index, event)]; let mut input = Vec::new(); event_records.encode_to(&mut input); @@ -441,9 +443,7 @@ mod tests { let event = Event::A(u32::MAX); let encoded_event = event.encode(); - let event_records = vec![ - event_record(pallet_index, event) - ]; + let event_records = vec![event_record(pallet_index, event)]; let mut input = Vec::new(); event_records.encode_to(&mut input); From de94ab7d870ade5ac586071bbbf3b8a92f622da3 Mon Sep 17 00:00:00 2001 From: Andrew Jones Date: Wed, 5 Jan 2022 12:58:34 +0000 Subject: [PATCH 4/8] Fix compact event field decoding --- src/events.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/events.rs b/src/events.rs index 2387f6c29f..daac1c7a99 100644 --- a/src/events.rs +++ b/src/events.rs @@ -253,10 +253,10 @@ where } } } - TypeDef::Compact(_compact) => { + TypeDef::Compact(compact) => { let inner = self .metadata - .resolve_type(type_id) + .resolve_type(compact.type_param().id()) .ok_or(MetadataError::TypeNotFound(type_id))?; let mut decode_compact_primitive = |primitive: &TypeDefPrimitive| { match primitive { @@ -281,6 +281,7 @@ where } } }; + println!("{:?}", inner.type_def()); match inner.type_def() { TypeDef::Primitive(primitive) => decode_compact_primitive(primitive), TypeDef::Composite(composite) => { From 10c3d51f2fa7ea08a368215fe0db1b0a0ce318b2 Mon Sep 17 00:00:00 2001 From: Andrew Jones Date: Wed, 5 Jan 2022 15:43:53 +0000 Subject: [PATCH 5/8] Remove println --- src/events.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/events.rs b/src/events.rs index daac1c7a99..4508ad20fd 100644 --- a/src/events.rs +++ b/src/events.rs @@ -281,7 +281,6 @@ where } } }; - println!("{:?}", inner.type_def()); match inner.type_def() { TypeDef::Primitive(primitive) => decode_compact_primitive(primitive), TypeDef::Composite(composite) => { From 4e8332ddcd9b758973bdecbea9901c4a378e26b7 Mon Sep 17 00:00:00 2001 From: Andrew Jones Date: Thu, 6 Jan 2022 10:43:35 +0000 Subject: [PATCH 6/8] Add test for compact wrapper struct --- src/events.rs | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/src/events.rs b/src/events.rs index 4508ad20fd..aa2b80ea7c 100644 --- a/src/events.rs +++ b/src/events.rs @@ -431,26 +431,40 @@ mod tests { } #[test] - fn compact_event_field() { + fn compact_fields() { #[derive(Clone, Encode, TypeInfo)] enum Event { A(#[codec(compact)] u32), + B(#[codec(compact)] CompactWrapper), } + #[derive(Clone, codec::CompactAs, Encode, TypeInfo)] + struct CompactWrapper(u64); + let pallet_index = 0; let pallet = pallet_metadata::(pallet_index); let decoder = init_decoder(vec![pallet]); - let event = Event::A(u32::MAX); - let encoded_event = event.encode(); - let event_records = vec![event_record(pallet_index, event)]; + let event1 = Event::A(u32::MAX); + let event2 = Event::B(CompactWrapper(0)); + + let encoded_event1 = event1.encode(); + let encoded_event2 = event2.encode(); + + let event_records = vec![ + event_record(pallet_index, event1), + event_record(pallet_index, event2), + ]; let mut input = Vec::new(); event_records.encode_to(&mut input); let events = decoder.decode_events(&mut &input[..]).unwrap(); - assert_eq!(events[0].1.variant_index, encoded_event[0]); - assert_eq!(events[0].1.data.0, encoded_event[1..]); + assert_eq!(events[0].1.variant_index, encoded_event1[0]); + assert_eq!(events[0].1.data.0, encoded_event1[1..]); + + assert_eq!(events[1].1.variant_index, encoded_event2[0]); + assert_eq!(events[1].1.data.0, encoded_event2[1..]); } } From 4dcdc4a5b6b2d61c5f42320d37460936fe000021 Mon Sep 17 00:00:00 2001 From: Andrew Jones Date: Thu, 6 Jan 2022 10:47:47 +0000 Subject: [PATCH 7/8] Revert "Add test for compact wrapper struct" This reverts commit 4e8332ddcd9b758973bdecbea9901c4a378e26b7. --- src/events.rs | 26 ++++++-------------------- 1 file changed, 6 insertions(+), 20 deletions(-) diff --git a/src/events.rs b/src/events.rs index aa2b80ea7c..4508ad20fd 100644 --- a/src/events.rs +++ b/src/events.rs @@ -431,40 +431,26 @@ mod tests { } #[test] - fn compact_fields() { + fn compact_event_field() { #[derive(Clone, Encode, TypeInfo)] enum Event { A(#[codec(compact)] u32), - B(#[codec(compact)] CompactWrapper), } - #[derive(Clone, codec::CompactAs, Encode, TypeInfo)] - struct CompactWrapper(u64); - let pallet_index = 0; let pallet = pallet_metadata::(pallet_index); let decoder = init_decoder(vec![pallet]); - let event1 = Event::A(u32::MAX); - let event2 = Event::B(CompactWrapper(0)); - - let encoded_event1 = event1.encode(); - let encoded_event2 = event2.encode(); - - let event_records = vec![ - event_record(pallet_index, event1), - event_record(pallet_index, event2), - ]; + let event = Event::A(u32::MAX); + let encoded_event = event.encode(); + let event_records = vec![event_record(pallet_index, event)]; let mut input = Vec::new(); event_records.encode_to(&mut input); let events = decoder.decode_events(&mut &input[..]).unwrap(); - assert_eq!(events[0].1.variant_index, encoded_event1[0]); - assert_eq!(events[0].1.data.0, encoded_event1[1..]); - - assert_eq!(events[1].1.variant_index, encoded_event2[0]); - assert_eq!(events[1].1.data.0, encoded_event2[1..]); + assert_eq!(events[0].1.variant_index, encoded_event[0]); + assert_eq!(events[0].1.data.0, encoded_event[1..]); } } From fe02492382acc874e009abb814e2b294db440187 Mon Sep 17 00:00:00 2001 From: Andrew Jones Date: Thu, 6 Jan 2022 10:55:48 +0000 Subject: [PATCH 8/8] Split compact tests and add multiple events test --- src/events.rs | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) diff --git a/src/events.rs b/src/events.rs index 4508ad20fd..15b74dca6f 100644 --- a/src/events.rs +++ b/src/events.rs @@ -430,6 +430,48 @@ mod tests { assert_eq!(events[0].1.data.0, encoded_event[1..]); } + #[test] + fn decode_multiple_events() { + #[derive(Clone, Encode, TypeInfo)] + enum Event { + A(u8), + B, + C { a: u32 }, + } + + let pallet_index = 0; + let pallet = pallet_metadata::(pallet_index); + let decoder = init_decoder(vec![pallet]); + + let event1 = Event::A(1); + let event2 = Event::B; + let event3 = Event::C { a: 3 }; + + let encoded_event1 = event1.encode(); + let encoded_event2 = event2.encode(); + let encoded_event3 = event3.encode(); + + let event_records = vec![ + event_record(pallet_index, event1), + event_record(pallet_index, event2), + event_record(pallet_index, event3), + ]; + + let mut input = Vec::new(); + event_records.encode_to(&mut input); + + let events = decoder.decode_events(&mut &input[..]).unwrap(); + + assert_eq!(events[0].1.variant_index, encoded_event1[0]); + assert_eq!(events[0].1.data.0, encoded_event1[1..]); + + assert_eq!(events[1].1.variant_index, encoded_event2[0]); + assert_eq!(events[1].1.data.0, encoded_event2[1..]); + + assert_eq!(events[2].1.variant_index, encoded_event3[0]); + assert_eq!(events[2].1.data.0, encoded_event3[1..]); + } + #[test] fn compact_event_field() { #[derive(Clone, Encode, TypeInfo)] @@ -453,4 +495,31 @@ mod tests { assert_eq!(events[0].1.variant_index, encoded_event[0]); assert_eq!(events[0].1.data.0, encoded_event[1..]); } + + #[test] + fn compact_wrapper_struct_field() { + #[derive(Clone, Encode, TypeInfo)] + enum Event { + A(#[codec(compact)] CompactWrapper), + } + + #[derive(Clone, codec::CompactAs, Encode, TypeInfo)] + struct CompactWrapper(u64); + + let pallet_index = 0; + let pallet = pallet_metadata::(pallet_index); + let decoder = init_decoder(vec![pallet]); + + let event = Event::A(CompactWrapper(0)); + let encoded_event = event.encode(); + let event_records = vec![event_record(pallet_index, event)]; + + let mut input = Vec::new(); + event_records.encode_to(&mut input); + + let events = decoder.decode_events(&mut &input[..]).unwrap(); + + assert_eq!(events[0].1.variant_index, encoded_event[0]); + assert_eq!(events[0].1.data.0, encoded_event[1..]); + } }