margin-account-oracle 0.1.0

use crate::utils::setup::*;
use fuels::{
    prelude::*,
    types::Identity,
};

mod success {

    use super::*;

    #[tokio::test]
    async fn initialize() {
        let (deploy_wallet, owner_wallet, _margin_wallet) = setup_wallets().await;
        let (oracle_instance, _oracle_id) = setup_oracle(&deploy_wallet).await;
        let blob_id = deploy_blob(&deploy_wallet).await;

        let owner_identity = Identity::Address(owner_wallet.address());

        assert_eq!(
            oracle_instance
                .methods()
                .owner()
                .call()
                .await
                .unwrap()
                .value,
            State::Uninitialized
        );
        assert_eq!(
            oracle_instance
                .methods()
                .get_margin_account_impl()
                .call()
                .await
                .unwrap()
                .value,
            None
        );

        let _ = oracle_instance
            .methods()
            .initialize(owner_identity, blob_id)
            .call()
            .await;

        assert_eq!(
            oracle_instance
                .methods()
                .owner()
                .call()
                .await
                .unwrap()
                .value,
            State::Initialized(owner_identity)
        );
        assert_eq!(
            oracle_instance
                .methods()
                .get_margin_account_impl()
                .call()
                .await
                .unwrap()
                .value,
            Some(blob_id)
        );
    }

    #[tokio::test]
    async fn transfer_ownership() {
        let (deploy_wallet, owner_wallet, new_owner) = setup_wallets().await;
        let (oracle_instance, oracle_id) = setup_oracle(&deploy_wallet).await;
        let blob_id = deploy_blob(&deploy_wallet).await;

        let owner_identity = Identity::Address(owner_wallet.address());
        let new_owner_identity = Identity::Address(new_owner.address());
        let _ = oracle_instance
            .methods()
            .initialize(owner_identity, blob_id)
            .call()
            .await;

        assert_eq!(
            oracle_instance
                .methods()
                .owner()
                .call()
                .await
                .unwrap()
                .value,
            State::Initialized(owner_identity)
        );

        let owner_instance = MarginAccountOracle::new(oracle_id, owner_wallet.clone());
        let _ = owner_instance
            .methods()
            .transfer_ownership(new_owner_identity)
            .call()
            .await;

        assert_eq!(
            oracle_instance
                .methods()
                .owner()
                .call()
                .await
                .unwrap()
                .value,
            State::Initialized(new_owner_identity)
        );
    }

    #[tokio::test]
    async fn pause() {
        let (deploy_wallet, owner_wallet, _new_owner) = setup_wallets().await;
        let (oracle_instance, oracle_id) = setup_oracle(&deploy_wallet).await;
        let blob_id = deploy_blob(&deploy_wallet).await;

        let owner_identity = Identity::Address(owner_wallet.address());
        let _ = oracle_instance
            .methods()
            .initialize(owner_identity, blob_id)
            .call()
            .await;

        assert!(
            !oracle_instance
                .methods()
                .is_paused()
                .call()
                .await
                .unwrap()
                .value
        );

        let owner_instance = MarginAccountOracle::new(oracle_id, owner_wallet.clone());
        let _ = owner_instance.methods().pause().call().await;

        assert!(
            oracle_instance
                .methods()
                .is_paused()
                .call()
                .await
                .unwrap()
                .value
        );
    }

    #[tokio::test]
    async fn unpause() {
        let (deploy_wallet, owner_wallet, _new_owner) = setup_wallets().await;
        let (oracle_instance, oracle_id) = setup_oracle(&deploy_wallet).await;
        let blob_id = deploy_blob(&deploy_wallet).await;

        let owner_identity = Identity::Address(owner_wallet.address());
        let _ = oracle_instance
            .methods()
            .initialize(owner_identity, blob_id)
            .call()
            .await;

        let owner_instance = MarginAccountOracle::new(oracle_id, owner_wallet.clone());
        let _ = owner_instance.methods().pause().call().await;

        assert!(
            oracle_instance
                .methods()
                .is_paused()
                .call()
                .await
                .unwrap()
                .value
        );

        let _ = owner_instance.methods().unpause().call().await;

        assert!(
            !oracle_instance
                .methods()
                .is_paused()
                .call()
                .await
                .unwrap()
                .value
        );
    }
}

mod revert {

    use super::*;

    #[tokio::test]
    #[should_panic]
    async fn when_already_initalized() {
        let (deploy_wallet, owner_wallet, _margin_wallet) = setup_wallets().await;
        let (oracle_instance, _oracle_id) = setup_oracle(&deploy_wallet).await;
        let (_trading_account_instance, trading_account_id) =
            setup_margin_account(&deploy_wallet).await;

        let owner_identity = Identity::Address(owner_wallet.address());
        let _ = oracle_instance
            .methods()
            .initialize(owner_identity, trading_account_id)
            .call()
            .await;
        let _ = oracle_instance
            .methods()
            .initialize(owner_identity, trading_account_id)
            .call()
            .await
            .unwrap();
    }

    #[tokio::test]
    #[should_panic]
    async fn when_not_owner_transfer_ownership() {
        let (deploy_wallet, owner_wallet, new_owner) = setup_wallets().await;
        let (oracle_instance, _oracle_id) = setup_oracle(&deploy_wallet).await;
        let (_trading_account_instance, trading_account_id) =
            setup_margin_account(&deploy_wallet).await;

        let owner_identity = Identity::Address(owner_wallet.address());
        let new_owner_identity = Identity::Address(new_owner.address());
        let _ = oracle_instance
            .methods()
            .initialize(owner_identity, trading_account_id)
            .call()
            .await;

        let _ = oracle_instance
            .methods()
            .transfer_ownership(new_owner_identity)
            .call()
            .await
            .unwrap();
    }

    #[tokio::test]
    #[should_panic]
    async fn when_not_owner_pause() {
        let (deploy_wallet, owner_wallet, _new_owner) = setup_wallets().await;
        let (oracle_instance, _oracle_id) = setup_oracle(&deploy_wallet).await;
        let (_trading_account_instance, trading_account_id) =
            setup_margin_account(&deploy_wallet).await;

        let owner_identity = Identity::Address(owner_wallet.address());
        let _ = oracle_instance
            .methods()
            .initialize(owner_identity, trading_account_id)
            .call()
            .await;

        let _ = oracle_instance.methods().pause().call().await.unwrap();
    }
}