Introduce xtest macro for externally-visible tests

We want to allow functional tests to be run by other project,
allowing them to replace components, such as the signer.

Author: devrandom

lightning-macros/Cargo.toml

@@ -18,9 +18,12 @@ proc-macro = true
 [features]
 
 [dependencies]
-syn = { version = "2.0.77", default-features = false, features = ["parsing", "printing", "proc-macro", "full"] }
-proc-macro2 = { version = "1.0.86", default-features = false, features = ["proc-macro"] }
+syn = { version = "2.0", default-features = false, features = ["parsing", "printing", "proc-macro", "full"] }
+proc-macro2 = { version = "1.0", default-features = false, features = ["proc-macro"] }
 quote = { version = "1.0", default-features = false, features = ["proc-macro"] }
 
+[dev-dependencies]
+inventory = "0.3"
+
 [lints]
 workspace = true

lightning-macros/src/lib.rs

@@ -22,9 +22,11 @@ extern crate alloc;
 
 use alloc::string::ToString;
 use proc_macro::{Delimiter, Group, TokenStream, TokenTree};
+use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
 use syn::spanned::Spanned;
 use syn::{parse, ImplItemFn, Token};
+use syn::{parse_macro_input, Item};
 
 fn add_async_method(mut parsed: ImplItemFn) -> TokenStream {
 	let output = quote! {
@@ -294,3 +296,124 @@ pub fn drop_legacy_field_definition(expr: TokenStream) -> TokenStream {
 	let out = syn::Expr::Struct(st);
 	quote! { #out }.into()
 }
+
+/// An exposed test.  This is a test that will run locally and also be
+/// made available to other crates that want to run it in their own context.
+///
+/// For example:
+/// ```rust
+/// use lightning_macros::xtest;
+///
+/// fn f1() {}
+///
+/// #[xtest(feature = "_test_utils")]
+/// pub fn test_f1() {
+///     f1();
+/// }
+/// ```
+///
+/// May also be applied to modules, like so:
+///
+/// ```rust
+/// use lightning_macros::xtest;
+///
+/// pub mod tests {
+/// 	use super::*;
+///
+///     fn f1() {}
+///
+/// 	#[xtest(feature = "_externalize_tests")]
+/// 	pub fn test_f1() {
+/// 	    f1();
+/// 	}
+/// }
+/// ```
+///
+/// Which will include the module if we are testing or the `_test_utils` feature
+/// is on.
+#[proc_macro_attribute]
+pub fn xtest(attrs: TokenStream, item: TokenStream) -> TokenStream {
+	let attrs = parse_macro_input!(attrs as TokenStream2);
+	let input = parse_macro_input!(item as Item);
+
+	let expanded = match input {
+		Item::Fn(item_fn) => {
+			let (cfg_attr, submit_attr) = if attrs.is_empty() {
+				(quote! { #[cfg_attr(test, test)] }, quote! { #[cfg(not(test))] })
+			} else {
+				(
+					quote! { #[cfg_attr(test, test)] #[cfg(any(test, #attrs))] },
+					quote! { #[cfg(all(not(test), #attrs))] },
+				)
+			};
+
+			// Check that the function doesn't take args and returns nothing
+			if !item_fn.sig.inputs.is_empty()
+				|| !matches!(item_fn.sig.output, syn::ReturnType::Default)
+			{
+				return syn::Error::new_spanned(
+					item_fn.sig,
+					"xtest functions must not take arguments and must return nothing",
+				)
+				.to_compile_error()
+				.into();
+			}
+
+			// Check for #[should_panic] attribute
+			let should_panic =
+				item_fn.attrs.iter().any(|attr| attr.path().is_ident("should_panic"));
+
+			let fn_name = &item_fn.sig.ident;
+			let fn_name_str = fn_name.to_string();
+			quote! {
+				#cfg_attr
+				#item_fn
+
+				// We submit the test to the inventory only if we're not actually testing
+				#submit_attr
+				inventory::submit! {
+					crate::XTestItem {
+						test_fn: #fn_name,
+						test_name: #fn_name_str,
+						should_panic: #should_panic,
+					}
+				}
+			}
+		},
+		_ => {
+			return syn::Error::new_spanned(
+				input,
+				"xtest can only be applied to functions or modules",
+			)
+			.to_compile_error()
+			.into();
+		},
+	};
+
+	TokenStream::from(expanded)
+}
+
+/// Collects all externalized tests marked with `#[xtest]`
+/// into a vector of `XTestItem`s.  This vector can be
+/// retrieved by calling `get_xtests()`.
+#[proc_macro]
+pub fn xtest_inventory(_input: TokenStream) -> TokenStream {
+	let expanded = quote! {
+		/// An externalized test item, including the test function, name, and whether it is marked with `#[should_panic]`.
+		pub struct XTestItem {
+			pub test_fn: fn(),
+			pub test_name: &'static str,
+			pub should_panic: bool,
+		}
+
+		inventory::collect!(XTestItem);
+
+		pub fn get_xtests() -> Vec<&'static XTestItem> {
+			inventory::iter::<XTestItem>
+				.into_iter()
+				.collect()
+		}
+	};
+
+	TokenStream::from(expanded)
+}