Adding upddates and first test of my job

Author: Gerson2102

src/lib.cairo

@@ -5,6 +5,7 @@ mod systems {
     mod spawn;
     mod world_setup;
     mod bag;
+    mod tournament;
 }
 
 mod models {
@@ -26,9 +27,11 @@ mod models {
     mod achievement_rarity;
     mod achievement_type;
     mod achievements;
+    mod tournament;
 }
 
 mod tests {
     mod test_battle;
     mod test_bag;
+    mod test_tournament;
 }

src/models/tournament.cairo

@@ -8,7 +8,7 @@ pub enum TournamentStatus {
 }
 
 
-#[derive(Copy, Drop, Serde)]
+#[derive(Drop, Serde)]
 #[dojo::model]
 pub struct Tournament {
     #[key]

src/systems/tournament.cairo

@@ -1,35 +1,59 @@
 use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
-use bytebeasts::{
-    models::{player::Player, tournament::Tournament, tournament::TournamentStatus},
-};
+use bytebeasts::{models::{player::Player, tournament::Tournament, tournament::TournamentStatus},};
 
 #[dojo::interface]
 trait ITournamentAction {
-    fn create_tournament(ref world: IWorldDispatcher, tournament_id: u32, name: felt252,
+    fn create_tournament(
+        ref world: IWorldDispatcher,
+        tournament_id: u32,
+        name: felt252,
         status: TournamentStatus,
         entry_fee: u32,
         max_participants: u32,
         current_participants: Array<Player>,
-        prize_pool: u32) -> Tournament;
-    fn register_player(ref world: IWorldDispatcher, tournament_id: u32, player_id: u32);
-    fn start_tournament(ref world: IWorldDispatcher, tournament_id: u32, player_id: u32);
-    fn complete_torunament(ref world: IWorldDispatcher, tournament_id: u32, player_id: u32);
-    fn get_tournament(ref world: IWorldDispatcher, tournament_id: u32) -> Tournament;
+        prize_pool: u32
+    );
+    // fn register_player(ref world: IWorldDispatcher, tournament_id: u32, player_id: u32);
+    // fn start_tournament(ref world: IWorldDispatcher, tournament_id: u32, player_id: u32);
+    // fn complete_torunament(ref world: IWorldDispatcher, tournament_id: u32, player_id: u32);
+    fn get_tournament(world: @IWorldDispatcher, tournament_id: u32) -> Tournament;
 }
 
 
 #[dojo::contract]
-mod spawn_action {
+mod tournament_system {
     use super::ITournamentAction;
     use bytebeasts::{
-        models::{player::Player, tournament::Tournament},
+        models::{player::Player, tournament::Tournament, tournament::TournamentStatus},
     };
 
     #[abi(embed_v0)]
     impl TournamentActionImpl of ITournamentAction<ContractState> {
+        fn create_tournament(
+            ref world: IWorldDispatcher,
+            tournament_id: u32,
+            name: felt252,
+            status: TournamentStatus,
+            entry_fee: u32,
+            max_participants: u32,
+            current_participants: Array<Player>,
+            prize_pool: u32
+        ) {
+            let tournament = Tournament {
+                tournament_id: tournament_id,
+                name: name,
+                status: status,
+                entry_fee: entry_fee,
+                max_participants: max_participants,
+                current_participants: current_participants,
+                prize_pool: prize_pool
+            };
+            set!(world, (tournament))
+        }
+
         fn get_tournament(world: @IWorldDispatcher, tournament_id: u32) -> Tournament {
             let tournament_from_world = get!(world, tournament_id, (Tournament));
             tournament_from_world
         }
     }
-}
+}

src/tests/test_tournament.cairo

@@ -0,0 +1,61 @@
+#[cfg(test)]
+mod tests {
+    use starknet::ContractAddress;
+
+    use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
+    use dojo::utils::test::{spawn_test_world, deploy_contract};
+
+    use bytebeasts::{
+        systems::{
+            tournament::{
+                tournament_system, ITournamentActionDispatcher, ITournamentActionDispatcherTrait
+            }
+        },
+    };
+
+    use bytebeasts::{
+        models::tournament::{{Tournament, tournament}}, models::tournament::TournamentStatus,
+        models::player::{{Player, player}},
+    };
+
+
+    // Helper function
+    // This function create the world and define the required models
+    #[test]
+    fn setup_world() -> (IWorldDispatcher, ITournamentActionDispatcher) {
+        let mut models = array![tournament::TEST_CLASS_HASH, player::TEST_CLASS_HASH];
+
+        let world = spawn_test_world("bytebeasts", models);
+
+        let contract_address = world
+            .deploy_contract('salt', tournament_system::TEST_CLASS_HASH.try_into().unwrap());
+
+        let tournament_system = ITournamentActionDispatcher { contract_address };
+
+        world.grant_writer(dojo::utils::bytearray_hash(@"bytebeasts"), contract_address);
+
+        (world, tournament_system)
+    }
+
+    #[test]
+    fn test_create_tournament() {
+        let (_, tournament_system) = setup_world();
+        let mut players = ArrayTrait::new();
+
+        let player_ash = Player {
+            player_id: 1,
+            player_name: 'Ash',
+            beast_1: 1, // Beast 1 assigned
+            beast_2: 0, // No beast assigned
+            beast_3: 0, // No beast assigned
+            beast_4: 0, // No beast assigned
+            potions: 1
+        };
+        players.append(player_ash);
+
+        tournament_system
+            .create_tournament(1, 'tournament', TournamentStatus::Pending, 1, 2, players, 1);
+        let tournament = tournament_system.get_tournament(1);
+        assert!(tournament.name == 'tournament', "The tournament name is wrong!");
+    }
+}