Added Test core test cases

Scarb.toml

@@ -19,6 +19,13 @@ sierra = true
 [scripts]
 test = "snforge test"
 
+
+[profile.dev.cairo]
+unstable-add-statements-code-locations-debug-info = true
+unstable-add-statements-functions-debug-info = true
+
+
+
 # Visit https://foundry-rs.github.io/starknet-foundry/appendix/scarb-toml.html for more information
 
 # [tool.snforge]                                             # Define `snforge` tool section

src/weaver.cairo

@@ -1,7 +1,7 @@
 use core::starknet::ContractAddress;
 
 #[starknet::contract]
-mod Weaver {
+pub mod Weaver {
     // *************************************************************************
     //                            IMPORT
     // *************************************************************************
@@ -44,11 +44,12 @@ mod Weaver {
     //                              EVENTS
     // *************************************************************************
     #[event]
-    #[derive(Copy, Drop, Debug, PartialEq, starknet::Event)]
+    #[derive(Copy, Drop, starknet::Event)]
     pub enum Event {
         Upgraded: Upgraded,
         UserRegistered: UserRegistered,
         ProtocolRegistered: ProtocolRegistered,
+        TaskMinted: TaskMinted,
     }
 
 
@@ -68,6 +69,13 @@ mod Weaver {
     }
 
 
+    #[derive(Copy, Drop, Debug, PartialEq, starknet::Event)]
+    pub struct TaskMinted {
+        pub task_id: u256,
+        pub user: ContractAddress,
+    }
+
+
     #[constructor]
     fn constructor(
         ref self: ContractState, owner: ContractAddress, weavernft_address: ContractAddress,
@@ -95,36 +103,7 @@ mod Weaver {
             self.emit(Event::UserRegistered(UserRegistered { user: get_caller_address() }));
         }
 
-        fn set_erc721(ref self: ContractState, address: ContractAddress) {
-            assert(get_caller_address() == self.owner.read(), 'UNAUTHORIZED');
-            assert(address.is_non_zero(), 'INVALID_ADDRESS');
-            self.weaver_nft_address.write(address);
-        }
-
-        fn get_register_user(self: @ContractState, address: ContractAddress) -> User {
-            return self.users.read(address);
-        }
-
-        fn version(self: @ContractState) -> u16 {
-            return self.version.read();
-        }
-
-        fn upgrade(ref self: ContractState, Imp_hash: ClassHash) {
-            assert(Imp_hash.is_non_zero(), 'Clash Hasd Cannot be Zero');
-            assert(get_caller_address() == self.owner.read(), 'UNAUTHORIZED');
-            starknet::syscalls::replace_class_syscall(Imp_hash).unwrap_syscall();
-            self.version.write(self.version.read() + 1);
-            self.emit(Event::Upgraded(Upgraded { implementation: Imp_hash }));
-        }
-
-        fn owner(self: @ContractState) -> ContractAddress {
-            return self.owner.read();
-        }
-
-        fn erc_721(self: @ContractState) -> ContractAddress {
-            return self.weaver_nft_address.read();
-        }
-
+
         fn mint(ref self: ContractState, task_id: u256) {
             let caller = get_caller_address();
 
@@ -144,12 +123,10 @@ mod Weaver {
 
             // Mint NFT to user
             weavernft_dispatcher.mint_weaver_nft(caller);
+            self.emit(Event::TaskMinted(TaskMinted { task_id, user: caller }));
         }
 
-        fn get_task_info(self: @ContractState, task_id: u256) -> TaskInfo {
-            self.task_registry.read(task_id)
-        }
-
+
 
         fn protocol_register(ref self: ContractState, protocol_name: ByteArray) {
             assert(protocol_name.len() > 0, 'INVALID_PROTOCOL_NAME');
@@ -166,9 +143,56 @@ mod Weaver {
             self.emit(Event::ProtocolRegistered(ProtocolRegistered { user: get_caller_address() }));
         }
 
+
+
+
+        // Getter functions
+
+        fn owner(self: @ContractState) -> ContractAddress {
+            return self.owner.read();
+        }
+
+        fn erc_721(self: @ContractState) -> ContractAddress {
+            return self.weaver_nft_address.read();
+        }
+
+        fn get_register_user(self: @ContractState, address: ContractAddress) -> User {
+            return self.users.read(address);
+        }
+
+        fn get_task_info(self: @ContractState, task_id: u256) -> TaskInfo {
+            self.task_registry.read(task_id)
+        }
+
         fn get_registered_protocols(self: @ContractState, address: ContractAddress) -> ProtocolInfo {
             self.protocol_registrations.read(address)
         }
 
+
+
+        //Utility functions
+
+        fn version(self: @ContractState) -> u16 {
+            return self.version.read();
+        }
+
+        fn upgrade(ref self: ContractState, Imp_hash: ClassHash) {
+            assert(Imp_hash.is_non_zero(), 'Clash Hasd Cannot be Zero');
+            assert(get_caller_address() == self.owner.read(), 'UNAUTHORIZED');
+            starknet::syscalls::replace_class_syscall(Imp_hash).unwrap_syscall();
+            self.version.write(self.version.read() + 1);
+            self.emit(Event::Upgraded(Upgraded { implementation: Imp_hash }));
+        }
+
+
+        fn set_erc721(ref self: ContractState, address: ContractAddress) {
+            assert(get_caller_address() == self.owner.read(), 'UNAUTHORIZED');
+            assert(address.is_non_zero(), 'INVALID_ADDRESS');
+            self.weaver_nft_address.write(address);
+        }
+
+
+
+
     }
 }

tests/test_weaver_contract.cairo

@@ -1,21 +1,21 @@
 use core::option::OptionTrait;
-use core::starknet::SyscallResultTrait;
-use starknet::testing::set_block_timestamp;
 use core::result::ResultTrait;
-use core::traits::{TryInto, Into};
+use core::traits::{TryInto};
 use core::byte_array::ByteArray;
 
 use snforge_std::{
     declare, start_cheat_caller_address, stop_cheat_caller_address, ContractClassTrait,
     DeclareResultTrait, spy_events, EventSpyAssertionsTrait, get_class_hash
 };
 
-use openzeppelin::{token::erc721::interface::{ERC721ABIDispatcher, ERC721ABIDispatcherTrait}};
-
-use starknet::{ContractAddress, ClassHash, get_block_timestamp};
+use starknet::{ContractAddress, get_block_timestamp};
 
 use weaver_contract::interfaces::IWeaverNFT::{IWeaverNFTDispatcher, IWeaverNFTDispatcherTrait};
 use weaver_contract::interfaces::IWeaver::{IWeaverDispatcher, IWeaverDispatcherTrait, User};
+use weaver_contract::weaver::Weaver::{Event};
+use weaver_contract::weaver::Weaver::{UserRegistered , ProtocolRegistered , TaskMinted};
+
+
 
 const ADMIN: felt252 = 'ADMIN';
 
@@ -78,6 +78,30 @@ fn test_register_user() {
 }
 
 
+#[test]
+fn test_register_user_emit_event() {
+    let (weaver_contract_address, _) = __setup__();
+    let weaver_contract = IWeaverDispatcher { contract_address: weaver_contract_address };
+
+    let mut spy = spy_events();
+
+    let user: ContractAddress = USER();
+    start_cheat_caller_address(weaver_contract_address, user);
+
+    let details: ByteArray = "Test User";
+    weaver_contract.register_User(details);
+
+    let is_registered = weaver_contract.get_register_user(user);
+    assert!(is_registered.Details == "Test User", "User should be registered");
+
+    let expected_event = Event::UserRegistered(UserRegistered{user: user});
+    spy.assert_emitted(@array![(weaver_contract_address, expected_event)]);
+
+    stop_cheat_caller_address(weaver_contract_address);
+}
+
+
+
 #[test]
 #[should_panic(expected: 'user already registered')]
 fn test_already_registered_should_panic() {
@@ -133,6 +157,32 @@ fn test_protocol_register() {
     stop_cheat_caller_address(weaver_contract_address);
 }
 
+
+#[test]
+fn test_protocol_register_emit_event() {
+    let (weaver_contract_address, nft_address) = __setup__();
+    let weaver_contract = IWeaverDispatcher { contract_address: weaver_contract_address };
+
+    let user: ContractAddress = USER();
+    let mut spy = spy_events();
+    start_cheat_caller_address(weaver_contract_address, user);
+
+    let protocol_name: ByteArray = "Weaver Protocol";
+    weaver_contract.protocol_register(protocol_name);
+
+    let protocol_info = weaver_contract.get_registered_protocols(user);
+    assert!(protocol_info.protocol_name == "Weaver Protocol", "Protocol should be registered");
+
+    let expected_event = Event::ProtocolRegistered(ProtocolRegistered{user: user});
+    spy.assert_emitted(@array![(weaver_contract_address, expected_event)]);
+
+    stop_cheat_caller_address(weaver_contract_address);
+}
+
+
+
+
+
 #[test]
 fn test_nft_minted_on_protocol_register() {
     let (weaver_contract_address, nft_address) = __setup__();
@@ -215,6 +265,8 @@ fn test_mint_nft_duplicate_id_should_panic() {
     assert!(minted_token_id > 0, "First NFT mint failed!");
 
     weaver_contract.mint(task_id);
+
+    stop_cheat_caller_address(weaver_contract_address);
 }
 
 #[test]
@@ -223,6 +275,8 @@ fn test_mint_nft() {
 
     let weaver_contract = IWeaverDispatcher { contract_address: weaver_contract_address };
     let nft_dispatcher = IWeaverNFTDispatcher { contract_address: nft_address };
+
+    let mut spy = spy_events();
     let user: ContractAddress = USER();
 
     start_cheat_caller_address(weaver_contract_address, user);
@@ -233,12 +287,6 @@ fn test_mint_nft() {
     let is_registered = weaver_contract.get_register_user(user);
     assert!(is_registered.Details == "Test User", "User should be registered");
 
-    let protocol_name: ByteArray = "Weaver Protocol";
-    weaver_contract.protocol_register(protocol_name);
-
-    let protocol_info = weaver_contract.get_registered_protocols(user);
-    assert!(protocol_info.protocol_name == "Weaver Protocol", "Protocol should be registered");
-
     let task_id = 2;
 
     let mut task_info = weaver_contract.get_task_info(task_id);
@@ -252,6 +300,11 @@ fn test_mint_nft() {
     let minted_token_id = nft_dispatcher.get_user_token_id(user);
 
     assert!(minted_token_id > 0, "NFT NOT Minted!");
+
+    let expected_event = Event::TaskMinted(TaskMinted{ task_id:task_id, user: user });
+    spy.assert_emitted(@array![(weaver_contract_address, expected_event)]);
+
+    stop_cheat_caller_address(weaver_contract_address);
 }
 
 #[test]
@@ -280,6 +333,8 @@ fn test_mint_nft_task_not_completed_should_panic() {
     weaver_contract.mint(task_id);
 
     println!("Mint function did not panic!");
+
+    stop_cheat_caller_address(weaver_contract_address);
 }
 
 #[test]
@@ -370,4 +425,56 @@ fn test_mint_task_already_exists() {
     stop_cheat_caller_address(weaver_contract_address);
 }
 
-// This is a comment
+
+#[test]
+fn test_nft_was_minted_after_user_registers(){
+    let (weaver_contract_address, nft_address) = __setup__();
+    let weaver_contract = IWeaverDispatcher { contract_address: weaver_contract_address };
+    let nft_dispatcher = IWeaverNFTDispatcher { contract_address: nft_address };
+
+    let user: ContractAddress = USER();
+    start_cheat_caller_address(weaver_contract_address, user);
+
+    let details: ByteArray = "Test User";
+    weaver_contract.register_User(details);
+
+    let minted_token_id = nft_dispatcher.get_user_token_id(user);
+    assert!(minted_token_id > 0, "NFT NOT Minted!");
+
+    let last_minted_id = nft_dispatcher.get_last_minted_id();
+    assert_eq!(minted_token_id, last_minted_id, "Minted token ID should match the last minted ID");
+
+    let mint_timestamp = nft_dispatcher.get_token_mint_timestamp(minted_token_id);
+    let current_block_timestamp = get_block_timestamp();
+    assert_eq!(mint_timestamp, current_block_timestamp, "Mint timestamp not matched");
+
+    stop_cheat_caller_address(weaver_contract_address);
+
+}
+
+
+#[test]
+fn test_nft_was_minted_after_protocol_registers(){
+    let (weaver_contract_address, nft_address) = __setup__();
+    let weaver_contract = IWeaverDispatcher { contract_address: weaver_contract_address };
+    let nft_dispatcher = IWeaverNFTDispatcher { contract_address: nft_address };
+
+    let user: ContractAddress = USER();
+    start_cheat_caller_address(weaver_contract_address, user);
+
+    let protocol_name: ByteArray = "Weaver Protocol";
+    weaver_contract.protocol_register(protocol_name);
+
+    let minted_token_id = nft_dispatcher.get_user_token_id(user);
+    assert!(minted_token_id > 0, "NFT NOT Minted!");
+
+    let last_minted_id = nft_dispatcher.get_last_minted_id();
+    assert_eq!(minted_token_id, last_minted_id, "Minted token ID should match the last minted ID");
+
+    let mint_timestamp = nft_dispatcher.get_token_mint_timestamp(minted_token_id);
+    let current_block_timestamp = get_block_timestamp();
+    assert_eq!(mint_timestamp, current_block_timestamp, "Mint timestamp not matched");
+
+    stop_cheat_caller_address(weaver_contract_address);
+
+}