@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.9

package/contracts/utils/src/tests/test_helper.rs

@@ -0,0 +1,47 @@
+// `utils` crate is `#![no_std]`, but unit tests can use `std`.
+extern crate std;
+
+use soroban_sdk::{address_payload::AddressPayload, BytesN};
+
+/// Same style as `common-macros` tests helper.
+pub(in crate::tests) fn assert_panics_contains<F>(case: &str, expected_substring: &str, f: F)
+where
+    F: FnOnce(),
+{
+    use std::any::Any;
+    use std::boxed::Box;
+    use std::format;
+    use std::panic::{catch_unwind, AssertUnwindSafe};
+    use std::string::{String, ToString};
+
+    let result = catch_unwind(AssertUnwindSafe(f));
+    assert!(result.is_err(), "{case}: expected panic, but function returned normally");
+
+    let payload: Box<dyn Any + Send> = result.expect_err("checked above");
+    let msg = if let Some(s) = payload.downcast_ref::<&str>() {
+        (*s).to_string()
+    } else if let Some(s) = payload.downcast_ref::<String>() {
+        s.clone()
+    } else {
+        format!("{payload:?}")
+    };
+
+    assert!(
+        msg.contains(expected_substring),
+        "{case}: expected panic message to contain '{expected_substring}', got '{msg}'"
+    );
+}
+
+/// Helper to assert address payload matches expected payload.
+///
+/// Used in buffer_reader and buffer_writer tests to verify address encoding/decoding.
+pub(in crate::tests) fn assert_address_payload_matches(actual: BytesN<32>, expected: AddressPayload) {
+    match expected {
+        AddressPayload::ContractIdHash(expected_payload) => {
+            assert_eq!(actual, expected_payload);
+        }
+        AddressPayload::AccountIdPublicKeyEd25519(expected_payload) => {
+            assert_eq!(actual, expected_payload);
+        }
+    }
+}

package/contracts/utils/src/tests/testing_utils.rs

