@layerzerolabs/framework-solana-anchor-trait 0.2.60

package/tests/override.rs

@@ -0,0 +1,414 @@
+#[cfg(test)]
+mod tests {
+    use anchor_trait::{InstructionOverrides, InstructionSet, InstructionSpec, OverrideConfig};
+    use quote::ToTokens;
+
+    // -----------------------------------------------------------------------
+    // Test fixtures
+    // -----------------------------------------------------------------------
+    //
+    // NOTE: This file intentionally does NOT use tests/common/mod.rs.
+    // Override collection tests use a minimal TestIx (3 variants, no Token,
+    // unimplemented spec) to prove that collect() works without needing
+    // real InstructionSpec values. Sharing common's 4-variant TestIx would
+    // obscure that property and add unnecessary coupling.
+
+    /// Minimal instruction set for testing. Three variants covering:
+    /// - SetPeer: a typical mutable instruction (has default impl in real usage)
+    /// - GetPeer: a typical view instruction (has default impl in real usage)
+    /// - LzReceive: a required instruction (no default impl in real usage)
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+    enum TestIx {
+        SetPeer,
+        GetPeer,
+        LzReceive,
+    }
+
+    impl InstructionSet for TestIx {
+        type Ctx = ();
+
+        fn all() -> &'static [Self] {
+            &[Self::SetPeer, Self::GetPeer, Self::LzReceive]
+        }
+
+        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),
+                _ => None,
+            }
+        }
+
+        fn canonical_name(&self) -> &'static str {
+            match self {
+                Self::SetPeer => "set_peer",
+                Self::GetPeer => "get_peer",
+                Self::LzReceive => "lz_receive",
+            }
+        }
+
+        fn spec(self, _ctx: &()) -> InstructionSpec<()> {
+            // Not called by collect() — only needed for generation tests later.
+            unimplemented!("TestIx::spec() is not used in override collection tests")
+        }
+    }
+
+    const TEST_CONFIG: OverrideConfig =
+        OverrideConfig { attr_name: "test_instruction", domain: "Test" };
+
+    /// Helper: assert collect() succeeds and return the overrides.
+    fn collect_ok(module: &syn::ItemMod) -> InstructionOverrides<TestIx> {
+        InstructionOverrides::<TestIx>::collect(module, TEST_CONFIG)
+            .expect("collect() should succeed")
+    }
+
+    /// Helper: assert collect() fails and return the error message.
+    fn collect_err(module: &syn::ItemMod) -> String {
+        match InstructionOverrides::<TestIx>::collect(module, TEST_CONFIG) {
+            Err(e) => e.to_string(),
+            Ok(_) => panic!("collect() should have failed but succeeded"),
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Tests — override collection (happy path)
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn empty_module_returns_no_overrides() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {}
+        };
+        let overrides = collect_ok(&module);
+        assert!(overrides.get(TestIx::SetPeer).is_none());
+        assert!(overrides.get(TestIx::GetPeer).is_none());
+        assert!(overrides.get(TestIx::LzReceive).is_none());
+    }
+
+    #[test]
+    fn non_handler_functions_are_ignored() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                fn some_helper() -> u64 { 42 }
+                fn another_helper(x: u32) -> u32 { x + 1 }
+            }
+        };
+        let overrides = collect_ok(&module);
+        assert!(overrides.get(TestIx::SetPeer).is_none());
+        assert!(overrides.get(TestIx::GetPeer).is_none());
+        assert!(overrides.get(TestIx::LzReceive).is_none());
+    }
+
+    #[test]
+    fn single_handler_override_detected() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn set_peer(ctx: Context<MyAccounts>, params: SetPeerParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let overrides = collect_ok(&module);
+
+        // SetPeer should be detected
+        let meta = overrides.get(TestIx::SetPeer).expect("SetPeer override should exist");
+        assert_eq!(meta.fn_ident, "set_peer");
+        assert_eq!(meta.accounts_type.to_token_stream().to_string(), "MyAccounts");
+        assert_eq!(meta.wrapper_mod.to_string(), "__test_instruction__set_peer_handler");
+
+        // Others untouched
+        assert!(overrides.get(TestIx::GetPeer).is_none());
+        assert!(overrides.get(TestIx::LzReceive).is_none());
+    }
+
+    #[test]
+    fn multiple_unique_overrides() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn set_peer(ctx: Context<PeerAccounts>, params: SetPeerParams) -> Result<()> {
+                    Ok(())
+                }
+
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<ReceiveAccounts>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let overrides = collect_ok(&module);
+
+        let peer = overrides.get(TestIx::SetPeer).expect("SetPeer should exist");
+        assert_eq!(peer.fn_ident, "set_peer");
+        assert_eq!(peer.accounts_type.to_token_stream().to_string(), "PeerAccounts");
+
+        let recv = overrides.get(TestIx::LzReceive).expect("LzReceive should exist");
+        assert_eq!(recv.fn_ident, "lz_receive");
+        assert_eq!(recv.accounts_type.to_token_stream().to_string(), "ReceiveAccounts");
+
+        assert!(overrides.get(TestIx::GetPeer).is_none());
+    }
+
+    #[test]
+    fn handler_with_lifetime_generics() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn lz_receive<'info>(
+                    ctx: Context<'_, '_, '_, 'info, MyReceiveAccounts<'info>>,
+                    params: LzReceiveParams,
+                ) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let overrides = collect_ok(&module);
+        let meta = overrides.get(TestIx::LzReceive).expect("LzReceive should exist");
+
+        // Inner type is the last type arg: MyReceiveAccounts<'info>
+        assert!(meta
+            .accounts_type
+            .to_token_stream()
+            .to_string()
+            .contains("MyReceiveAccounts < 'info >"));
+
+        // Full context_type preserves all lifetimes
+        let full_ctx = meta.context_type.to_token_stream().to_string();
+        assert!(full_ctx.contains("Context"), "context_type should contain Context: {full_ctx}");
+        assert!(
+            full_ctx.contains("'_"),
+            "context_type should preserve anonymous lifetimes: {full_ctx}"
+        );
+        assert!(
+            full_ctx.contains("'info"),
+            "context_type should preserve named lifetimes: {full_ctx}"
+        );
+
+        // Function-level generics should capture <'info>
+        let generics = meta.fn_generics.to_token_stream().to_string();
+        assert!(generics.contains("'info"), "fn_generics should contain 'info: {generics}");
+    }
+
+    #[test]
+    fn filtered_items_removes_overridden_handlers() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn set_peer(ctx: Context<MyAccounts>, params: SetPeerParams) -> Result<()> {
+                    Ok(())
+                }
+
+                pub fn helper_function() -> u64 {
+                    42
+                }
+
+                struct MyState {
+                    value: u64,
+                }
+            }
+        };
+        let overrides = collect_ok(&module);
+        let filtered = overrides.filtered_items(&module).to_string();
+
+        // Override handler should be removed
+        assert!(!filtered.contains("set_peer"), "overridden handler should be filtered out");
+
+        // Regular items should remain
+        assert!(filtered.contains("helper_function"), "regular fn should be kept");
+        assert!(filtered.contains("MyState"), "struct should be kept");
+    }
+
+    // -----------------------------------------------------------------------
+    // Tests — wrapper module generation
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn wrapper_defs_contain_relocated_handler() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn get_peer(ctx: Context<GetPeerAccounts>, params: GetPeerParams) -> Result<[u8; 32]> {
+                    Ok([0u8; 32])
+                }
+            }
+        };
+        let overrides = collect_ok(&module);
+        let wrapper = overrides.wrapper_defs.to_string();
+
+        // Wrapper module should exist with the correct name
+        assert!(
+            wrapper.contains("__test_instruction__get_peer_handler"),
+            "wrapper module should be named correctly: {wrapper}"
+        );
+
+        // Handler function should be inside the wrapper
+        assert!(wrapper.contains("get_peer"), "handler fn should be inside wrapper: {wrapper}");
+
+        // The override attribute should be stripped from the relocated handler.
+        // The module name itself contains "test_instruction", so check for the
+        // attribute syntax specifically: `# [test_instruction` (tokenized form).
+        assert!(
+            !wrapper.contains("# [test_instruction"),
+            "override attr should be stripped in wrapper: {wrapper}"
+        );
+
+        // Wrapper should import parent scope
+        assert!(
+            wrapper.contains("use super :: *"),
+            "wrapper should have `use super::*`: {wrapper}"
+        );
+    }
+
+    // -----------------------------------------------------------------------
+    // Tests — error cases
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn error_unknown_instruction_name() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn nonexistent(ctx: Context<Foo>) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let err = collect_err(&module);
+        assert!(err.contains("unsupported"), "error should mention unsupported: {err}");
+        assert!(err.contains("nonexistent"), "error should mention the bad name: {err}");
+    }
+
+    #[test]
+    fn error_attribute_with_arguments_rejected() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction(set_peer)]
+                pub fn set_peer(ctx: Context<Foo>) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let err = collect_err(&module);
+        assert!(
+            err.contains("does not accept arguments"),
+            "error should mention no arguments allowed: {err}"
+        );
+    }
+
+    #[test]
+    fn error_handler_missing_context_param() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn set_peer() -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let err = collect_err(&module);
+        assert!(err.contains("Context"), "error should mention Context<T>: {err}");
+    }
+
+    #[test]
+    fn error_handler_wrong_first_param_type() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn set_peer(x: u64) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let err = collect_err(&module);
+        assert!(err.contains("Context"), "error should mention Context<T>: {err}");
+    }
+
+    #[test]
+    fn error_bare_function_name_collision() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                pub fn set_peer(ctx: Context<Foo>) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let err = collect_err(&module);
+        assert!(err.contains("conflicts"), "error should mention conflict: {err}");
+        assert!(err.contains("set_peer"), "error should mention the function name: {err}");
+    }
+
+    #[test]
+    fn error_duplicate_attribute_on_single_function() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                #[test_instruction]
+                pub fn set_peer(ctx: Context<Foo>) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let err = collect_err(&module);
+        assert!(err.contains("duplicate"), "error should mention duplicate: {err}");
+    }
+
+    // -----------------------------------------------------------------------
+    // Tests — boundary conditions
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn bodiless_module_returns_no_overrides() {
+        // `mod foo;` (no body) — collect should return empty, not panic.
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program;
+        };
+        let overrides = collect_ok(&module);
+        assert!(overrides.get(TestIx::SetPeer).is_none());
+        assert!(overrides.get(TestIx::GetPeer).is_none());
+        assert!(overrides.get(TestIx::LzReceive).is_none());
+    }
+
+    #[test]
+    fn filtered_items_on_bodiless_module_returns_empty() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program;
+        };
+        let overrides = collect_ok(&module);
+        let filtered = overrides.filtered_items(&module).to_string();
+        assert!(
+            filtered.is_empty(),
+            "filtered_items on bodiless module should be empty: {filtered}"
+        );
+    }
+
+    #[test]
+    fn non_override_attrs_preserved_in_wrapper() {
+        // A handler with both the override attr and another attr — the
+        // non-override attr should survive relocation into the wrapper module.
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[inline(always)]
+                #[test_instruction]
+                pub fn set_peer(ctx: Context<MyAccounts>, params: SetPeerParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let overrides = collect_ok(&module);
+        let wrapper = overrides.wrapper_defs.to_string();
+
+        // The override attr should be stripped
+        assert!(
+            !wrapper.contains("# [test_instruction"),
+            "override attr should be stripped: {wrapper}"
+        );
+
+        // The #[inline(always)] attr should be preserved
+        assert!(
+            wrapper.contains("inline"),
+            "non-override attrs should be preserved in wrapper: {wrapper}"
+        );
+    }
+}

