dev: test emit_events

[DiegoB1911]

This PR implements the unit test for the emit_events function.

Pull Request type

Please check the type of change your PR introduces:

• Bugfix
• Feature
• Code style update (formatting, renaming)
• Refactoring (no functional changes, no API changes)
• Build-related changes
• Documentation content changes
• Other (please describe):

What is the current behavior?

The emit_events function doesn't have any unit tests.

Resolves: #952

What is the new behavior?

• The test_emit_events function generates some events and adds them to the state before calling the emit_events function. This allows the events to be asserted using the spy.assert_emitted function.
• I created a MockEvent struct to implement the event trait, as the append_keys_and_data function is required for the assert_emitted function to work. Without that implementation, attempts to assert the events would fail because the expected events in the comparison were empty.
• I added a helper function to serialize mock events to match the structure of the emitted events, so they can be properly asserted.

Does this introduce a breaking change?

• Yes
• No

---

This change is 

[enitrat]

Hi @DiegoB1911, thank you it is the right approach overall.

However, here are some indications on how to make it "better":

1. I am not sure to understand what the MockEvent struct is for. You should be able to assert the emission like this:

        let contract_events = EventsFilterBuilderTrait::from_events(@spy.get_events())
            .with_contract_address(test_address())
            .build();

        for event in evm_events {
            let starknet_event = EventIntoStarknetEvent::into(event);
            contract_events.assert_emitted(@starknet_event);
        };

2. your serialize_mock_events is a good idea, as when we check for events emitted, they are in serialized form. However, a more idiiomatic way would be to define an implementation of the Into trait:

    impl EventIntoStarknetEvent of Into<Event, StarknetEvent> {
       fn into(self: Event) -> StarknetEvent {
           let mut serialized_keys = array![];
           let mut serialized_data = array![];
           Serde::<Array<u256>>::serialize(@self.keys, ref serialized_keys);
           Serde::<Array<u8>>::serialize(@self.data, ref serialized_data);
           StarknetEvent { keys: serialized_keys, data: serialized_data }
       }
   } 

(see usage in example above)

Here is a full git diff of the changes I would make. As you see the logic is roughly the same.

I also modified a file under snforge_utils to avoid passing ownership when using assert_emitted that I pushed on your branch to avoid ownership issues.

[enitrat]

prefer the implementation of Into, see main message (but same underlying idea)

[enitrat]

Suggested change

	let mut mock_events = ArrayTrait::<(ContractAddress, MockEvent)>::new();
	let mut mock_events = ArrayTrait::<(ContractAddress, MockEvent)>::new();

no longer required

[DiegoB1911]

@enitrat Thank you for your review and explanation. I hadn’t considered implementing the Into trait in that way, and I also thought about importing snforge_std::Event as you did ("snforge_std::Event as StarknetEvent"), but I wasn’t sure it was possible to rename imported elements like in other languages, which is why I created the mock event. Thanks for showing me that approach. I'm still learning how traits and implementations work, and how Cairo functions in general, so I really appreciate your help. I’ve made the requested changes. Please let me know if there’s anything else I need to adjust.

[enitrat]

lgtm, great job 💪