@layerzerolabs/framework-solana-anchor-trait 0.2.60

package/tests/common/mod.rs

@@ -0,0 +1,206 @@
+//! Shared test fixtures and helpers for anchor-trait integration tests.
+
+#![allow(dead_code)]
+
+use anchor_trait::{
+    generate_instructions, DefaultImpl, GeneratedInstructions, InstructionOverrides,
+    InstructionSet, InstructionSpec, OverrideConfig,
+};
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote, ToTokens};
+use syn::{FnArg, GenericArgument, ItemFn, ItemStruct, Pat, PatIdent, PathArguments, Type};
+
+// ---------------------------------------------------------------------------
+// Test instruction set
+// ---------------------------------------------------------------------------
+
+/// Instruction set shared across generation and assembly tests.
+///
+/// - SetPeer: mutable, has params, has default impl (provided)
+/// - GetPeer: view, has params, has default impl (provided)
+/// - LzReceive: mutable, has params, NO default impl (required)
+/// - Token: view, NO params, has default impl (provided)
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum TestIx {
+    SetPeer,
+    GetPeer,
+    LzReceive,
+    Token,
+}
+
+/// Dummy codegen context.
+pub struct TestCtx;
+
+/// Generates a placeholder default impl (struct only) named after the instruction's
+/// default accounts type, mirroring real codegen which emits instruction-specific structs.
+pub fn gen_default_impl(_ctx: &TestCtx, spec: &InstructionSpec<TestCtx>) -> TokenStream {
+    let ident = &spec.default_impl.as_ref().unwrap().accounts_ident;
+    quote! { struct #ident; }
+}
+
+impl InstructionSet for TestIx {
+    type Ctx = TestCtx;
+
+    fn all() -> &'static [Self] {
+        &[Self::SetPeer, Self::GetPeer, Self::LzReceive, Self::Token]
+    }
+
+    fn from_ident(ident: &syn::Ident) -> Option<Self> {
+        match ident.to_string().as_str() {
+            "set_peer" => Some(Self::SetPeer),
+            "get_peer" => Some(Self::GetPeer),
+            "lz_receive" => Some(Self::LzReceive),
+            "token" => Some(Self::Token),
+            _ => None,
+        }
+    }
+
+    fn canonical_name(&self) -> &'static str {
+        match self {
+            Self::SetPeer => "set_peer",
+            Self::GetPeer => "get_peer",
+            Self::LzReceive => "lz_receive",
+            Self::Token => "token",
+        }
+    }
+
+    fn spec(self, _ctx: &Self::Ctx) -> InstructionSpec<TestCtx> {
+        match self {
+            Self::SetPeer => InstructionSpec {
+                params_type: Some(quote!(SetPeerParams)),
+                return_type: quote!(()),
+                is_view: false,
+                default_impl: Some(DefaultImpl {
+                    accounts_ident: format_ident!("StdSetPeer"),
+                    handler_ident: format_ident!("apply"),
+                    generator: gen_default_impl,
+                }),
+            },
+            Self::GetPeer => InstructionSpec {
+                params_type: Some(quote!(GetPeerParams)),
+                return_type: quote!([u8; 32]),
+                is_view: true,
+                default_impl: Some(DefaultImpl {
+                    accounts_ident: format_ident!("StdGetPeer"),
+                    handler_ident: format_ident!("apply"),
+                    generator: gen_default_impl,
+                }),
+            },
+            Self::LzReceive => InstructionSpec {
+                params_type: Some(quote!(LzReceiveParams)),
+                return_type: quote!(()),
+                is_view: false,
+                default_impl: None, // required — no default
+            },
+            Self::Token => InstructionSpec {
+                params_type: None, // no params
+                return_type: quote!(Pubkey),
+                is_view: true,
+                default_impl: Some(DefaultImpl {
+                    accounts_ident: format_ident!("StdToken"),
+                    handler_ident: format_ident!("apply"),
+                    generator: gen_default_impl,
+                }),
+            },
+        }
+    }
+}
+
+pub const TEST_CONFIG: OverrideConfig =
+    OverrideConfig { attr_name: "test_instruction", domain: "Test" };
+
+// ---------------------------------------------------------------------------
+// Pipeline helpers
+// ---------------------------------------------------------------------------
+
+/// Collect overrides from a module and run generation.
+pub fn generate_ok(module: &syn::ItemMod) -> GeneratedInstructions {
+    let overrides = InstructionOverrides::<TestIx>::collect(module, TEST_CONFIG)
+        .expect("collect() should succeed");
+    generate_instructions(&TestCtx, &overrides).expect("generate should succeed")
+}
+
+/// Collect overrides and expect generation to fail.
+pub fn generate_err(module: &syn::ItemMod) -> String {
+    let overrides = InstructionOverrides::<TestIx>::collect(module, TEST_CONFIG)
+        .expect("collect() should succeed");
+    match generate_instructions(&TestCtx, &overrides) {
+        Err(e) => e.to_string(),
+        Ok(_) => panic!("generate should have failed but succeeded"),
+    }
+}
+
+/// Collect overrides from a module (for assembly tests that need the overrides directly).
+pub fn collect_overrides(module: &syn::ItemMod) -> InstructionOverrides<TestIx> {
+    InstructionOverrides::<TestIx>::collect(module, TEST_CONFIG).expect("collect() should succeed")
+}
+
+// ---------------------------------------------------------------------------
+// AST assertion helpers
+// ---------------------------------------------------------------------------
+
+/// Parse a token stream and extract all function items.
+pub fn parse_fns(ts: &TokenStream) -> Vec<ItemFn> {
+    let file: syn::File = syn::parse2(quote! { #ts }).expect("should parse as File");
+    file.items
+        .into_iter()
+        .filter_map(|item| match item {
+            syn::Item::Fn(f) => Some(f),
+            _ => None,
+        })
+        .collect()
+}
+
+/// Parse a token stream and extract all struct items.
+pub fn parse_structs(ts: &TokenStream) -> Vec<ItemStruct> {
+    let file: syn::File = syn::parse2(quote! { #ts }).expect("should parse as File");
+    file.items
+        .into_iter()
+        .filter_map(|item| match item {
+            syn::Item::Struct(s) => Some(s),
+            _ => None,
+        })
+        .collect()
+}
+
+/// Find a function by name in a list of parsed functions.
+pub fn find_fn<'a>(fns: &'a [ItemFn], name: &str) -> Option<&'a ItemFn> {
+    fns.iter().find(|f| f.sig.ident == name)
+}
+
+/// Find a struct by name in a list of parsed structs.
+pub fn find_struct<'a>(structs: &'a [ItemStruct], name: &str) -> Option<&'a ItemStruct> {
+    structs.iter().find(|s| s.ident == name)
+}
+
+/// Extract (is_mut, context_inner_type) from the first parameter of a function.
+/// Expects the first param to be `ctx: Context<T>` or `mut ctx: Context<T>`.
+pub fn first_param_context_type(f: &ItemFn) -> (bool, String) {
+    let arg = f.sig.inputs.first().expect("function should have at least one param");
+
+    let FnArg::Typed(pat_type) = arg else {
+        panic!("expected typed param, got self");
+    };
+
+    // Check mutability from the pattern (mut ctx vs ctx)
+    let is_mut = match pat_type.pat.as_ref() {
+        Pat::Ident(PatIdent { mutability, .. }) => mutability.is_some(),
+        other => panic!("expected ident pattern, got: {}", other.to_token_stream()),
+    };
+
+    // Extract the inner type T from Context<T> (or Context<'a, 'b, ..., T>)
+    let Type::Path(type_path) = pat_type.ty.as_ref() else {
+        panic!("expected path type for ctx param");
+    };
+    let segment = type_path.path.segments.last().expect("empty path");
+    assert_eq!(segment.ident, "Context", "first param should be Context<T>");
+    let PathArguments::AngleBracketed(args) = &segment.arguments else {
+        panic!("Context should have angle bracket args");
+    };
+    let inner = args.args.last().expect("Context should have at least one type arg");
+    let GenericArgument::Type(inner_type) = inner else {
+        panic!("last generic arg should be a type");
+    };
+
+    (is_mut, inner_type.to_token_stream().to_string())
+}