package/tests/snapshots/snapshots__tests__snapshot_all_defaults.snap

@@ -0,0 +1,35 @@
+---
+source: crates/anchor-trait/tests/snapshots.rs
+expression: output
+---
+mod __test_instruction__lz_receive_handler {
+    use super::*;
+    pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+        Ok(())
+    }
+}
+struct StdSetPeer;
+struct StdGetPeer;
+struct StdToken;
+#[program]
+pub mod my_program {
+    use super::*;
+    pub fn set_peer(mut ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+        StdSetPeer::apply(&mut ctx, &params)
+    }
+    pub fn get_peer(
+        ctx: Context<StdGetPeer>,
+        params: GetPeerParams,
+    ) -> Result<[u8; 32]> {
+        StdGetPeer::apply(&ctx, &params)
+    }
+    pub fn lz_receive(
+        mut ctx: Context<MyReceive>,
+        params: LzReceiveParams,
+    ) -> Result<()> {
+        __test_instruction__lz_receive_handler::lz_receive(ctx, params)
+    }
+    pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
+        StdToken::apply(&ctx)
+    }
+}

package/tests/snapshots/snapshots__tests__snapshot_full_override.snap

@@ -0,0 +1,47 @@
+---
+source: crates/anchor-trait/tests/snapshots.rs
+expression: output
+---
+mod __test_instruction__set_peer_handler {
+    use super::*;
+    pub fn set_peer(
+        ctx: Context<MyCustomAccounts>,
+        params: SetPeerParams,
+    ) -> Result<()> {
+        msg!("fully custom set_peer");
+        Ok(())
+    }
+}
+mod __test_instruction__lz_receive_handler {
+    use super::*;
+    pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+        Ok(())
+    }
+}
+struct StdGetPeer;
+struct StdToken;
+#[program]
+pub mod my_program {
+    use super::*;
+    pub fn set_peer(
+        mut ctx: Context<MyCustomAccounts>,
+        params: SetPeerParams,
+    ) -> Result<()> {
+        __test_instruction__set_peer_handler::set_peer(ctx, params)
+    }
+    pub fn get_peer(
+        ctx: Context<StdGetPeer>,
+        params: GetPeerParams,
+    ) -> Result<[u8; 32]> {
+        StdGetPeer::apply(&ctx, &params)
+    }
+    pub fn lz_receive(
+        mut ctx: Context<MyReceive>,
+        params: LzReceiveParams,
+    ) -> Result<()> {
+        __test_instruction__lz_receive_handler::lz_receive(ctx, params)
+    }
+    pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
+        StdToken::apply(&ctx)
+    }
+}

