add happy path tests for submit_with_allowance

pool/src/pool/submit.rs

@@ -187,7 +187,6 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Error(Contract, #9)")]
     fn test_submit_use_allowance() {
         let e = Env::default();
         e.budget().reset_unlimited();
@@ -215,6 +214,106 @@ mod tests {
         let (reserve_config, reserve_data) = testutils::default_reserve_meta();
         testutils::create_reserve(&e, &pool, &underlying_0, &reserve_config, &reserve_data);
 
+        let (underlying_1, underlying_1_client) = testutils::create_token_contract(&e, &bombadil);
+        let (reserve_config, reserve_data) = testutils::default_reserve_meta();
+        testutils::create_reserve(&e, &pool, &underlying_1, &reserve_config, &reserve_data);
+
+        underlying_0_client.mint(&frodo, &16_0000000);
+
+        oracle_client.set_data(
+            &bombadil,
+            &Asset::Other(Symbol::new(&e, "USD")),
+            &vec![
+                &e,
+                Asset::Stellar(underlying_0.clone()),
+                Asset::Stellar(underlying_1.clone()),
+            ],
+            &7,
+            &300,
+        );
+        oracle_client.set_price_stable(&vec![&e, 1_0000000, 5_0000000]);
+
+        let pool_config = PoolConfig {
+            oracle,
+            bstop_rate: 0_1000000,
+            status: 0,
+            max_positions: 2,
+        };
+        e.as_contract(&pool, || {
+            e.mock_all_auths_allowing_non_root_auth();
+            storage::set_pool_config(&e, &pool_config);
+
+            let pre_pool_balance_0 = underlying_0_client.balance(&pool);
+            let pre_pool_balance_1 = underlying_1_client.balance(&pool);
+
+            let requests = vec![
+                &e,
+                Request {
+                    request_type: RequestType::SupplyCollateral as u32,
+                    address: underlying_0,
+                    amount: 15_0000000,
+                },
+                Request {
+                    request_type: RequestType::Borrow as u32,
+                    address: underlying_1,
+                    amount: 1_5000000,
+                },
+            ];
+            underlying_0_client.approve(&frodo, &pool, &15_0000000, &e.ledger().sequence());
+            assert_eq!(underlying_0_client.allowance(&frodo, &pool), 15_0000000);
+
+            let positions = execute_submit(&e, &samwise, &frodo, &merry, requests, true);
+
+            assert_eq!(positions.liabilities.len(), 1);
+            assert_eq!(positions.collateral.len(), 1);
+            assert_eq!(positions.supply.len(), 0);
+            assert_eq!(positions.collateral.get_unchecked(0), 14_9999884);
+            assert_eq!(positions.liabilities.get_unchecked(1), 1_4999983);
+
+            assert_eq!(
+                underlying_0_client.balance(&pool),
+                pre_pool_balance_0 + 15_0000000
+            );
+            assert_eq!(underlying_1_client.allowance(&frodo, &pool), 0);
+            assert_eq!(
+                underlying_1_client.balance(&pool),
+                pre_pool_balance_1 - 1_5000000
+            );
+
+            assert_eq!(underlying_0_client.balance(&frodo), 1_0000000);
+            assert_eq!(underlying_1_client.balance(&merry), 1_5000000);
+        });
+    }
+
+    #[test]
+    #[should_panic(expected = "Error(Contract, #9)")]
+    fn test_submit_use_allowance_no_allowance() {
+        let e = Env::default();
+        e.budget().reset_unlimited();
+        e.mock_all_auths_allowing_non_root_auth();
+
+        e.ledger().set(LedgerInfo {
+            timestamp: 600,
+            protocol_version: 22,
+            sequence_number: 1234,
+            network_id: Default::default(),
+            base_reserve: 10,
+            min_temp_entry_ttl: 10,
+            min_persistent_entry_ttl: 10,
+            max_entry_ttl: 3110400,
+        });
+
+        let bombadil = Address::generate(&e);
+        let samwise = Address::generate(&e);
+        let frodo = Address::generate(&e);
+        let merry = Address::generate(&e);
+        let pool = testutils::create_pool(&e);
+        let (oracle, oracle_client) = testutils::create_mock_oracle(&e);
+
+        let (underlying_0, underlying_0_client) = testutils::create_token_contract(&e, &bombadil);
+        let (reserve_config, reserve_data) = testutils::default_reserve_meta();
+        testutils::create_reserve(&e, &pool, &underlying_0, &reserve_config, &reserve_data);
+
         let (underlying_1, _) = testutils::create_token_contract(&e, &bombadil);
         let (reserve_config, reserve_data) = testutils::default_reserve_meta();
         testutils::create_reserve(&e, &pool, &underlying_1, &reserve_config, &reserve_data);

test-suites/tests/test_pool.rs

@@ -50,15 +50,24 @@ fn test_pool_user() {
             amount,
         },
     ];
-    let result = pool_fixture.pool.submit(&sam, &sam, &sam, &requests);
+    weth.approve(
+        &sam,
+        &pool_fixture.pool.address,
+        &amount,
+        &fixture.env.ledger().sequence(),
+    );
+    assert_eq!(weth.allowance(&sam, &pool_fixture.pool.address), amount);
+    let result = pool_fixture
+        .pool
+        .submit_with_allowance(&sam, &sam, &sam, &requests);
     assert_eq!(
         fixture.env.auths()[0],
         (
             sam.clone(),
             AuthorizedInvocation {
                 function: AuthorizedFunction::Contract((
                     pool_fixture.pool.address.clone(),
-                    Symbol::new(&fixture.env, "submit"),
+                    Symbol::new(&fixture.env, "submit_with_allowance"),
                     vec![
                         &fixture.env,
                         sam.to_val(),
@@ -67,19 +76,7 @@ fn test_pool_user() {
                         requests.to_val()
                     ]
                 )),
-                sub_invocations: std::vec![AuthorizedInvocation {
-                    function: AuthorizedFunction::Contract((
-                        weth.address.clone(),
-                        Symbol::new(&fixture.env, "transfer"),
-                        vec![
-                            &fixture.env,
-                            sam.to_val(),
-                            pool_fixture.pool.address.to_val(),
-                            amount.into_val(&fixture.env)
-                        ]
-                    )),
-                    sub_invocations: std::vec![]
-                }]
+                sub_invocations: std::vec![]
             }
         )
     );
@@ -88,6 +85,7 @@ fn test_pool_user() {
     sam_weth_balance -= amount;
     assert_eq!(weth.balance(&sam), sam_weth_balance);
     assert_eq!(weth.balance(&pool_fixture.pool.address), pool_weth_balance);
+    assert_eq!(weth.allowance(&sam, &pool_fixture.pool.address), 0);
     sam_weth_btoken_balance += amount
         .fixed_div_floor(reserve_data.b_rate, SCALAR_9)
         .unwrap();