@layerzerolabs/protocol-stellar-v2 0.2.12 → 0.2.15

package/contracts/endpoint-v2/src/tests/message_lib_manager/set_default_send_library.rs

@@ -1,134 +1,153 @@
 use soroban_sdk::{testutils::Address as _, vec, Address};
+use utils::testing_utils::assert_event;
 
 use crate::{
-    errors::EndpointError, events::DefaultSendLibrarySet, storage, tests::endpoint_setup::setup, MessageLibType,
+    errors::EndpointError, events::DefaultSendLibrarySet, tests::endpoint_setup::setup,
+    tests::endpoint_setup::TestSetup, MessageLibType,
 };
-use utils::testing_utils::assert_event;
 
-// Integration tests for set_default_send_library
+fn try_set_default_send_library_with_auth(
+    context: &TestSetup,
+    dst_eid: u32,
+    send_lib: &Address,
+) -> Result<(), Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+    context.mock_owner_auth("set_default_send_library", (&dst_eid, send_lib));
+    context.endpoint_client.try_set_default_send_library(&dst_eid, send_lib).map(|r| r.expect("conversion error"))
+}
+
+// Unsupported EID rejection (library must support dst_eid)
 #[test]
 fn test_set_default_send_library_unsupported_eid() {
     let context = setup();
     let env = &context.env;
-    let endpoint_client = &context.endpoint_client;
 
     let unsupported_eid = context.eid + 1;
 
-    // Create and register a send lib that only supports TEST_context.eid
+    // Create and register a send lib that only supports `context.eid`.
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
 
-    // Mock owner auth for register_library
-    context.mock_owner_auth("register_library", (&send_lib,));
-    endpoint_client.register_library(&send_lib);
-
-    // Mock owner auth for set_default_send_library
-    context.mock_owner_auth("set_default_send_library", (&unsupported_eid, &send_lib));
-
-    // Try to set it as default for unsupported eid
-    let result = endpoint_client.try_set_default_send_library(&unsupported_eid, &send_lib);
+    context.register_library_with_auth(&send_lib);
 
+    let result = try_set_default_send_library_with_auth(&context, unsupported_eid, &send_lib);
     assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::UnsupportedEid.into());
 }
 
+// Wrong library type rejection (must be Send)
 #[test]
 fn test_set_default_send_library_wrong_lib_type() {
     let context = setup();
     let env = &context.env;
-    let endpoint_client = &context.endpoint_client;
 
-    // Create and register a receive-only lib that supports eid 1
+    // Create and register a receive-only lib that supports `context.eid`.
     let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
 
-    // Mock owner auth for register_library
-    context.mock_owner_auth("register_library", (&receive_lib,));
-    endpoint_client.register_library(&receive_lib);
-
-    // Mock owner auth for set_default_send_library
-    context.mock_owner_auth("set_default_send_library", (&context.eid, &receive_lib));
-
-    // Try to set it as default send library
-    let result = endpoint_client.try_set_default_send_library(&context.eid, &receive_lib);
+    context.register_library_with_auth(&receive_lib);
 
+    let result = try_set_default_send_library_with_auth(&context, context.eid, &receive_lib);
     assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlySendLib.into());
 }
 
+// Unregistered library rejection
 #[test]
 fn test_set_default_send_library_unregistered_lib() {
     let context = setup();
     let env = &context.env;
-    let endpoint_client = &context.endpoint_client;
 
-    // Create but don't register a valid send lib
+    // Create but do not register a valid send lib.
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
 
-    // Mock owner auth for set_default_send_library
-    context.mock_owner_auth("set_default_send_library", (&context.eid, &send_lib));
-
-    // Try to set it as default without registering
-    let result = endpoint_client.try_set_default_send_library(&context.eid, &send_lib);
-
+    let result = try_set_default_send_library_with_auth(&context, context.eid, &send_lib);
     assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlyRegisteredLib.into());
 }
 
+// Successful update (state update + event emission)
 #[test]
-fn test_set_default_send_library_non_deployed_lib() {
+fn test_set_default_send_library_success() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    // Address without any contract deployed
-    let non_existent_lib = Address::generate(env);
+    // Create and register a valid send lib that supports `context.eid`.
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    context.register_library_with_auth(&send_lib);
 
-    // Mock owner auth for set_default_send_library
-    context.mock_owner_auth("set_default_send_library", (&context.eid, &non_existent_lib));
+    // Verify initial state via public interface.
+    assert_eq!(endpoint_client.default_send_library(&context.eid), None);
 
-    // Try to set a non-existent contract as default
-    let result = endpoint_client.try_set_default_send_library(&context.eid, &non_existent_lib);
+    // Should succeed.
+    context.set_default_send_library_with_auth(context.eid, &send_lib);
 
-    assert!(result.is_err());
+    // Verify event emission.
+    assert_event(
+        env,
+        &endpoint_client.address,
+        DefaultSendLibrarySet { dst_eid: context.eid, new_lib: send_lib.clone() },
+    );
+
+    // Verify state update via public interface.
+    assert_eq!(endpoint_client.default_send_library(&context.eid), Some(send_lib.clone()));
 }
 
+// Successful update with SendAndReceive library type (valid for send)
 #[test]