package/tests/snapshots/snapshots__tests__snapshot_handler_override.snap

@@ -0,0 +1,42 @@
+---
+source: crates/anchor-trait/tests/snapshots.rs
+expression: output
+---
+mod __test_instruction__set_peer_handler {
+    use super::*;
+    pub fn set_peer(ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+        msg!("custom set_peer logic");
+        Ok(())
+    }
+}
+mod __test_instruction__lz_receive_handler {
+    use super::*;
+    pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+        Ok(())
+    }
+}
+struct StdSetPeer;
+struct StdGetPeer;
+struct StdToken;
+#[program]
+pub mod my_program {
+    use super::*;
+    pub fn set_peer(mut ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+        __test_instruction__set_peer_handler::set_peer(ctx, params)
+    }
+    pub fn get_peer(
+        ctx: Context<StdGetPeer>,
+        params: GetPeerParams,
+    ) -> Result<[u8; 32]> {
+        StdGetPeer::apply(&ctx, &params)
+    }
+    pub fn lz_receive(
+        mut ctx: Context<MyReceive>,
+        params: LzReceiveParams,
+    ) -> Result<()> {
+        __test_instruction__lz_receive_handler::lz_receive(ctx, params)
+    }
+    pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
+        StdToken::apply(&ctx)
+    }
+}

