Feat/rsvp for event

.tool-versions

@@ -0,0 +1 @@
+starknet-foundry 0.31.0

src/base/errors.cairo

@@ -4,4 +4,6 @@ pub mod Errors {
     pub const NOT_OWNER: felt252 = 'Caller Not Owner';
     pub const CLOSED_EVENT: felt252 = 'Event is closed';
     pub const ALREADY_REGISTERED: felt252 = 'Caller already registered';
+    pub const NOT_REGISTERED: felt252 = 'rsvp only for registered event';
+    pub const ALREADY_RSVP: felt252 = 'rsvp already exist';
 }

src/events/events.cairo

@@ -3,7 +3,7 @@ pub mod Events {
     use core::num::traits::zero::Zero;
     use chainevents_contracts::base::types::{EventDetails, EventRegistration, EventType};
     use chainevents_contracts::base::errors::Errors::{
-        ZERO_ADDRESS_OWNER, ZERO_ADDRESS_CALLER, NOT_OWNER, CLOSED_EVENT, ALREADY_REGISTERED
+        ZERO_ADDRESS_OWNER, ZERO_ADDRESS_CALLER, NOT_OWNER, CLOSED_EVENT, ALREADY_REGISTERED, NOT_REGISTERED, ALREADY_RSVP
     };
     use chainevents_contracts::interfaces::IEvent::IEvent;
     use core::starknet::{
@@ -36,7 +36,7 @@ pub mod Events {
     // event
     #[event]
     #[derive(Drop, starknet::Event)]
-    enum Event {
+    pub enum Event {
         NewEventAdded: NewEventAdded,
         RegisteredForEvent: RegisteredForEvent,
         EventAttendanceMark: EventAttendanceMark,
@@ -70,7 +70,6 @@ pub mod Events {
     #[derive(Drop, starknet::Event)]
     pub struct RSVPForEvent {
         pub event_id: u256,
-        pub event_name: felt252,
         pub attendee_address: ContractAddress
     }
 
@@ -174,7 +173,25 @@ pub mod Events {
         fn end_event_registration(
             ref self: ContractState, event_id: u256
         ) {} // only owner can closed an event 
-        fn rsvp_for_event(ref self: ContractState, event_id: u256) {}
+
+        fn rsvp_for_event(ref self: ContractState, event_id: u256) {
+            let caller = get_caller_address();
+
+            let attendee_event_details = self.attendee_event_details.entry((event_id, caller)).read();
+
+            assert(attendee_event_details.attendee_address == caller, NOT_REGISTERED);
+            assert(attendee_event_details.has_rsvp == false, ALREADY_RSVP);
+
+            self.attendee_event_details.entry((event_id, caller)).has_rsvp.write(true);
+
+            self.emit(
+                RSVPForEvent {
+                    event_id,
+                    attendee_address: caller,
+                }
+            );
+        }
+
         fn upgrade_event(ref self: ContractState, event_id: u256, paid_amount: u256) {}
 
         // GETTER FUNCTION

tests/test_contract.cairo

@@ -9,10 +9,11 @@ use starknet::{ContractAddress};
 
 use snforge_std::{
     declare, start_cheat_caller_address, stop_cheat_caller_address, ContractClassTrait,
-    DeclareResultTrait,
+    DeclareResultTrait,  spy_events, EventSpyAssertionsTrait,
 };
 
 use chainevents_contracts::interfaces::IEvent::{IEventDispatcher, IEventDispatcherTrait};
+use chainevents_contracts::events::events::Events;
 
 
 const USER_ONE: felt252 = 'JOE';
@@ -64,3 +65,79 @@ fn test_register_for_event() {
 
     stop_cheat_caller_address(event_contract_address);
 }
+
+#[test]
+#[should_panic(expected: 'rsvp only for registered event')]
+fn test_should_panic_on_rsvp_for_event_that_was_not_registered_for() {
+    let event_contract_address = __setup__();
+
+    let event_dispatcher = IEventDispatcher { contract_address: event_contract_address };
+
+    let caller: ContractAddress = starknet::contract_address_const::<0x123626789>();
+
+    start_cheat_caller_address(event_contract_address, caller);
+
+    let event_id: u256 = 1;
+
+    event_dispatcher.rsvp_for_event(event_id);
+
+    stop_cheat_caller_address(event_contract_address);
+}
+
+#[test]
+fn test_rsvp_for_event_should_emit_event_on_success() {
+    let event_contract_address = __setup__();
+
+    let event_dispatcher = IEventDispatcher { contract_address: event_contract_address };
+
+    // USER_ONE adds event
+    start_cheat_caller_address(event_contract_address, USER_ONE.try_into().unwrap());
+    let event_id = event_dispatcher.add_event("bitcoin dev meetup", "Dan Marna road");
+    assert(event_id == 1, 'Event was not created');
+    stop_cheat_caller_address(event_contract_address);
+
+    // Use a new user(caller) to register for event & rsvp for event
+    let caller: ContractAddress = starknet::contract_address_const::<0x123626789>();
+
+    start_cheat_caller_address(event_contract_address, caller);
+
+    event_dispatcher.register_for_event(event_id);
+
+    let mut spy = spy_events();
+
+    event_dispatcher.rsvp_for_event(event_id);
+
+    let expected_event = Events::Event::RSVPForEvent(Events::RSVPForEvent { event_id: 1, attendee_address: caller });
+    spy.assert_emitted(@array![(event_contract_address, expected_event)]);
+
+    stop_cheat_caller_address(event_contract_address);
+}
+
+#[test]
+#[should_panic(expected: 'rsvp already exist')]
+fn test_should_panic_on_rsvp_for_event_twice() {
+    let event_contract_address = __setup__();
+
+    let event_dispatcher = IEventDispatcher { contract_address: event_contract_address };
+
+    // USER_ONE adds event
+    start_cheat_caller_address(event_contract_address, USER_ONE.try_into().unwrap());
+    let event_id = event_dispatcher.add_event("bitcoin dev meetup", "Dan Marna road");
+    assert(event_id == 1, 'Event was not created');
+    stop_cheat_caller_address(event_contract_address);
+
+    // Use a new user(caller) to register for event & rsvp for event
+    let caller: ContractAddress = starknet::contract_address_const::<0x123626789>();
+
+    start_cheat_caller_address(event_contract_address, caller);
+
+    event_dispatcher.register_for_event(event_id);
+
+    // first rsvp for event
+    event_dispatcher.rsvp_for_event(event_id);
+
+    // second rsvp for the same event: should panic
+    event_dispatcher.rsvp_for_event(event_id);
+
+    stop_cheat_caller_address(event_contract_address);
+}