@layerzerolabs/framework-solana-anchor-trait 0.2.60

package/tests/generation.rs

@@ -0,0 +1,358 @@
+mod common;
+
+#[cfg(test)]
+mod tests {
+    use super::common::*;
+    use quote::ToTokens;
+
+    // -----------------------------------------------------------------------
+    // Tests — override level resolution
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn default_level_emits_context_and_entrypoint() {
+        // All defaults — no overrides except required lz_receive
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+
+        // Default impls should be generated for each provided instruction
+        let structs = parse_structs(&gen.default_impls);
+        assert!(find_struct(&structs, "StdSetPeer").is_some(), "should emit StdSetPeer");
+        assert!(find_struct(&structs, "StdGetPeer").is_some(), "should emit StdGetPeer");
+        assert!(find_struct(&structs, "StdToken").is_some(), "should emit StdToken");
+
+        // Entrypoints should include all instructions
+        let fns = parse_fns(&gen.entrypoints);
+        assert!(find_fn(&fns, "set_peer").is_some(), "should have set_peer entrypoint");
+        assert!(find_fn(&fns, "get_peer").is_some(), "should have get_peer entrypoint");
+        assert!(find_fn(&fns, "lz_receive").is_some(), "should have lz_receive entrypoint");
+        assert!(find_fn(&fns, "token").is_some(), "should have token entrypoint");
+    }
+
+    #[test]
+    fn default_mutable_passes_mut_ref() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+        let fns = parse_fns(&gen.entrypoints);
+        let set_peer = find_fn(&fns, "set_peer").expect("set_peer entrypoint should exist");
+
+        // set_peer is mutable (is_view = false), default level → mut ctx: Context<StdSetPeer>
+        let (is_mut, ctx_type) = first_param_context_type(set_peer);
+        assert!(is_mut, "set_peer should have `mut ctx`");
+        assert_eq!(ctx_type, "StdSetPeer", "should use default context type");
+
+        // Default handler called by reference: StdSetPeer::apply(&mut ctx, ...)
+        let body = set_peer.block.to_token_stream().to_string();
+        assert!(
+            body.contains("StdSetPeer :: apply (& mut ctx"),
+            "mutable default should pass &mut ctx to handler: {body}"
+        );
+    }
+
+    #[test]
+    fn default_view_passes_immutable_ref() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+        let fns = parse_fns(&gen.entrypoints);
+        let get_peer = find_fn(&fns, "get_peer").expect("get_peer entrypoint should exist");
+
+        // get_peer is view (is_view = true), default level → ctx: Context<StdGetPeer>
+        let (is_mut, ctx_type) = first_param_context_type(get_peer);
+        assert!(!is_mut, "view default should use `ctx` (no mut)");
+        assert_eq!(ctx_type, "StdGetPeer", "should use default context type");
+
+        // Default handler called by immutable reference: StdGetPeer::apply(&ctx, ...)
+        let body = get_peer.block.to_token_stream().to_string();
+        assert!(
+            body.contains("StdGetPeer :: apply (& ctx"),
+            "view default should pass &ctx to handler: {body}"
+        );
+    }
+
+    #[test]
+    fn handler_override_emits_default_context() {
+        // Override set_peer but reuse StdSetPeer context
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn set_peer(ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+                    Ok(())
+                }
+
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+
+        // Default impl should still be generated (handler reuses it)
+        let structs = parse_structs(&gen.default_impls);
+        assert!(
+            find_struct(&structs, "StdSetPeer").is_some(),
+            "handler override should still emit StdSetPeer context"
+        );
+
+        // Entrypoint should dispatch to wrapper
+        let fns = parse_fns(&gen.entrypoints);
+        let set_peer = find_fn(&fns, "set_peer").expect("set_peer entrypoint should exist");
+        let body = set_peer.block.to_token_stream().to_string();
+        assert!(
+            body.contains("__test_instruction__set_peer_handler :: set_peer"),
+            "should dispatch to wrapper handler: {body}"
+        );
+    }
+
+    #[test]
+    fn full_override_skips_default_context() {
+        // Override set_peer with a custom context type (not StdSetPeer)
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn set_peer(ctx: Context<MyCustomAccounts>, params: SetPeerParams) -> Result<()> {
+                    Ok(())
+                }
+
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+
+        // Full override should NOT emit default impl for set_peer.
+        // Other provided instructions (get_peer, token) still get their defaults.
+        let structs = parse_structs(&gen.default_impls);
+        assert!(
+            find_struct(&structs, "StdSetPeer").is_none(),
+            "full override should skip default impl for set_peer"
+        );
+        assert!(
+            find_struct(&structs, "StdGetPeer").is_some(),
+            "get_peer should still have default"
+        );
+        assert!(find_struct(&structs, "StdToken").is_some(), "token should still have default");
+
+        // Entrypoint should use the custom context type
+        let fns = parse_fns(&gen.entrypoints);
+        let set_peer = find_fn(&fns, "set_peer").expect("set_peer entrypoint should exist");
+        let (is_mut, ctx_type) = first_param_context_type(set_peer);
+        assert!(is_mut, "set_peer should have `mut ctx`");
+        assert_eq!(ctx_type, "MyCustomAccounts", "full override should use custom context type");
+
+        // Should dispatch to wrapper
+        let body = set_peer.block.to_token_stream().to_string();
+        assert!(
+            body.contains("__test_instruction__set_peer_handler :: set_peer"),
+            "should dispatch to wrapper handler: {body}"
+        );
+    }
+
+    #[test]
+    fn override_receives_params_by_value() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn set_peer(ctx: Context<MyAccounts>, params: SetPeerParams) -> Result<()> {
+                    Ok(())
+                }
+
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+        let fns = parse_fns(&gen.entrypoints);
+        let set_peer = find_fn(&fns, "set_peer").expect("set_peer entrypoint should exist");
+
+        // Override handlers get (ctx, params) by value — no & or &mut on the call
+        let body = set_peer.block.to_token_stream().to_string();
+        assert!(
+            body.contains("set_peer (ctx , params)"),
+            "override should pass ctx and params by value: {body}"
+        );
+    }
+
+    #[test]
+    fn no_params_instruction_generates_parameterless_entrypoint() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+        let fns = parse_fns(&gen.entrypoints);
+        let token = find_fn(&fns, "token").expect("token entrypoint should exist");
+
+        // Token instruction has no params — entrypoint should only have ctx
+        assert_eq!(token.sig.inputs.len(), 1, "no-params instruction should have only ctx");
+        let (is_mut, ctx_type) = first_param_context_type(token);
+        assert!(!is_mut, "token is a view — should not be mut");
+        assert_eq!(ctx_type, "StdToken", "should use default context type");
+    }
+
+    // -----------------------------------------------------------------------
+    // Tests — boundary conditions
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn view_override_with_params_gets_immutable_ctx() {
+        // Override get_peer (view, has params) — entrypoint should have
+        // immutable ctx and dispatch to wrapper with (ctx, params) by value.
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn get_peer(ctx: Context<MyGetPeerAccounts>, params: GetPeerParams) -> Result<[u8; 32]> {
+                    Ok([0u8; 32])
+                }
+
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+        let fns = parse_fns(&gen.entrypoints);
+        let get_peer = find_fn(&fns, "get_peer").expect("get_peer entrypoint should exist");
+
+        // View override: ctx should NOT be mut
+        let (is_mut, ctx_type) = first_param_context_type(get_peer);
+        assert!(!is_mut, "view override should have immutable ctx");
+        assert_eq!(ctx_type, "MyGetPeerAccounts", "should use override's context type");
+
+        // Dispatches to wrapper by value
+        let body = get_peer.block.to_token_stream().to_string();
+        assert!(
+            body.contains("get_peer (ctx , params)"),
+            "view override should pass ctx and params by value: {body}"
+        );
+    }
+
+    #[test]
+    fn override_no_params_receives_ctx_by_value() {
+        // Override the token instruction (no params) — entrypoint should
+        // dispatch to wrapper with just `ctx` by value.
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn token(ctx: Context<MyTokenAccounts>) -> Result<Pubkey> {
+                    Ok(Pubkey::default())
+                }
+
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+        let fns = parse_fns(&gen.entrypoints);
+        let token = find_fn(&fns, "token").expect("token entrypoint should exist");
+
+        // No-params override: entrypoint has only ctx, dispatches wrapper::handler(ctx)
+        assert_eq!(token.sig.inputs.len(), 1, "no-params override should have only ctx");
+        let body = token.block.to_token_stream().to_string();
+        assert!(
+            body.contains("token (ctx)"),
+            "no-params override should pass ctx by value: {body}"
+        );
+    }
+
+    #[test]
+    fn return_type_from_spec_propagated_to_entrypoint() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+        let fns = parse_fns(&gen.entrypoints);
+
+        // get_peer returns [u8; 32] per spec
+        let get_peer = find_fn(&fns, "get_peer").expect("get_peer should exist");
+        let ret = get_peer.sig.output.to_token_stream().to_string();
+        assert!(ret.contains("[u8 ; 32]"), "get_peer return type should be [u8; 32]: {ret}");
+
+        // token returns Pubkey per spec
+        let token = find_fn(&fns, "token").expect("token should exist");
+        let ret = token.sig.output.to_token_stream().to_string();
+        assert!(ret.contains("Pubkey"), "token return type should be Pubkey: {ret}");
+
+        // set_peer returns () per spec
+        let set_peer = find_fn(&fns, "set_peer").expect("set_peer should exist");
+        let ret = set_peer.sig.output.to_token_stream().to_string();
+        assert!(ret.contains("()"), "set_peer return type should be (): {ret}");
+    }
+
+    #[test]
+    fn fn_generics_from_handler_propagated_to_entrypoint() {
+        // Override with lifetime generics — entrypoint should carry them.
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn lz_receive<'info>(
+                    ctx: Context<'_, '_, '_, 'info, MyReceive<'info>>,
+                    params: LzReceiveParams,
+                ) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let gen = generate_ok(&module);
+        let fns = parse_fns(&gen.entrypoints);
+        let lz_receive = find_fn(&fns, "lz_receive").expect("lz_receive should exist");
+
+        let generics = lz_receive.sig.generics.to_token_stream().to_string();
+        assert!(
+            generics.contains("'info"),
+            "entrypoint should carry handler's lifetime generics: {generics}"
+        );
+    }
+
+    // -----------------------------------------------------------------------
+    // Tests — signature validation errors
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn error_required_instruction_missing_handler() {
+        // lz_receive is required (no default) but not overridden
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {}
+        };
+        let err = generate_err(&module);
+        assert!(err.contains("lz_receive"), "should mention instruction name: {err}");
+        assert!(err.contains("no default implementation"), "should explain why: {err}");
+    }
+}