add tests

tserg · tserg · commit b23bc8abe712 · 2024-09-27T21:11:14.000+08:00
diff --git a/src/lib.cairo b/src/lib.cairo
@@ -73,6 +73,7 @@ pub mod mock {
     pub mod erc20_mintable;
     pub mod flash_borrower;
     pub mod flash_liquidator;
+    pub mod mock_ekubo_oracle_extension;
     pub mod mock_pragma;
     pub mod mock_switchboard;
 }
diff --git a/src/mock/mock_ekubo_oracle_extension.cairo b/src/mock/mock_ekubo_oracle_extension.cairo
@@ -0,0 +1,44 @@
+use starknet::ContractAddress;
+
+#[starknet::interface]
+pub trait IMockEkuboOracleExtension<TContractState> {
+    // Timestamps are ignored
+    fn next_get_price_x128_over_period(
+        ref self: TContractState, base_token: ContractAddress, quote_token: ContractAddress, price: u256
+    );
+}
+
+#[starknet::contract]
+pub mod mock_ekubo_oracle_extension {
+    use opus::external::interfaces::IEkuboOracleExtension;
+    use starknet::ContractAddress;
+    use super::IMockEkuboOracleExtension;
+
+    #[storage]
+    struct Storage {
+        // Mapping from (base token, quote token) to x128 price
+        price: LegacyMap::<(ContractAddress, ContractAddress), u256>,
+    }
+
+    #[abi(embed_v0)]
+    impl IMockEkuboOracleExtensionImpl of IMockEkuboOracleExtension<ContractState> {
+        fn next_get_price_x128_over_period(
+            ref self: ContractState, base_token: ContractAddress, quote_token: ContractAddress, price: u256
+        ) {
+            self.price.write((base_token, quote_token), price);
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl IEkuboOracleExtensionImpl of IEkuboOracleExtension<ContractState> {
+        fn get_price_x128_over_period(
+            self: @ContractState,
+            base_token: ContractAddress,
+            quote_token: ContractAddress,
+            start_time: u64,
+            end_time: u64
+        ) -> u256 {
+            self.price.read((base_token, quote_token))
+        }
+    }
+}
diff --git a/src/tests/receptor/test_receptor.cairo b/src/tests/receptor/test_receptor.cairo
@@ -1,31 +1,307 @@
 mod test_receptor {
-    use opus::constants::{DAI_DECIMALS, USDC_DECIMALS, USDT_DECIMALS};
+    use access_control::{IAccessControlDispatcher, IAccessControlDispatcherTrait};
     use opus::core::receptor::receptor as receptor_contract;
+    use opus::core::roles::receptor_roles;
+    use opus::core::shrine::shrine as shrine_contract;
+    use opus::external::interfaces::{ITaskDispatcher, ITaskDispatcherTrait};
+    use opus::interfaces::IReceptor::{IReceptorDispatcher, IReceptorDispatcherTrait};
     use opus::interfaces::IShrine::{IShrineDispatcher, IShrineDispatcherTrait};
+    use opus::tests::common;
     use opus::tests::receptor::utils::receptor_utils;
     use opus::tests::shrine::utils::shrine_utils;
     use opus::types::QuoteTokenInfo;
+    use snforge_std::{start_warp, start_prank, stop_prank, CheatTarget, spy_events, SpyOn, EventSpy, EventAssertions};
+    use starknet::{ContractAddress, get_block_timestamp};
+    use wadray::Wad;
 
 
     #[test]
     fn test_receptor_deploy() {
-        let shrine: IShrineDispatcher = shrine_utils::shrine_deploy_and_setup(Option::None);
+        let (_, receptor, mock_ekubo_oracle_extension_addr) = receptor_utils::receptor_deploy(Option::None);
 
-        let quote_tokens: Span<QuoteTokenInfo> = array![
-            QuoteTokenInfo { address: receptor_utils::mock_dai(), decimals: DAI_DECIMALS },
-            QuoteTokenInfo { address: receptor_utils::mock_usdc(), decimals: USDC_DECIMALS },
-            QuoteTokenInfo { address: receptor_utils::mock_usdt(), decimals: USDT_DECIMALS },
+        let receptor_ac = IAccessControlDispatcher { contract_address: receptor.contract_address };
+        let admin = shrine_utils::admin();
+        assert(receptor_ac.get_admin() == admin, 'wrong admin');
+        assert(receptor_ac.get_roles(admin) == receptor_roles::default_admin_role(), 'wrong role');
+
+        assert_eq!(receptor.get_oracle_extension(), mock_ekubo_oracle_extension_addr, "wrong extension addr");
+        assert_eq!(receptor.get_twap_duration(), receptor_utils::INITIAL_TWAP_DURATION, "wrong twap duration");
+        assert_eq!(receptor.get_quote_tokens(), receptor_utils::quote_tokens(), "wrong quote tokens");
+    }
+
+    // Parameters
+
+    #[test]
+    fn test_set_oracle_extension() {
+        let (_, receptor, _) = receptor_utils::receptor_deploy(Option::None);
+
+        start_prank(CheatTarget::One(receptor.contract_address), shrine_utils::admin());
+        let new_addr: ContractAddress = receptor_utils::mock_oracle_extension();
+        receptor.set_oracle_extension(new_addr);
+
+        assert_eq!(receptor.get_oracle_extension(), new_addr, "wrong extension addr");
+    }
+
+    #[test]
+    #[should_panic(expected: ('Caller missing role',))]
+    fn test_set_oracle_extension_unauthorized() {
+        let (_, receptor, _) = receptor_utils::receptor_deploy(Option::None);
+
+        start_prank(CheatTarget::One(receptor.contract_address), common::badguy());
+        receptor.set_oracle_extension(receptor_utils::mock_oracle_extension());
+    }
+
+    #[test]
+    fn test_set_twap_duration_pass() {
+        let (_, receptor, _) = receptor_utils::receptor_deploy(Option::None);
+        let mut spy = spy_events(SpyOn::One(receptor.contract_address));
+
+        start_prank(CheatTarget::One(receptor.contract_address), shrine_utils::admin().into());
+        let old_duration: u64 = receptor_utils::INITIAL_TWAP_DURATION;
+        let new_duration: u64 = old_duration + 1;
+        receptor.set_twap_duration(new_duration);
+
+        let expected_events = array![
+            (
+                receptor.contract_address,
+                receptor_contract::Event::TwapDurationUpdated(
+                    receptor_contract::TwapDurationUpdated { old_duration, new_duration }
+                )
+            )
+        ];
+
+        spy.assert_emitted(@expected_events);
+    }
+
+    #[test]
+    #[should_panic(expected: ('REC: TWAP duration is 0',))]
+    fn test_set_twap_duration_zero_fail() {
+        let (_, receptor, _) = receptor_utils::receptor_deploy(Option::None);
+
+        start_prank(CheatTarget::One(receptor.contract_address), shrine_utils::admin().into());
+        receptor.set_twap_duration(0);
+    }
+
+    #[test]
+    #[should_panic(expected: ('Caller missing role',))]
+    fn test_set_twap_duration_unauthorized_fail() {
+        let (_, receptor, _) = receptor_utils::receptor_deploy(Option::None);
+
+        start_prank(CheatTarget::One(receptor.contract_address), common::badguy());
+        receptor.set_twap_duration(receptor_utils::INITIAL_TWAP_DURATION + 1);
+    }
+
+    #[test]
+    fn test_set_update_frequency_pass() {
+        let (_, receptor, _) = receptor_utils::receptor_deploy(Option::None);
+        let mut spy = spy_events(SpyOn::One(receptor.contract_address));
+
+        let old_frequency: u64 = receptor_utils::INITIAL_UPDATE_FREQUENCY;
+        let new_frequency: u64 = old_frequency + 1;
+        start_prank(CheatTarget::One(receptor.contract_address), shrine_utils::admin());
+        receptor.set_update_frequency(new_frequency);
+
+        assert_eq!(receptor.get_update_frequency(), new_frequency, "wrong update frequency");
+
+        let expected_events = array![
+            (
+                receptor.contract_address,
+                receptor_contract::Event::UpdateFrequencyUpdated(
+                    receptor_contract::UpdateFrequencyUpdated { old_frequency, new_frequency }
+                )
+            )
+        ];
+
+        spy.assert_emitted(@expected_events);
+    }
+
+    #[test]
+    #[should_panic(expected: ('Caller missing role',))]
+    fn test_set_update_frequency_unauthorized() {
+        let (_, receptor, _) = receptor_utils::receptor_deploy(Option::None);
+        start_prank(CheatTarget::One(receptor.contract_address), common::badguy());
+        receptor.set_update_frequency(receptor_utils::INITIAL_UPDATE_FREQUENCY - 1);
+    }
+
+    #[test]
+    #[should_panic(expected: ('REC: Frequency out of bounds',))]
+    fn test_set_update_frequency_oob_lower() {
+        let (_, receptor, _) = receptor_utils::receptor_deploy(Option::None);
+
+        let new_frequency: u64 = receptor_contract::LOWER_UPDATE_FREQUENCY_BOUND - 1;
+        start_prank(CheatTarget::One(receptor.contract_address), shrine_utils::admin());
+        receptor.set_update_frequency(new_frequency);
+    }
+
+    #[test]
+    #[should_panic(expected: ('REC: Frequency out of bounds',))]
+    fn test_set_update_frequency_oob_higher() {
+        let (_, receptor, _) = receptor_utils::receptor_deploy(Option::None);
+
+        let new_frequency: u64 = receptor_contract::UPPER_UPDATE_FREQUENCY_BOUND + 1;
+        start_prank(CheatTarget::One(receptor.contract_address), shrine_utils::admin());
+        receptor.set_update_frequency(new_frequency);
+    }
+
+    // Core functionality
+
+    #[test]
+    fn test_update_yin_price() {
+        let (shrine, receptor, mock_ekubo_oracle_extension_addr) = receptor_utils::receptor_deploy(Option::None);
+        let mut shrine_spy = spy_events(SpyOn::One(shrine.contract_address));
+        let mut receptor_spy = spy_events(SpyOn::One(receptor.contract_address));
+
+        let before_yin_spot_price: Wad = shrine.get_yin_spot_price();
+
+        let quote_tokens: Span<QuoteTokenInfo> = receptor_utils::quote_tokens();
+        // actual mainnet values from 1727418625 start time to 1727429425 end time
+        // converted in python
+        let prices: Span<u256> = array![
+            340309250276362099785975626643777172060, // 1.000158012403645039602034587 DAI / CASH
+            340527434977254803682969657, // 1.001440899252887204535902704 USDC / CASH
+            340328625112763872478829777, // 1.000271899695698999556601210 USDT / CASH
+        ]
+            .span();
+        receptor_utils::set_next_prices(
+            shrine.contract_address, mock_ekubo_oracle_extension_addr, quote_tokens, prices,
+        );
+
+        let next_ts = get_block_timestamp() + receptor_utils::INITIAL_UPDATE_FREQUENCY;
+        start_warp(CheatTarget::All, next_ts);
+
+        let quotes: Span<Wad> = receptor.get_quotes();
+        let expected_yin_spot_price: Wad = *quotes[2];
+        let mut expected_prices: Span<Wad> = array![
+            1000158012403645039_u128.into(), // DAI
+            1001440899252887204_u128.into(), // USDC
+            1000271899695698999_u128.into(), // USDT
+        ]
+            .span();
+        let error_margin: Wad = 200_u128.into();
+
+        let mut quotes_copy = quotes;
+        loop {
+            match quotes_copy.pop_front() {
+                Option::Some(quote) => {
+                    let expected: Wad = *expected_prices.pop_front().unwrap();
+                    common::assert_equalish(*quote, expected, error_margin, 'wrong quote');
+                },
+                Option::None => { break; },
+            };
+        };
+
+        start_prank(CheatTarget::One(receptor.contract_address), shrine_utils::admin());
+        receptor.update_yin_price();
+
+        let after_yin_spot_price: Wad = shrine.get_yin_spot_price();
+        assert_eq!(after_yin_spot_price, expected_yin_spot_price, "wrong yin price in shrine #1");
+
+        let expected_receptor_events = array![
+            (
+                receptor.contract_address,
+                receptor_contract::Event::ValidQuotes(receptor_contract::ValidQuotes { quotes })
+            )
+        ];
+        receptor_spy.assert_emitted(@expected_receptor_events);
+
+        let expected_shrine_events = array![
+            (
+                shrine.contract_address,
+                shrine_contract::Event::YinPriceUpdated(
+                    shrine_contract::YinPriceUpdated {
+                        old_price: before_yin_spot_price, new_price: after_yin_spot_price
+                    }
+                )
+            )
+        ];
+        shrine_spy.assert_emitted(@expected_shrine_events);
+
+        // test unsuccessful update due to a zero price quote
+        let prices: Span<u256> = array![
+            340309250276362099785975626643777172060, // 1.000158012403645039602034587 DAI / CASH
+            0, // 1.001440899252887204535902704 USDC / CASH
+            340328625112763872478829777, // 1.000271899695698999556601210 USDT / CASH
+        ]
+            .span();
+        receptor_utils::set_next_prices(
+            shrine.contract_address, mock_ekubo_oracle_extension_addr, quote_tokens, prices,
+        );
+
+        let next_ts = get_block_timestamp() + receptor_utils::INITIAL_UPDATE_FREQUENCY;
+        start_warp(CheatTarget::All, next_ts);
+
+        let quotes: Span<Wad> = receptor.get_quotes();
+
+        receptor.update_yin_price();
+
+        assert_eq!(shrine.get_yin_spot_price(), expected_yin_spot_price, "wrong yin price in shrine #2");
+
+        let expected_receptor_events = array![
+            (
+                receptor.contract_address,
+                receptor_contract::Event::InvalidQuotes(receptor_contract::InvalidQuotes { quotes })
+            )
+        ];
+        receptor_spy.assert_emitted(@expected_receptor_events);
+    }
+
+    #[test]
+    fn test_update_yin_price_via_execute_task() {
+        let (shrine, receptor, mock_ekubo_oracle_extension_addr) = receptor_utils::receptor_deploy(Option::None);
+
+        let quote_tokens: Span<QuoteTokenInfo> = receptor_utils::quote_tokens();
+        // actual mainnet values from 1727418625 start time to 1727429425 end time
+        // converted in python
+        let prices: Span<u256> = array![
+            340309250276362099785975626643777172060, // 1.000158012403645039602034587 DAI / CASH
+            340527434977254803682969657, // 1.001440899252887204535902704 USDC / CASH
+            340328625112763872478829777, // 1.000271899695698999556601210 USDT / CASH
         ]
             .span();
+        receptor_utils::set_next_prices(
+            shrine.contract_address, mock_ekubo_oracle_extension_addr, quote_tokens, prices,
+        );
+
+        let next_ts = get_block_timestamp() + receptor_utils::INITIAL_UPDATE_FREQUENCY;
+        start_warp(CheatTarget::All, next_ts);
+
+        ITaskDispatcher { contract_address: receptor.contract_address }.execute_task();
 
-        let receptor = receptor_utils::receptor_deploy(
-            shrine.contract_address,
-            receptor_utils::mock_oracle_extension(),
-            receptor_utils::INITIAL_TWAP_DURATION,
-            quote_tokens,
-            Option::None
+        let quotes: Span<Wad> = receptor.get_quotes();
+        let expected_yin_spot_price: Wad = *quotes[2];
+
+        let after_yin_spot_price: Wad = shrine.get_yin_spot_price();
+        assert_eq!(after_yin_spot_price, expected_yin_spot_price, "wrong yin price in shrine #1");
+    }
+
+    #[test]
+    fn test_probe_task() {
+        let (shrine, receptor, mock_ekubo_oracle_extension_addr) = receptor_utils::receptor_deploy(Option::None);
+
+        let quote_tokens: Span<QuoteTokenInfo> = receptor_utils::quote_tokens();
+        // actual mainnet values from 1727418625 start time to 1727429425 end time
+        // converted in python
+        let prices: Span<u256> = array![
+            340309250276362099785975626643777172060, // 1.000158012403645039602034587 DAI / CASH
+            340527434977254803682969657, // 1.001440899252887204535902704 USDC / CASH
+            340328625112763872478829777, // 1.000271899695698999556601210 USDT / CASH
+        ]
+            .span();
+        receptor_utils::set_next_prices(
+            shrine.contract_address, mock_ekubo_oracle_extension_addr, quote_tokens, prices,
         );
 
-        println!("Receptor deployed");
+        let task = ITaskDispatcher { contract_address: receptor.contract_address };
+        assert(task.probe_task(), 'should be ready 1');
+
+        task.execute_task();
+
+        assert(!task.probe_task(), 'should not be ready 1');
+
+        start_warp(CheatTarget::All, get_block_timestamp() + receptor.get_update_frequency() - 1);
+        assert(!task.probe_task(), 'should not be ready 2');
+
+        start_warp(CheatTarget::All, get_block_timestamp() + 1);
+        assert(task.probe_task(), 'should be ready 2');
     }
 }
diff --git a/src/tests/receptor/utils.cairo b/src/tests/receptor/utils.cairo

Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,7 @@ pub mod mock {`
`73`	`73`	`pub mod erc20_mintable;`
`74`	`74`	`pub mod flash_borrower;`
`75`	`75`	`pub mod flash_liquidator;`
	`76`	`+ pub mod mock_ekubo_oracle_extension;`
`76`	`77`	`pub mod mock_pragma;`
`77`	`78`	`pub mod mock_switchboard;`
`78`	`79`	`}`