testing: Prepare light client testing with substrate binary and add subxt-test macro

Cargo.toml

@@ -7,6 +7,7 @@ members = [
     "testing/substrate-runner",
     "testing/test-runtime",
     "testing/integration-tests",
+    "testing/integration-tests/proc-macro",
     "testing/ui-tests",
     "testing/generate-custom-metadata",
     "macro",

subxt/src/backend/unstable/rpc_methods.rs

@@ -11,7 +11,7 @@ use crate::config::BlockHash;
 use crate::{Config, Error};
 use derive_where::derive_where;
 use futures::{Stream, StreamExt};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use std::collections::{HashMap, VecDeque};
 use std::task::Poll;
 
@@ -377,8 +377,7 @@ pub enum FollowEvent<Hash> {
 ///
 /// This is the first event generated by the `follow` subscription
 /// and is submitted only once.
-#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
-#[serde(rename_all = "camelCase")]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Initialized<Hash> {
     /// The hashes of the last finalized blocks.
     pub finalized_block_hashes: Vec<Hash>,
@@ -391,6 +390,30 @@ pub struct Initialized<Hash> {
     pub finalized_block_runtime: Option<RuntimeEvent>,
 }
 
+impl<'de, Hash: Deserialize<'de>> Deserialize<'de> for Initialized<Hash> {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        // Custom struct that can deserialize both `finalizedBlockHash` and `finalizedBlockHashes`.
+        #[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+        #[serde(rename_all = "camelCase")]
+        struct InitializedIR<Hash> {
+            finalized_block_hashes: Option<Vec<Hash>>,
+            finalized_block_hash: Option<Hash>,
+            finalized_block_runtime: Option<RuntimeEvent>,
+        }
+
+        let ir = InitializedIR::deserialize(deserializer)?;
+        let finalized_block_hashes = ir
+            .finalized_block_hashes
+            .or_else(|| ir.finalized_block_hash.map(|hash| vec![hash]))
+            .ok_or_else(|| serde::de::Error::custom("Missing finalized block hashes"))?;
+
+        Ok(Initialized {
+            finalized_block_hashes,
+            finalized_block_runtime: ir.finalized_block_runtime,
+        })
+    }
+}
+
 /// The runtime event generated if the `follow` subscription
 /// has set the `with_runtime` flag.
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
@@ -973,4 +996,30 @@ mod test {
         let _ = serde_json::from_value::<Foo32>(from_err)
             .expect_err("can't deser invalid num into u32");
     }
+
+    #[test]
+    fn chain_head_initialized() {
+        // Latest format version.
+        let event = serde_json::json!({
+            "finalizedBlockHashes": ["0x1", "0x2"],
+        });
+        let decoded: Initialized<String> = serde_json::from_value(event).unwrap();
+        assert_eq!(
+            decoded.finalized_block_hashes,
+            vec!["0x1".to_string(), "0x2".to_string()]
+        );
+
+        // Old format.
+        let event = serde_json::json!({
+            "finalizedBlockHash": "0x1",
+        });
+        let decoded: Initialized<String> = serde_json::from_value(event).unwrap();
+        assert_eq!(decoded.finalized_block_hashes, vec!["0x1".to_string()]);
+
+        // Wrong format.
+        let event = serde_json::json!({
+            "finalizedBlockHash": ["0x1"],
+        });
+        let _ = serde_json::from_value::<Initialized<String>>(event).unwrap_err();
+    }
 }

testing/integration-tests/Cargo.toml

@@ -18,6 +18,9 @@ default = []
 # Enable to run the tests with Light Client support.
 unstable-light-client = ["subxt/unstable-light-client"]
 
+# Enable to run the full-client tests with Light Client support.
+unstable-light-client-long-running = ["subxt/unstable-light-client"]
+
 # Enable this to use the unstable backend in tests _instead of_
 # the default one which relies on the "old" RPC methods.
 unstable-backend-client = []
@@ -43,3 +46,7 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 wabt = { workspace = true }
 substrate-runner = { workspace = true }
+subxt-test-proc-macro = { path = "proc-macro" }
+
+[build-dependencies]
+cfg_aliases = "0.2.0"

testing/integration-tests/build.rs

@@ -0,0 +1,9 @@
+use cfg_aliases::cfg_aliases;
+
+fn main() {
+    // Setup cfg aliases
+    cfg_aliases! {
+        lightclient: { any(feature = "unstable-light-client", feature = "unstable-light-client-long-running") },
+        fullclient: { all(not(feature = "unstable-light-client"), not(feature = "unstable-light-client-long-running")) },
+    }
+}

testing/integration-tests/proc-macro/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "subxt-test-proc-macro"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+publish = false
+
+license.workspace = true
+repository.workspace = true
+documentation.workspace = true
+homepage.workspace = true
+description = "Subxt integration tests proc-macros"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { workspace = true }
+quote = { workspace = true }

testing/integration-tests/proc-macro/src/lib.rs

