@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

package/contracts/endpoint-v2/src/tests/messaging_composer/lz_compose_alert.rs

@@ -1,269 +1,211 @@
-use crate::{events::LzComposeAlert, tests::endpoint_setup::setup};
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, Bytes, BytesN, IntoVal,
-};
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
 use utils::testing_utils::assert_event;
 
-#[test]
-fn test_lz_compose_alert_success() {
-    let context = setup();
-    let env = &context.env;
-    let endpoint_client = &context.endpoint_client;
-
-    let executor = Address::generate(env);
-    let from = Address::generate(env);
-    let to = Address::generate(env);
-    let guid = BytesN::from_array(env, &[1u8; 32]);
-    let index = 0u32;
-    let gas = 1000i128;
-    let value = 500i128;
-    let message = Bytes::from_array(env, &[1, 2, 3, 4, 5]);
-    let extra_data = Bytes::from_array(env, &[6, 7, 8]);
-    let reason = Bytes::from_array(env, &[9, 10]);
+use crate::{
+    constants::MAX_COMPOSE_INDEX, endpoint_v2::EndpointV2Client, errors::EndpointError, events::LzComposeAlert,
+    tests::endpoint_setup::setup, tests::endpoint_setup::TestSetup,
+};
 
-    // Mock auth for executor
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "lz_compose_alert",
-            args: (&executor, &from, &to, &guid, &index, &gas, &value, &message, &extra_data, &reason).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+// Helpers
+struct LzComposeAlertFixture {
+    executor: Address,
+    from: Address,
+    to: Address,
+    guid: BytesN<32>,
+    index: u32,
+    gas: i128,
+    value: i128,
+    message: Bytes,
+    extra_data: Bytes,
+    reason: Bytes,
+}
 
-    endpoint_client.lz_compose_alert(
-        &executor,
-        &from,
-        &to,
-        &guid,
-        &index,
-        &gas,
-        &value,
-        &message,
-        &extra_data,
-        &reason,
-    );
+fn default_fixture(env: &Env) -> LzComposeAlertFixture {
+    LzComposeAlertFixture {
+        executor: Address::generate(env),
+        from: Address::generate(env),
+        to: Address::generate(env),
+        guid: BytesN::from_array(env, &[1u8; 32]),
+        index: 0u32,
+        gas: 1000i128,
+        value: 500i128,
+        message: Bytes::from_array(env, &[1, 2, 3, 4, 5]),
+        extra_data: Bytes::from_array(env, &[6, 7, 8]),
+        reason: Bytes::from_array(env, &[9, 10]),
+    }
+}
 
-    // Verify the event was published
-    assert_event(
-        env,
-        &endpoint_client.address,
-        LzComposeAlert {
-            from: from.clone(),
-            to: to.clone(),
-            executor: executor.clone(),
-            guid: guid.clone(),
-            index,
-            gas,
-            value,
-            message: message.clone(),
-            extra_data: extra_data.clone(),
-            reason: reason.clone(),
-        },
+fn invoke_lz_compose_alert_with_auth<'a>(
+    context: &TestSetup,
+    endpoint_client: &EndpointV2Client<'a>,
+    executor: &Address,
+    from: &Address,
+    to: &Address,
+    guid: &BytesN<32>,
+    index: u32,
+    gas: i128,
+    value: i128,
+    message: &Bytes,
+    extra_data: &Bytes,
+    reason: &Bytes,
+) {
+    // The endpoint requires authorization from `executor`.
+    context.mock_auth(
+        executor,
+        "lz_compose_alert",
+        (executor, from, to, guid, &index, &gas, &value, message, extra_data, reason),
     );
+    endpoint_client.lz_compose_alert(executor, from, to, guid, &index, &gas, &value, message, extra_data, reason);
 }
 
+// Authorization (executor must authorize)
 #[test]
-fn test_lz_compose_alert_zero_values() {
+fn test_lz_compose_alert_auth() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    let executor = Address::generate(env);
-    let from = Address::generate(env);
-    let to = Address::generate(env);
-    let guid = BytesN::from_array(env, &[1u8; 32]);
-    let index = 0u32;
-    let gas = 0i128;
-    let value = 0i128;
-    let message = Bytes::new(env);
-    let extra_data = Bytes::new(env);
-    let reason = Bytes::new(env);
-
-    // Mock auth for executor
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "lz_compose_alert",
-            args: (&executor, &from, &to, &guid, &index, &gas, &value, &message, &extra_data, &reason).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    endpoint_client.lz_compose_alert(
-        &executor,
-        &from,
-        &to,
-        &guid,
-        &index,
-        &gas,
-        &value,
-        &message,
-        &extra_data,
-        &reason,
+    let f = default_fixture(env);
+    invoke_lz_compose_alert_with_auth(
+        &context,
+        endpoint_client,
+        &f.executor,
+        &f.from,
+        &f.to,
+        &f.guid,
+        f.index,
+        f.gas,
+        f.value,
+        &f.message,
+        &f.extra_data,
+        &f.reason,
     );
 
-    // Verify the event was published with zero values
     assert_event(
         env,
         &endpoint_client.address,
         LzComposeAlert {
-            from: from.clone(),
-            to: to.clone(),
-            executor: executor.clone(),
-            guid: guid.clone(),
-            index,
-            gas,
-            value,
-            message: message.clone(),
-            extra_data: extra_data.clone(),
-            reason: reason.clone(),
+            executor: f.executor.clone(),
+            from: f.from.clone(),
+            to: f.to.clone(),
+            guid: f.guid.clone(),
+            index: f.index,
+            gas: f.gas,
+            value: f.value,
+            message: f.message.clone(),
+            extra_data: f.extra_data.clone(),
+            reason: f.reason.clone(),
         },
     );
 }
 
 #[test]
-fn test_lz_compose_alert_large_values() {
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_lz_compose_alert_fails_without_executor_auth() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    let executor = Address::generate(env);
-    let from = Address::generate(env);
-    let to = Address::generate(env);
-    let guid = BytesN::from_array(env, &[255u8; 32]);
-    let index = u16::MAX as u32;
-    let gas = i128::MAX;
-    let value = i128::MAX;
-    let message = Bytes::from_array(env, &[255u8; 100]);
-    let extra_data = Bytes::from_array(env, &[128u8; 50]);
-    let reason = Bytes::from_array(env, &[64u8; 25]);
-
-    // Mock auth for executor
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "lz_compose_alert",
-            args: (&executor, &from, &to, &guid, &index, &gas, &value, &message, &extra_data, &reason).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-
+    let f = default_fixture(env);
     endpoint_client.lz_compose_alert(
-        &executor,
-        &from,
-        &to,
-        &guid,
-        &index,
-        &gas,
-        &value,
-        &message,
-        &extra_data,
-        &reason,
-    );
-
-    // Verify the event was published with large values
-    assert_event(
-        env,
-        &endpoint_client.address,
-        LzComposeAlert {
-            from: from.clone(),
-            to: to.clone(),
-            executor: executor.clone(),
-            guid: guid.clone(),
-            index,
-            gas,
-            value,
-            message: message.clone(),
-            extra_data: extra_data.clone(),
-            reason: reason.clone(),
-        },
+        &f.executor,
+        &f.from,
+        &f.to,
+        &f.guid,
+        &f.index,
+        &f.gas,
+        &f.value,
+        &f.message,
+        &f.extra_data,
+        &f.reason,
     );
 }
 
+// Index bounds (<= MAX_COMPOSE_INDEX)
 #[test]
-fn test_lz_compose_alert_multiple_alerts() {
+fn test_lz_compose_alert_invalid_index_exceeds_max() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    let executor = Address::generate(env);
-    let from = Address::generate(env);
-    let to = Address::generate(env);
-    let guid1 = BytesN::from_array(env, &[1u8; 32]);
-    let guid2 = BytesN::from_array(env, &[2u8; 32]);
-    let index = 0u32;
-    let gas = 1000i128;
-    let value = 500i128;
-    let message = Bytes::from_array(env, &[1, 2, 3]);
-    let extra_data = Bytes::from_array(env, &[4, 5]);
-    let reason = Bytes::from_array(env, &[6]);
+    let f = default_fixture(env);
+    let invalid_index = MAX_COMPOSE_INDEX + 1;
+    let result = {
+        context.mock_auth(
+            &f.executor,
+            "lz_compose_alert",
+            (
+                &f.executor,
+                &f.from,
+                &f.to,
+                &f.guid,
+                &invalid_index,
+                &f.gas,
+                &f.value,
+                &f.message,
+                &f.extra_data,
+                &f.reason,
+            ),
+        );
+        endpoint_client.try_lz_compose_alert(
+            &f.executor,
+            &f.from,
+            &f.to,
+            &f.guid,
+            &invalid_index,
+            &f.gas,
+            &f.value,
+            &f.message,
+            &f.extra_data,
+            &f.reason,
+        )
+    };
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InvalidIndex.into());
+}
 
-    // Send first alert
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "lz_compose_alert",
-            args: (&executor, &from, &to, &guid1, &index, &gas, &value, &message, &extra_data, &reason).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.lz_compose_alert(
-        &executor,
-        &from,
-        &to,
-        &guid1,
-        &index,
-        &gas,
-        &value,
-        &message,
-        &extra_data,
-        &reason,
-    );
+// Payload edge cases
+#[test]
+fn test_lz_compose_alert_with_empty_data() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
-    // Send second alert
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "lz_compose_alert",
-            args: (&executor, &from, &to, &guid2, &index, &gas, &value, &message, &extra_data, &reason).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.lz_compose_alert(
-        &executor,
-        &from,
-        &to,
-        &guid2,
-        &index,
-        &gas,
-        &value,
-        &message,
-        &extra_data,
-        &reason,
+    let mut f = default_fixture(env);
+    f.gas = 0;
+    f.value = 0;
+    f.message = Bytes::new(env);
+    f.extra_data = Bytes::new(env);
+    f.reason = Bytes::new(env);
+
+    invoke_lz_compose_alert_with_auth(
+        &context,
+        endpoint_client,
+        &f.executor,
+        &f.from,
+        &f.to,
+        &f.guid,
+        f.index,
+        f.gas,
+        f.value,
+        &f.message,
+        &f.extra_data,
+        &f.reason,
     );
 
-    // Both alerts should succeed - verify at least one event was published
     assert_event(
         env,
         &endpoint_client.address,
         LzComposeAlert {
-            from: from.clone(),
-            to: to.clone(),
-            executor: executor.clone(),
-            guid: guid2.clone(),
-            index,
-            gas,
-            value,
-            message: message.clone(),
-            extra_data: extra_data.clone(),
-            reason: reason.clone(),
+            executor: f.executor.clone(),
+            from: f.from.clone(),
+            to: f.to.clone(),
+            guid: f.guid.clone(),
+            index: f.index,
+            gas: f.gas,
+            value: f.value,
+            message: f.message.clone(),
+            extra_data: f.extra_data.clone(),
+            reason: f.reason.clone(),
         },
     );
 }