@@ -0,0 +1,555 @@
+use crate::testing_utils::{assert_event, assert_events, ExpectedEvent, IntoExpectedEvent};
+use common_macros::event;
+use soroban_sdk::{contract, contractimpl, testutils::Address as _, Address, Env, IntoVal, Val, Vec};
+
+// ============================================
+// Test Fixtures
+// ============================================
+
+#[event]
+pub struct TestEvent1 {
+    pub value: u32,
+}
+
+#[event]
+pub struct TestEvent2 {
+    pub name: u32,
+    pub count: u64,
+}
+
+#[event]
+pub struct TestEvent3 {
+    pub address: Address,
+}
+
+#[contract]
+pub struct TestingUtilsContract;
+
+#[contractimpl]
+impl TestingUtilsContract {
+    pub fn emit_event1(env: &Env, value: u32) {
+        TestEvent1 { value }.publish(env);
+    }
+
+    pub fn emit_event2(env: &Env, name: u32, count: u64) {
+        TestEvent2 { name, count }.publish(env);
+    }
+
+    pub fn emit_event3(env: &Env, address: Address) {
+        TestEvent3 { address }.publish(env);
+    }
+
+    pub fn emit_multiple_events(env: &Env, value1: u32, value2: u32) {
+        TestEvent1 { value: value1 }.publish(env);
+        TestEvent1 { value: value2 }.publish(env);
+    }
+
+    pub fn emit_both_events(env: &Env, value: u32, name: u32, count: u64) {
+        TestEvent1 { value }.publish(env);
+        TestEvent2 { name, count }.publish(env);
+    }
+
+    pub fn emit_three_events(env: &Env, value1: u32, value2: u32, value3: u32) {
+        TestEvent1 { value: value1 }.publish(env);
+        TestEvent1 { value: value2 }.publish(env);
+        TestEvent1 { value: value3 }.publish(env);
+    }
+
+    pub fn emit_mixed_four_events(env: &Env, v1: u32, name: u32, count: u64, v2: u32, v3: u32) {
+        TestEvent1 { value: v1 }.publish(env);
+        TestEvent2 { name, count }.publish(env);
+        TestEvent1 { value: v2 }.publish(env);
+        TestEvent1 { value: v3 }.publish(env);
+    }
+
+    pub fn emit_mixed_three_types(env: &Env, value: u32, name: u32, count: u64, address: Address) {
+        TestEvent1 { value }.publish(env);
+        TestEvent2 { name, count }.publish(env);
+        TestEvent3 { address }.publish(env);
+    }
+
+    pub fn emit_two_plus_event2(env: &Env, value1: u32, value2: u32, name: u32, count: u64) {
+        TestEvent1 { value: value1 }.publish(env);
+        TestEvent1 { value: value2 }.publish(env);
+        TestEvent2 { name, count }.publish(env);
+    }
+}
+
+// ============================================
+// assert_event
+// ============================================
+
+// Basic functionality
+
+#[test]
+fn test_assert_event_found() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    assert_event(&env, &contract_id, TestEvent1 { value: 42 });
+}
+
+#[test]
+fn test_assert_event_with_multiple_fields() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event2(&123, &456);
+
+    assert_event(&env, &contract_id, TestEvent2 { name: 123, count: 456 });
+}
+
+#[test]
+fn test_assert_event_with_address() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    let addr = Address::generate(&env);
+    client.emit_event3(&addr);
+
+    assert_event(&env, &contract_id, TestEvent3 { address: addr });
+}
+
+#[test]
+fn test_assert_event_among_multiple() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_multiple_events(&10, &20);
+
+    assert_event(&env, &contract_id, TestEvent1 { value: 10 });
+    assert_event(&env, &contract_id, TestEvent1 { value: 20 });
+}
+
+// Edge cases
+
+#[test]
+fn test_assert_event_finds_first_matching_event() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_multiple_events(&42, &42);
+
+    assert_event(&env, &contract_id, TestEvent1 { value: 42 });
+}
+
+#[test]
+fn test_assert_event_finds_correct_event_among_many() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    // Use single contract call that emits all events (events don't accumulate across calls)
+    client.emit_mixed_four_events(&1, &100, &200, &2, &3);
+
+    assert_event(&env, &contract_id, TestEvent1 { value: 2 });
+    assert_event(&env, &contract_id, TestEvent2 { name: 100, count: 200 });
+}
+
+// Error cases
+
+#[test]
+#[should_panic(expected = "Expected event not found")]
+fn test_assert_event_no_events_emitted() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+
+    assert_event(&env, &contract_id, TestEvent1 { value: 42 });
+}
+
+#[test]
+#[should_panic(expected = "Expected event not found")]
+fn test_assert_event_not_found() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    assert_event(&env, &contract_id, TestEvent1 { value: 100 });
+}
+
+#[test]
+#[should_panic(expected = "Expected event not found")]
+fn test_assert_event_wrong_contract() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let other_contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    assert_event(&env, &other_contract_id, TestEvent1 { value: 42 });
+}
+
+#[test]
+#[should_panic(expected = "Expected event not found")]
+fn test_assert_event_topics_length_mismatch() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    assert_event(&env, &contract_id, TestEvent2 { name: 42, count: 0 });
+}
+
+#[test]
+#[should_panic(expected = "Expected event not found")]
+fn test_assert_event_data_mismatch() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event2(&123, &456);
+
+    assert_event(&env, &contract_id, TestEvent2 { name: 123, count: 789 });
+}
+
+// ============================================
+// assert_events
+// ============================================
+
+// Basic functionality
+
+#[test]
+fn test_assert_events_single() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    assert_events(&env, &contract_id, &[TestEvent1 { value: 42 }.expected(&env)]);
+}
+
+#[test]
+fn test_assert_events_multiple_same_type() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_multiple_events(&10, &20);
+
+    assert_events(
+        &env,
+        &contract_id,
+        &[TestEvent1 { value: 10 }.expected(&env), TestEvent1 { value: 20 }.expected(&env)],
+    );
+}
+
+#[test]
+fn test_assert_events_multiple_different_types() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_both_events(&42, &123, &456);
+
+    assert_events(
+        &env,
+        &contract_id,
+        &[TestEvent1 { value: 42 }.expected(&env), TestEvent2 { name: 123, count: 456 }.expected(&env)],
+    );
+}
+
+#[test]
+fn test_assert_events_order_independent() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_both_events(&42, &123, &456);
+
+    assert_events(
+        &env,
+        &contract_id,
+        &[TestEvent2 { name: 123, count: 456 }.expected(&env), TestEvent1 { value: 42 }.expected(&env)],
+    );
+}
+
+#[test]
+fn test_assert_events_empty_list() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+
+    assert_events(&env, &contract_id, &[]);
+}
+
+#[test]
+fn test_assert_events_with_duplicates() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_multiple_events(&42, &42);
+
+    assert_events(
+        &env,
+        &contract_id,
+        &[TestEvent1 { value: 42 }.expected(&env), TestEvent1 { value: 42 }.expected(&env)],
+    );
+}
+
+// Edge cases
+
+#[test]
+fn test_assert_events_partial_match() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    // Use single contract call that emits all events (events don't accumulate across calls)
+    client.emit_two_plus_event2(&10, &20, &100, &200);
+
+    assert_events(&env, &contract_id, &[TestEvent1 { value: 10 }.expected(&env)]);
+}
+
+#[test]
+fn test_assert_events_three_events() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    // Use single contract call that emits all events (events don't accumulate across calls)
+    client.emit_three_events(&1, &2, &3);
+
+    assert_events(
+        &env,
+        &contract_id,
+        &[
+            TestEvent1 { value: 1 }.expected(&env),
+            TestEvent1 { value: 2 }.expected(&env),
+            TestEvent1 { value: 3 }.expected(&env),
+        ],
+    );
+}
+
+#[test]
+fn test_assert_events_mixed_event_types_three() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    let addr = Address::generate(&env);
+
+    // Use single contract call that emits all events (events don't accumulate across calls)
+    client.emit_mixed_three_types(&42, &100, &200, &addr);
+
+    assert_events(
+        &env,
+        &contract_id,
+        &[
+            TestEvent3 { address: addr.clone() }.expected(&env),
+            TestEvent1 { value: 42 }.expected(&env),
+            TestEvent2 { name: 100, count: 200 }.expected(&env),
+        ],
+    );
+}
+
+#[test]
+fn test_assert_events_from_specific_contract_ignores_others() {
+    let env = Env::default();
+    let contract_id1 = env.register(TestingUtilsContract, ());
+    let contract_id2 = env.register(TestingUtilsContract, ());
+    let client1 = TestingUtilsContractClient::new(&env, &contract_id1);
+
+    // Emit events from contract1 only
+    // Note: Events don't accumulate across separate contract calls, so we use a single call
+    client1.emit_multiple_events(&10, &30);
+
+    // Assert events from contract1 are found when using contract1's address
+    assert_events(
+        &env,
+        &contract_id1,
+        &[TestEvent1 { value: 10 }.expected(&env), TestEvent1 { value: 30 }.expected(&env)],
+    );
+
+    // Verify that using contract2's address doesn't match contract1's events
+    // (this tests the filtering logic - events should not be found for wrong contract)
+    assert_events(&env, &contract_id2, &[]);
+}
+
+// Error cases
+
+#[test]
+#[should_panic(expected = "Expected event #0 not found")]
+fn test_assert_events_first_not_found() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    assert_events(&env, &contract_id, &[TestEvent1 { value: 100 }.expected(&env)]);
+}
+
+#[test]
+#[should_panic(expected = "Expected event #1 not found")]
+fn test_assert_events_second_not_found() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    assert_events(
+        &env,
+        &contract_id,
+        &[TestEvent1 { value: 42 }.expected(&env), TestEvent1 { value: 100 }.expected(&env)],
+    );
+}
+
+#[test]
+#[should_panic(expected = "Expected event #2 not found")]
+fn test_assert_events_third_not_found() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_multiple_events(&10, &20);
+
+    assert_events(
+        &env,
+        &contract_id,
+        &[
+            TestEvent1 { value: 10 }.expected(&env),
+            TestEvent1 { value: 20 }.expected(&env),
+            TestEvent1 { value: 30 }.expected(&env),
+        ],
+    );
+}
+
+#[test]
+#[should_panic(expected = "Expected event #1 not found")]
+fn test_assert_events_duplicate_expected_but_not_emitted() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    assert_events(
+        &env,
+        &contract_id,
+        &[TestEvent1 { value: 42 }.expected(&env), TestEvent1 { value: 42 }.expected(&env)],
+    );
+}
+
+#[test]
+#[should_panic(expected = "Expected event #0 not found")]
+fn test_assert_events_no_events_emitted() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+
+    assert_events(&env, &contract_id, &[TestEvent1 { value: 42 }.expected(&env)]);
+}
+
+#[test]
+#[should_panic(expected = "Expected event #0 not found")]
+fn test_assert_events_wrong_contract() {
+    let env = Env::default();
+    let contract_id1 = env.register(TestingUtilsContract, ());
+    let contract_id2 = env.register(TestingUtilsContract, ());
+    let client1 = TestingUtilsContractClient::new(&env, &contract_id1);
+
+    client1.emit_event1(&42);
+
+    assert_events(&env, &contract_id2, &[TestEvent1 { value: 42 }.expected(&env)]);
+}
+
+#[test]
+#[should_panic(expected = "Expected event #0 not found")]
+fn test_assert_events_topics_length_mismatch() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event1(&42);
+
+    let empty_topics: Vec<Val> = Vec::new(&env);
+    let data: Val = 42u32.into_val(&env);
+    let expected_with_empty_topics = ExpectedEvent { topics: empty_topics, data };
+
+    assert_events(&env, &contract_id, &[expected_with_empty_topics]);
+}
+
+#[test]
+#[should_panic(expected = "Expected event #0 not found")]
+fn test_assert_events_data_mismatch() {
+    let env = Env::default();
+    let contract_id = env.register(TestingUtilsContract, ());
+    let client = TestingUtilsContractClient::new(&env, &contract_id);
+
+    client.emit_event2(&100, &200);
+
+    assert_events(&env, &contract_id, &[TestEvent2 { name: 100, count: 999 }.expected(&env)]);
+}
+
+// ============================================
+// ExpectedEvent & IntoExpectedEvent
+// ============================================
+
+#[test]
+fn test_into_expected_event() {
+    let env = Env::default();
+
+    let event = TestEvent1 { value: 42 };
+    let expected = event.expected(&env);
+
+    assert!(!expected.topics.is_empty());
+}
+
+#[test]
+fn test_into_expected_event_with_multiple_fields() {
+    let env = Env::default();
+
+    let event = TestEvent2 { name: 123, count: 456 };
+    let expected = event.expected(&env);
+
+    assert!(!expected.topics.is_empty());
+}
+
+#[test]
+fn test_into_expected_event_with_address() {
+    let env = Env::default();
+
+    let addr = Address::generate(&env);
+    let event = TestEvent3 { address: addr };
+    let expected = event.expected(&env);
+
+    assert!(!expected.topics.is_empty());
+}
+
+#[test]
+fn test_expected_event_struct() {
+    let env = Env::default();
+
+    let topics: Vec<Val> = Vec::new(&env);
+    let data: Val = 42u32.into_val(&env);
+
+    let expected = ExpectedEvent { topics, data };
+
+    assert_eq!(expected.topics.len(), 0);
+}
+
+#[test]
+fn test_expected_event_with_topics() {
+    let env = Env::default();
+
+    let mut topics: Vec<Val> = Vec::new(&env);
+    topics.push_back(42u32.into_val(&env));
+    topics.push_back(100u64.into_val(&env));
+    let data: Val = 999u32.into_val(&env);
+
+    let expected = ExpectedEvent { topics, data };
+
+    assert_eq!(expected.topics.len(), 2);
+}