@@ -0,0 +1,95 @@
+// Copyright 2019-2023 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+use quote::{format_ident, quote};
+use syn::{
+    parse::{Parse, ParseStream},
+    Error,
+};
+
+/// Environment variable for setting the timeout for the test.
+const SUBXT_TEST_TIMEOUT: &str = "SUBXT_TEST_TIMEOUT";
+
+/// Default timeout for the test.
+const DEFAULT_TIMEOUT: u64 = 60 * 6;
+
+#[proc_macro_attribute]
+pub fn subxt_test(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let subxt_attr = match syn::parse::<SubxtTestAttr>(attr) {
+        Ok(subxt_attr) => subxt_attr,
+        Err(err) => return err.into_compile_error().into(),
+    };
+
+    // Timeout is determined by:
+    // - The timeout attribute if it is set.
+    // - The SUBXT_TEST_TIMEOUT environment variable if it is set.
+    // - A default of 6 minutes.
+    let timeout_duration = subxt_attr.timeout.unwrap_or_else(|| {
+        std::env::var(SUBXT_TEST_TIMEOUT)
+            .map(|str| str.parse().unwrap_or(DEFAULT_TIMEOUT))
+            .unwrap_or(DEFAULT_TIMEOUT)
+    });
+
+    let func: syn::ItemFn = match syn::parse(item) {
+        Ok(func) => func,
+        Err(err) => return err.into_compile_error().into(),
+    };
+
+    let func_attrs = &func.attrs;
+    let func_vis = &func.vis;
+    let func_sig = &func.sig;
+    let func_block = &func.block;
+
+    let mut inner_func_sig = func.sig.clone();
+    inner_func_sig.ident = format_ident!("{}_inner", inner_func_sig.ident);
+    let inner_func_name = &inner_func_sig.ident;
+
+    let result = quote! {
+        #[tokio::test]
+        #( #func_attrs )*
+        #func_vis #func_sig {
+            #func_vis #inner_func_sig
+            #func_block
+
+            tokio::time::timeout(std::time::Duration::from_secs(#timeout_duration), #inner_func_name())
+                .await
+                .expect("Test timedout")
+        }
+    };
+    result.into()
+}
+
+mod keywords {
+    syn::custom_keyword!(timeout);
+}
+
+struct SubxtTestAttr {
+    timeout: Option<u64>,
+}
+
+impl Parse for SubxtTestAttr {
+    fn parse(input: ParseStream) -> Result<Self, Error> {
+        if input.is_empty() {
+            return Ok(Self { timeout: None });
+        }
+
+        let _keyword = input.parse::<keywords::timeout>()?;
+        input.parse::<syn::token::Eq>()?;
+        let timeout = input.parse::<syn::LitInt>()?.base10_parse::<u64>()?;
+
+        if !input.is_empty() {
+            return Err(Error::new(
+                input.span(),
+                "Expected tokens: `timeout = value`",
+            ));
+        }
+
+        Ok(Self {
+            timeout: Some(timeout),
+        })
+    }
+}

testing/integration-tests/src/full_client/blocks/mod.rs

@@ -2,17 +2,27 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
-use crate::{test_context, utils::node_runtime};
+use crate::{subxt_test, test_context};
 use codec::{Compact, Encode};
 use futures::StreamExt;
+
+#[cfg(fullclient)]
+use crate::utils::node_runtime;
+#[cfg(fullclient)]
 use subxt::config::signed_extensions::{ChargeAssetTxPayment, CheckMortality, CheckNonce};
+#[cfg(fullclient)]
 use subxt::config::DefaultExtrinsicParamsBuilder;
+#[cfg(fullclient)]
 use subxt::config::SubstrateConfig;
+#[cfg(fullclient)]
 use subxt::utils::Era;
-use subxt_metadata::Metadata;
+#[cfg(fullclient)]
 use subxt_signer::sr25519::dev;
 
-#[tokio::test]
+use subxt_metadata::Metadata;
+
+#[cfg(fullclient)]
+#[subxt_test]
 async fn block_subscriptions_are_consistent_with_eachother() -> Result<(), subxt::Error> {
     let ctx = test_context().await;
     let api = ctx.client();
@@ -76,7 +86,7 @@ async fn block_subscriptions_are_consistent_with_eachother() -> Result<(), subxt
     Ok(())
 }
 
-#[tokio::test]
+#[subxt_test]
 async fn finalized_headers_subscription() -> Result<(), subxt::Error> {
     let ctx = test_context().await;
     let api = ctx.client();
@@ -93,7 +103,7 @@ async fn finalized_headers_subscription() -> Result<(), subxt::Error> {
     Ok(())
 }
 
-#[tokio::test]
+#[subxt_test]
 async fn missing_block_headers_will_be_filled_in() -> Result<(), subxt::Error> {
     use subxt::backend::legacy;
 
@@ -138,7 +148,7 @@ async fn missing_block_headers_will_be_filled_in() -> Result<(), subxt::Error> {
 }
 
 // Check that we can subscribe to non-finalized blocks.
-#[tokio::test]
+#[subxt_test]
 async fn runtime_api_call() -> Result<(), subxt::Error> {
     let ctx = test_context().await;
     let api = ctx.client();
@@ -163,7 +173,8 @@ async fn runtime_api_call() -> Result<(), subxt::Error> {
     Ok(())
 }
 
-#[tokio::test]
+#[cfg(fullclient)]
+#[subxt_test]
 async fn fetch_block_and_decode_extrinsic_details() {
     let ctx = test_context().await;
     let api = ctx.client();
@@ -232,7 +243,8 @@ async fn fetch_block_and_decode_extrinsic_details() {
     assert!(tx.is_signed());
 }
 
-#[tokio::test]
+#[cfg(fullclient)]
+#[subxt_test]
 async fn decode_signed_extensions_from_blocks() {
     let ctx = test_context().await;
     let api = ctx.client();