-fn test_set_default_send_library_success() {
+fn test_set_default_send_library_success_with_send_and_receive_type() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    // Create and register a valid send lib that supports eid 1
-    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    // Create and register a SendAndReceive lib that supports `context.eid`.
+    let send_and_receive_lib = context.setup_mock_message_lib(MessageLibType::SendAndReceive, vec![env, context.eid]);
 
-    // Mock owner auth for register_library
-    context.mock_owner_auth("register_library", (&send_lib,));
-    endpoint_client.register_library(&send_lib);
+    context.register_library_with_auth(&send_and_receive_lib);
 
-    // Verify initial state - default send library should not be set
-    assert_eq!(endpoint_client.default_send_library(&context.eid), None);
-    let initial_lib =
-        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::default_send_library(env, context.eid));
-    assert_eq!(initial_lib, None, "Initial default send library should be None");
+    // Should succeed.
+    context.set_default_send_library_with_auth(context.eid, &send_and_receive_lib);
 
-    // Mock owner auth for set_default_send_library
-    context.mock_owner_auth("set_default_send_library", (&context.eid, &send_lib));
+    // Verify event emission.
+    assert_event(
+        env,
+        &endpoint_client.address,
+        DefaultSendLibrarySet { dst_eid: context.eid, new_lib: send_and_receive_lib.clone() },
+    );
 
-    // Should succeed
-    endpoint_client.set_default_send_library(&context.eid, &send_lib);
+    // Verify state update via public interface.
+    assert_eq!(endpoint_client.default_send_library(&context.eid), Some(send_and_receive_lib));
+}
+
+// Updating from one default to another (A -> B)
+#[test]
+fn test_set_default_send_library_can_change_default_library() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let send_lib_a = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    let send_lib_b = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    context.register_library_with_auth(&send_lib_a);
+    context.register_library_with_auth(&send_lib_b);
 
-    // Verify the event was published
+    // Set A as the default first.
+    context.set_default_send_library_with_auth(context.eid, &send_lib_a);
     assert_event(
         env,
         &endpoint_client.address,
-        DefaultSendLibrarySet { dst_eid: context.eid, new_lib: send_lib.clone() },
+        DefaultSendLibrarySet { dst_eid: context.eid, new_lib: send_lib_a.clone() },
     );
+    assert_eq!(endpoint_client.default_send_library(&context.eid), Some(send_lib_a.clone()));
 
-    // Verify it was set correctly via public interface
-    assert_eq!(endpoint_client.default_send_library(&context.eid), Some(send_lib.clone()));
-
-    // Assert storage change directly
-    let stored_lib =
-        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::default_send_library(env, context.eid));
-    assert_eq!(stored_lib, Some(send_lib), "Storage should contain the default send library");
+    // Then change the default to B.
+    context.set_default_send_library_with_auth(context.eid, &send_lib_b);
+    assert_event(
+        env,
+        &endpoint_client.address,
+        DefaultSendLibrarySet { dst_eid: context.eid, new_lib: send_lib_b.clone() },
+    );
+    assert_eq!(endpoint_client.default_send_library(&context.eid), Some(send_lib_b.clone()));
 }
 
+// Authorization (only owner)
 #[test]
 #[should_panic(expected = "Error(Auth, InvalidAction)")]
 fn test_set_default_send_library_requires_owner_auth() {
@@ -138,43 +157,30 @@ fn test_set_default_send_library_requires_owner_auth() {
 
     let non_owner = Address::generate(env);
 
-    // Create and register a valid send lib
+    // Create and register a valid send lib.
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
 
-    // Mock owner auth for register_library
-    context.mock_owner_auth("register_library", (&send_lib,));
-    endpoint_client.register_library(&send_lib);
+    context.register_library_with_auth(&send_lib);
 
-    // Mock auth for the non-owner (not the owner)
+    // Mock auth for the non-owner (not the owner).
     context.mock_auth(&non_owner, "set_default_send_library", (&context.eid, &send_lib));
 
-    // Should fail when non-owner tries to set
+    // Should fail when a non-owner tries to set.
     endpoint_client.set_default_send_library(&context.eid, &send_lib);
 }
 
+// Same value rejection (no-op is not allowed)
 #[test]
 fn test_set_default_send_library_same_value() {
     let context = setup();
     let env = &context.env;
-    let endpoint_client = &context.endpoint_client;
 
-    // Create and register a valid send lib that supports eid 1
+    // Create and register a valid send lib that supports `context.eid`.
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
 
-    // Mock owner auth for register_library
-    context.mock_owner_auth("register_library", (&send_lib,));
-    endpoint_client.register_library(&send_lib);
-
-    // Mock owner auth for set_default_send_library
-    context.mock_owner_auth("set_default_send_library", (&context.eid, &send_lib));
-
-    // Should succeed
-    endpoint_client.set_default_send_library(&context.eid, &send_lib);
-
-    context.mock_owner_auth("set_default_send_library", (&context.eid, &send_lib));
-
-    // Try to set same library again
-    let result = endpoint_client.try_set_default_send_library(&context.eid, &send_lib);
+    context.register_library_with_auth(&send_lib);
+    context.set_default_send_library_with_auth(context.eid, &send_lib);
 
+    let result = try_set_default_send_library_with_auth(&context, context.eid, &send_lib);
     assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::SameValue.into());
 }