fix(primitives): enrich error type

pvq-primitives/src/lib.rs

@@ -10,6 +10,9 @@ pub type PvqResponse = Vec<u8>;
 
 #[derive(Debug, Clone, PartialEq, Eq, Encode, Decode, TypeInfo)]
 pub enum PvqError {
+    FailedToDecode,
+    InvalidPvqProgramFormat,
+    QueryExceedsWeightLimit,
     Custom(String),
 }
 

pvq-test-runner/src/lib.rs

@@ -0,0 +1,87 @@
+use parity_scale_codec::Encode;
+use pvq_extension::{extensions_impl, ExtensionsExecutor, InvokeSource};
+
+#[derive(Encode)]
+#[allow(non_camel_case_types)]
+#[allow(dead_code)]
+pub enum ExtensionFungiblesFunctions {
+    #[codec(index = 0)]
+    total_supply { asset: u32 },
+    #[codec(index = 1)]
+    balance { asset: u32, who: [u8; 32] },
+}
+
+#[extensions_impl]
+pub mod extensions {
+    #[extensions_impl::impl_struct]
+    pub struct ExtensionsImpl;
+
+    #[extensions_impl::extension]
+    impl pvq_extension_core::extension::ExtensionCore for ExtensionsImpl {
+        type ExtensionId = u64;
+        fn has_extension(id: Self::ExtensionId) -> bool {
+            matches!(id, 0 | 1)
+        }
+    }
+
+    #[extensions_impl::extension]
+    impl pvq_extension_fungibles::extension::ExtensionFungibles for ExtensionsImpl {
+        type AssetId = u32;
+        type AccountId = [u8; 32];
+        type Balance = u64;
+        fn total_supply(_asset: Self::AssetId) -> Self::Balance {
+            100
+        }
+        fn balance(_asset: Self::AssetId, _who: Self::AccountId) -> Self::Balance {
+            100
+        }
+    }
+}
+
+pub struct TestRunner {
+    executor: ExtensionsExecutor<extensions::Extensions, ()>,
+}
+
+impl TestRunner {
+    pub fn new() -> Self {
+        Self {
+            executor: ExtensionsExecutor::new(InvokeSource::RuntimeAPI),
+        }
+    }
+
+    pub fn prepare_input_data(program_path: &str) -> Vec<u8> {
+        let mut input_data = Vec::new();
+
+        if program_path.contains("sum-balance") {
+            input_data.extend_from_slice(&0u32.encode());
+            input_data.extend_from_slice(&vec![[0u8; 32], [1u8; 32]].encode());
+        } else if program_path.contains("total-supply") {
+            input_data.extend_from_slice(&0u32.encode());
+        } else if program_path.contains("transparent-call") {
+            input_data.extend_from_slice(&4071833530116166512u64.encode());
+            input_data.extend_from_slice(
+                &ExtensionFungiblesFunctions::balance {
+                    asset: 0,
+                    who: [1u8; 32],
+                }
+                .encode(),
+            );
+        }
+
+        input_data
+    }
+
+    pub fn execute_program(
+        &mut self,
+        program_blob: &[u8],
+        input_data: &[u8],
+    ) -> Result<Vec<u8>, pvq_primitives::PvqError> {
+        self.executor.execute_method(program_blob, input_data, 0)
+    }
+}
+
+impl Default for TestRunner {
+    fn default() -> Self {
+        Self::new()
+    }
+}

pvq-test-runner/src/main.rs

@@ -1,8 +1,8 @@
 use clap::Parser;
-use parity_scale_codec::Encode;
-use pvq_extension::{extensions_impl, ExtensionsExecutor, InvokeSource};
 use tracing_subscriber::prelude::*;
 
+use pvq_test_runner::TestRunner;
+
 #[derive(Parser, Debug)]
 #[command(version, about)]
 struct Cli {
@@ -26,63 +26,13 @@ fn main() {
     let cli = Cli::parse();
 
     let blob = std::fs::read(&cli.program).expect("Failed to read program");
-    let mut executor = ExtensionsExecutor::<extensions::Extensions, ()>::new(InvokeSource::RuntimeAPI);
-    let mut input_data = Vec::new();
     let program_str = cli.program.to_string_lossy();
-    if program_str.contains("sum-balance") {
-        input_data.extend_from_slice(&0u32.encode());
-        input_data.extend_from_slice(&vec![[0u8; 32], [1u8; 32]].encode());
-    } else if program_str.contains("total-supply") {
-        input_data.extend_from_slice(&0u32.encode());
-    } else if program_str.contains("transparent-call") {
-        input_data.extend_from_slice(&4071833530116166512u64.encode());
-        input_data.extend_from_slice(
-            &ExtensionFungiblesFunctions::balance {
-                asset: 0,
-                who: [1u8; 32],
-            }
-            .encode(),
-        );
-    }
-    tracing::info!("Input data: {:?}", input_data);
-    let res = executor.execute_method(&blob, &input_data, 0).unwrap();
-
-    tracing::info!("Result: {:?}", res);
-}
 
-#[derive(Encode)]
-#[allow(non_camel_case_types)]
-#[allow(dead_code)]
-enum ExtensionFungiblesFunctions {
-    #[codec(index = 0)]
-    total_supply { asset: u32 },
-    #[codec(index = 1)]
-    balance { asset: u32, who: [u8; 32] },
-}
-
-#[extensions_impl]
-pub mod extensions {
-    #[extensions_impl::impl_struct]
-    pub struct ExtensionsImpl;
+    let input_data = TestRunner::prepare_input_data(&program_str);
+    tracing::info!("Input data: {:?}", input_data);
 
-    #[extensions_impl::extension]
-    impl pvq_extension_core::extension::ExtensionCore for ExtensionsImpl {
-        type ExtensionId = u64;
-        fn has_extension(id: Self::ExtensionId) -> bool {
-            matches!(id, 0 | 1)
-        }
-    }
+    let mut runner = TestRunner::new();
+    let res = runner.execute_program(&blob, &input_data).unwrap();
 
-    #[extensions_impl::extension]
-    impl pvq_extension_fungibles::extension::ExtensionFungibles for ExtensionsImpl {
-        type AssetId = u32;
-        type AccountId = [u8; 32];
-        type Balance = u64;
-        fn total_supply(_asset: Self::AssetId) -> Self::Balance {
-            100
-        }
-        fn balance(_asset: Self::AssetId, _who: Self::AccountId) -> Self::Balance {
-            100
-        }
-    }
+    tracing::info!("Result: {:?}", res);
 }