package/tests/snapshots/snapshots__tests__snapshot_mixed_overrides.snap

@@ -0,0 +1,57 @@
+---
+source: crates/anchor-trait/tests/snapshots.rs
+expression: output
+---
+struct PreludeMarker;
+mod __test_instruction__set_peer_handler {
+    use super::*;
+    pub fn set_peer(ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+        msg!("handler override set_peer");
+        Ok(())
+    }
+}
+mod __test_instruction__get_peer_handler {
+    use super::*;
+    pub fn get_peer(
+        ctx: Context<MyCustomGetPeer>,
+        params: GetPeerParams,
+    ) -> Result<[u8; 32]> {
+        Ok([0u8; 32])
+    }
+}
+mod __test_instruction__lz_receive_handler {
+    use super::*;
+    pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+        Ok(())
+    }
+}
+struct StdSetPeer;
+struct StdToken;
+#[program]
+pub mod my_program {
+    use super::*;
+    pub fn helper() -> u64 {
+        42
+    }
+    struct MyState {
+        value: u64,
+    }
+    pub fn set_peer(mut ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+        __test_instruction__set_peer_handler::set_peer(ctx, params)
+    }
+    pub fn get_peer(
+        ctx: Context<MyCustomGetPeer>,
+        params: GetPeerParams,
+    ) -> Result<[u8; 32]> {
+        __test_instruction__get_peer_handler::get_peer(ctx, params)
+    }
+    pub fn lz_receive(
+        mut ctx: Context<MyReceive>,
+        params: LzReceiveParams,
+    ) -> Result<()> {
+        __test_instruction__lz_receive_handler::lz_receive(ctx, params)
+    }
+    pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
+        StdToken::apply(&ctx)
+    }
+}