package/tests/declare_instructions.rs

@@ -0,0 +1,206 @@
+//! Tests for the `declare_instructions!` macro.
+
+use anchor_trait::{InstructionSet, InstructionSpec};
+use quote::quote;
+
+// ---------------------------------------------------------------------------
+// Test fixtures — fake modules that declare_instructions! dispatches to
+// ---------------------------------------------------------------------------
+
+struct TestCtx;
+
+/// Module with ctx-passing spec (the `(ctx)` marker form).
+mod alpha {
+    use super::*;
+
+    pub fn spec(_ctx: &TestCtx) -> InstructionSpec<TestCtx> {
+        InstructionSpec {
+            params_type: Some(quote!(AlphaParams)),
+            return_type: quote!(()),
+            is_view: false,
+            default_impl: None,
+        }
+    }
+}
+
+/// Module with no-ctx spec (no marker form).
+mod beta {
+    use super::*;
+
+    pub fn spec() -> InstructionSpec<TestCtx> {
+        InstructionSpec {
+            params_type: None,
+            return_type: quote!(u64),
+            is_view: true,
+            default_impl: None,
+        }
+    }
+}
+
+/// Third module to test with more than two variants.
+mod gamma {
+    use super::*;
+
+    pub fn spec(ctx: &TestCtx) -> InstructionSpec<TestCtx> {
+        let _ = ctx;
+        InstructionSpec {
+            params_type: Some(quote!(GammaParams)),
+            return_type: quote!(bool),
+            is_view: false,
+            default_impl: None,
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Primary invocation — mixed ctx/no-ctx, trailing comma, multiple variants
+// ---------------------------------------------------------------------------
+
+anchor_trait::declare_instructions! {
+    name = TestIx;
+    context = TestCtx;
+
+    Alpha => alpha(ctx),
+    Beta  => beta,
+    Gamma => gamma(ctx),
+}
+
+// ---------------------------------------------------------------------------
+// Compile-time grammar guards
+//
+// These modules exist solely to prove that the macro accepts certain grammar
+// variants. If any of these stops compiling, a future change broke the macro's
+// accepted syntax. No runtime assertions needed — compilation is the test.
+// ---------------------------------------------------------------------------
+
+/// Single-variant invocation. Guards the `)+` (one-or-more) boundary.
+mod single_variant {
+    use super::*;
+
+    anchor_trait::declare_instructions! {
+        name = SingleIx;
+        context = TestCtx;
+
+        Alpha => alpha(ctx),
+    }
+}
+
+/// No trailing comma. Guards the optional `$(,)?` at the end.
+mod no_trailing_comma {
+    use super::*;
+
+    anchor_trait::declare_instructions! {
+        name = NoCommaIx;
+        context = TestCtx;
+
+        Alpha => alpha(ctx),
+        Beta  => beta
+    }
+}
+
+/// All variants use the `(ctx)` marker. Guards that the ctx-passing path
+/// works without any no-ctx variants present.
+mod all_ctx {
+    use super::*;
+
+    anchor_trait::declare_instructions! {
+        name = AllCtxIx;
+        context = TestCtx;
+
+        Alpha => alpha(ctx),
+        Gamma => gamma(ctx),
+    }
+}
+
+/// No variants use the `(ctx)` marker. Guards that the no-ctx path works
+/// without any ctx-passing variants present.
+mod all_no_ctx {
+    use super::*;
+
+    anchor_trait::declare_instructions! {
+        name = AllNoCtxIx;
+        context = TestCtx;
+
+        Beta => beta,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[test]
+fn all_returns_variants_in_declaration_order() {
+    let all = TestIx::all();
+    assert_eq!(all.len(), 3);
+    assert_eq!(all[0], TestIx::Alpha);
+    assert_eq!(all[1], TestIx::Beta);
+    assert_eq!(all[2], TestIx::Gamma);
+}
+
+#[test]
+fn from_ident_maps_canonical_names() {
+    let alpha_ident = syn::Ident::new("alpha", proc_macro2::Span::call_site());
+    let beta_ident = syn::Ident::new("beta", proc_macro2::Span::call_site());
+    let gamma_ident = syn::Ident::new("gamma", proc_macro2::Span::call_site());
+
+    assert_eq!(TestIx::from_ident(&alpha_ident), Some(TestIx::Alpha));
+    assert_eq!(TestIx::from_ident(&beta_ident), Some(TestIx::Beta));
+    assert_eq!(TestIx::from_ident(&gamma_ident), Some(TestIx::Gamma));
+}
+
+#[test]
+fn from_ident_returns_none_for_unknown() {
+    let unknown = syn::Ident::new("nonexistent", proc_macro2::Span::call_site());
+    assert_eq!(TestIx::from_ident(&unknown), None);
+}
+
+#[test]
+fn canonical_name_returns_module_name() {
+    assert_eq!(TestIx::Alpha.canonical_name(), "alpha");
+    assert_eq!(TestIx::Beta.canonical_name(), "beta");
+    assert_eq!(TestIx::Gamma.canonical_name(), "gamma");
+}
+
+#[test]
+fn from_ident_and_canonical_name_are_inverses() {
+    for &variant in TestIx::all() {
+        let name = variant.canonical_name();
+        let ident = syn::Ident::new(name, proc_macro2::Span::call_site());
+        assert_eq!(TestIx::from_ident(&ident), Some(variant), "round-trip failed for {name}");
+    }
+}
+
+#[test]
+fn spec_dispatches_with_ctx_marker() {
+    let ctx = TestCtx;
+    let spec = TestIx::Alpha.spec(&ctx);
+
+    // Alpha uses (ctx) marker → alpha::spec(&ctx)
+    assert!(!spec.is_view, "alpha should be mutable");
+    assert_eq!(spec.params_type.unwrap().to_string(), quote!(AlphaParams).to_string());
+}
+
+#[test]
+fn spec_dispatches_without_ctx_marker() {
+    let ctx = TestCtx;
+    let spec = TestIx::Beta.spec(&ctx);
+
+    // Beta has no ctx marker → beta::spec() (ctx not passed)
+    assert!(spec.is_view, "beta should be a view");
+    assert!(spec.params_type.is_none(), "beta should have no params");
+    assert_eq!(spec.return_type.to_string(), quote!(u64).to_string());
+}
+
+#[test]
+fn ord_matches_declaration_order() {
+    // The macro derives Ord. Enum discriminant order = declaration order,
+    // so Alpha < Beta < Gamma must hold.
+    assert!(TestIx::Alpha < TestIx::Beta);
+    assert!(TestIx::Beta < TestIx::Gamma);
+
+    // Also verify via sort: sorting should be a no-op on all()
+    let mut sorted = TestIx::all().to_vec();
+    sorted.sort();
+    assert_eq!(sorted, TestIx::all());
+}