Update Integration utils (#51)

.github/workflows/push.yml

@@ -18,7 +18,7 @@ jobs:
         run: make build
 
   unit-tests:
-    runs-on: ubuntu-latest
+    runs-on: macos-latest
     steps:
       - uses: actions/checkout@v3
 

.github/workflows/test.yml

@@ -19,7 +19,7 @@ jobs:
         run: make build
 
   unit-tests:
-    runs-on: ubuntu-latest
+    runs-on: macos-latest
     steps:
       - uses: actions/checkout@v3
 

Cargo.toml

@@ -18,8 +18,8 @@ near-workspaces = "0.9.0"
 
 near-sdk = { git = "https://github.com/sweatco/near-sdk-rs", rev = "8c48b26cc48d969c1e5f3162141fe9c824fccecd" }
 near-contract-standards = { git = "https://github.com/sweatco/near-sdk-rs", rev = "8c48b26cc48d969c1e5f3162141fe9c824fccecd" }
-integration-trait = { git = "https://github.com/sweatco/integration-trait.git", rev = "8dd8b63cef5e60448629a8903ea43b642bbf9f45" }
-integration-utils = { git = "https://github.com/sweatco/integration-utils.git", rev = "9fe6398c6064dfe8a26c323a6d0ea3c117a0b4a5" }
+integration-trait = { git = "https://github.com/sweatco/integration-utils.git", rev = "9a455faf70702e285eea39ae69a73a4d123b523f" }
+integration-utils = { git = "https://github.com/sweatco/integration-utils.git", rev = "9a455faf70702e285eea39ae69a73a4d123b523f" }
 
 sweat-model = { path = "model" }
 sweat-integration = { path = "sweat-integration" }

integration-tests/src/callback_attack.rs

@@ -17,7 +17,7 @@ async fn test_call_on_record_in_callback() -> anyhow::Result<()> {
 
     let alice = context.alice().await?;
 
-    let alice_balance_before_attack = context.ft_contract().ft_balance_of(alice.to_near()).await?;
+    let alice_balance_before_attack = context.ft_contract().ft_balance_of(alice.to_near()).call().await?;
 
     let target_amount = U128(1_000_000);
     let result = alice
@@ -33,7 +33,7 @@ async fn test_call_on_record_in_callback() -> anyhow::Result<()> {
 
     assert!(result.has_panic("The operation can be only initiated by an oracle"));
 
-    let alice_balance_after_attack = context.ft_contract().ft_balance_of(alice.to_near()).await?;
+    let alice_balance_after_attack = context.ft_contract().ft_balance_of(alice.to_near()).call().await?;
     assert_eq!(alice_balance_before_attack, alice_balance_after_attack);
 
     Ok(())

integration-tests/src/defer.rs

@@ -1,6 +1,6 @@
 #![cfg(test)]
 
-use integration_utils::{integration_contract::IntegrationContract, misc::ToNear};
+use integration_utils::misc::ToNear;
 use near_sdk::json_types::U64;
 use sweat_model::{FungibleTokenCoreIntegration, SweatApiIntegration, SweatDeferIntegration};
 
@@ -13,22 +13,27 @@ async fn test_defer() -> anyhow::Result<()> {
     let alice = context.alice().await?;
     let holding_account = context.holding_contract().as_account().to_near();
 
-    let target_amount = context.ft_contract().formula(U64(0), 10_000).await?;
+    let target_amount = context.ft_contract().formula(U64(0), 10_000).call().await?;
     assert_ne!(0, target_amount.0);
 
     context
         .ft_contract()
-        .with_user(&oracle)
         .defer_batch(vec![(alice.to_near(), 10_000)], holding_account.clone())
+        .with_user(&oracle)
+        .call()
         .await?;
 
-    let alice_balance = context.ft_contract().ft_balance_of(alice.to_near()).await?;
+    let alice_balance = context.ft_contract().ft_balance_of(alice.to_near()).call().await?;
     assert_eq!(0, alice_balance.0);
 
-    let holder_balance = context.ft_contract().ft_balance_of(holding_account.clone()).await?;
+    let holder_balance = context
+        .ft_contract()
+        .ft_balance_of(holding_account.clone())
+        .call()
+        .await?;
     assert_eq!(target_amount.0 * 95 / 100, holder_balance.0);
 
-    let oracle_balance = context.ft_contract().ft_balance_of(oracle.to_near()).await?;
+    let oracle_balance = context.ft_contract().ft_balance_of(oracle.to_near()).call().await?;
     assert_eq!(target_amount.0 * 5 / 100, oracle_balance.0);
 
     Ok(())

integration-tests/src/formula.rs

@@ -1,5 +1,4 @@
 use anyhow::Result;
-use integration_utils::integration_contract::IntegrationContract;
 use near_sdk::json_types::U64;
 use sweat_model::SweatApiIntegration;
 
@@ -13,7 +12,7 @@ async fn test_formula() -> Result<()> {
 
     let oracle = context.oracle().await?;
 
-    let steps = context.ft_contract().get_steps_since_tge().await?;
+    let steps = context.ft_contract().get_steps_since_tge().call().await?;
 
     assert_eq!(0, steps.0);
 
@@ -42,8 +41,9 @@ async fn test_formula() -> Result<()> {
         for steps in 0..steps_to_convert.len() {
             let formula_res = context
                 .ft_contract()
-                .with_user(&oracle)
                 .formula(U64(steps_from_tge[tge]), steps_to_convert[steps])
+                .with_user(&oracle)
+                .call()
                 .await?
                 .0;
 

integration-tests/src/lib.rs

@@ -1,6 +1,6 @@
 #![cfg(test)]
 
-use integration_utils::{integration_contract::IntegrationContract, misc::ToNear};
+use integration_utils::misc::ToNear;
 use sweat_model::{FungibleTokenCoreIntegration, SweatApiIntegration, SweatDeferIntegration};
 
 use crate::prepare::{prepare_contract, IntegrationContext};
@@ -23,26 +23,28 @@ async fn happy_flow() -> anyhow::Result<()> {
 
     assert_eq!(
         99999995378125008,
-        context.ft_contract().formula(100_000.into(), 100).await?.0
+        context.ft_contract().formula(100_000.into(), 100).call().await?.0
     );
 
     context
         .ft_contract()
         .tge_mint(&alice.to_near(), 100_000_000.into())
+        .call()
         .await?;
 
     assert_eq!(
         100_000_000,
-        context.ft_contract().ft_balance_of(alice.to_near()).await?.0
+        context.ft_contract().ft_balance_of(alice.to_near()).call().await?.0
     );
 
     context
         .ft_contract()
-        .with_user(&oracle)
         .defer_batch(
             vec![(alice.to_near(), 1000)],
             context.holding_contract().as_account().to_near(),
         )
+        .with_user(&oracle)
+        .call()
         .await?;
 
     Ok(())

integration-tests/src/mint.rs

@@ -1,4 +1,4 @@
-use integration_utils::{integration_contract::IntegrationContract, misc::ToNear};
+use integration_utils::misc::ToNear;
 use near_sdk::json_types::{U128, U64};
 use sweat_model::{FungibleTokenCoreIntegration, SweatApiIntegration};
 
@@ -13,25 +13,30 @@ async fn test_mint() -> anyhow::Result<()> {
     let user = context.alice().await?;
     let oracle = context.oracle().await?;
 
-    let result = context.ft_contract().get_steps_since_tge().await?;
+    let result = context.ft_contract().get_steps_since_tge().call().await?;
     assert_eq!(result, U64(0));
 
-    let result = context.ft_contract().formula(U64(0), TARGET_STEPS_SINCE_TGE).await?;
+    let result = context
+        .ft_contract()
+        .formula(U64(0), TARGET_STEPS_SINCE_TGE)
+        .call()
+        .await?;
     assert_eq!(result, U128(TARGET_BALANCE));
 
     context
         .ft_contract()
-        .with_user(&oracle)
         .record_batch(vec![(user.to_near(), 10_000u32)])
+        .with_user(&oracle)
+        .call()
         .await?;
 
-    let result = context.ft_contract().ft_balance_of(oracle.to_near()).await?;
+    let result = context.ft_contract().ft_balance_of(oracle.to_near()).call().await?;
     assert_eq!(result, U128(TARGET_BALANCE * 5 / 100));
 
-    let result = context.ft_contract().ft_balance_of(user.to_near()).await?;
+    let result = context.ft_contract().ft_balance_of(user.to_near()).call().await?;
     assert_eq!(result, U128(TARGET_BALANCE * 95 / 100));
 
-    let result = context.ft_contract().get_steps_since_tge().await?;
+    let result = context.ft_contract().get_steps_since_tge().call().await?;
     assert_eq!(result, U64(TARGET_STEPS_SINCE_TGE as u64));
 
     Ok(())

integration-tests/src/prepare.rs

@@ -46,19 +46,25 @@ pub async fn prepare_contract() -> anyhow::Result<Context> {
     let oracle = context.oracle().await?;
     let alice = context.alice().await?;
 
-    context.ft_contract().new(".u.sweat.testnet".to_string().into()).await?;
+    context
+        .ft_contract()
+        .new(".u.sweat.testnet".to_string().into())
+        .call()
+        .await?;
 
     context
         .ft_contract()
         .storage_deposit(oracle.to_near().into(), None)
+        .call()
         .await?;
 
     context
         .ft_contract()
         .storage_deposit(alice.to_near().into(), None)
+        .call()
         .await?;
 
-    context.ft_contract().add_oracle(&oracle.to_near()).await?;
+    context.ft_contract().add_oracle(&oracle.to_near()).call().await?;
 
     let holding_contract_init_result = context
         .holding_contract()
@@ -72,6 +78,7 @@ pub async fn prepare_contract() -> anyhow::Result<Context> {
     context
         .ft_contract()
         .storage_deposit(context.holding_contract().as_account().to_near().into(), None)
+        .call()
         .await?;
 
     Ok(context)

integration-tests/src/transfer.rs

@@ -1,4 +1,4 @@
-use integration_utils::{integration_contract::IntegrationContract, misc::ToNear};
+use integration_utils::misc::ToNear;
 use near_sdk::json_types::U128;
 use sweat_model::{FungibleTokenCoreIntegration, StorageManagementIntegration, SweatApiIntegration};
 
@@ -13,35 +13,42 @@ async fn test_transfer() -> anyhow::Result<()> {
 
     context
         .ft_contract()
-        .with_user(&oracle)
         .record_batch(vec![(alice.to_near(), 10_000)])
+        .with_user(&oracle)
+        .call()
         .await?;
 
     // This will fail because storage is not registered for this new account
     let res = context
         .ft_contract()
-        .with_user(&alice)
         .ft_transfer(bob.to_near(), U128(9499999991723028480), None)
+        .with_user(&alice)
+        .call()
         .await;
     assert!(res.is_err());
 
-    let res = context.ft_contract().storage_deposit(Some(bob.to_near()), None).await;
+    let res = context
+        .ft_contract()
+        .storage_deposit(Some(bob.to_near()), None)
+        .call()
+        .await;
     assert!(res.is_ok());
 
-    let alice_balance = context.ft_contract().ft_balance_of(alice.to_near()).await?;
+    let alice_balance = context.ft_contract().ft_balance_of(alice.to_near()).call().await?;
     assert_ne!(U128(0), alice_balance);
 
     // Transfer all tokens from alice to new account
     context
         .ft_contract()
-        .with_user(&alice)
         .ft_transfer(bob.to_near(), alice_balance, None)
+        .with_user(&alice)
+        .call()
         .await?;
 
-    let alice_balance_updated = context.ft_contract().ft_balance_of(alice.to_near()).await?;
+    let alice_balance_updated = context.ft_contract().ft_balance_of(alice.to_near()).call().await?;
     assert_eq!(U128(0), alice_balance_updated);
 
-    let bob_balance = context.ft_contract().ft_balance_of(bob.to_near()).await?;
+    let bob_balance = context.ft_contract().ft_balance_of(bob.to_near()).call().await?;
     assert_eq!(alice_balance, bob_balance);
 
     Ok(())

model/Cargo.toml

@@ -10,3 +10,6 @@ integration-trait = { workspace = true }
 
 near-sdk = { workspace = true }
 near-contract-standards = { workspace = true }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+integration-utils = { workspace = true }