unnecessary tests cleanup

Author: benesjan

noir-projects/noir-contracts/contracts/app/orderbook_contract/src/test.nr

@@ -58,7 +58,6 @@ unconstrained fn setup_orderbook_with_tokens(
 }
 
 // Utility function to mint tokens to private balance
-// Note: The minting must be done by the token owner (admin), not the recipient
 unconstrained fn mint_to_private(
     env: TestEnvironment,
     token_address: AztecAddress,
@@ -98,7 +97,7 @@ unconstrained fn check_public_balance(
 // Happy path tests
 
 #[test]
-unconstrained fn test_create_order_happy_path() {
+unconstrained fn create_order_happy_path() {
     let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
         setup_orderbook_with_tokens(true);
 
@@ -136,7 +135,7 @@ unconstrained fn test_create_order_happy_path() {
 }
 
 #[test]
-unconstrained fn test_fulfill_order_happy_path() {
+unconstrained fn full_flow() {
     let (mut env, orderbook_address, token0_address, token1_address, maker, _) =
         setup_orderbook_with_tokens(true);
 
@@ -170,6 +169,15 @@ unconstrained fn test_fulfill_order_happy_path() {
         ),
     );
 
+    // Get order and verify it's active
+    let (order, is_fulfilled) =
+        env.simulate_utility(Orderbook::at(orderbook_address).get_order(order_id));
+
+    assert_eq(order.bid_amount, bid_amount);
+    assert_eq(order.ask_amount, ask_amount);
+    assert_eq(order.bid_token_is_zero, true); // token0 -> token1
+    assert_eq(is_fulfilled, false);
+
     // Create authwit for taker to transfer ask tokens
     // Convert order_id back to PartialUintNote as the orderbook does
     let maker_partial_note = PartialUintNote::from_field(order_id);
@@ -197,12 +205,21 @@ unconstrained fn test_fulfill_order_happy_path() {
     check_private_balance(env, token1_address, maker, ask_amount);
     check_private_balance(env, token0_address, taker, bid_amount);
     check_private_balance(env, token1_address, taker, 0);
+
+    // Get order and verify it's fulfilled
+    let (order, is_fulfilled) =
+        env.simulate_utility(Orderbook::at(orderbook_address).get_order(order_id));
+
+    assert_eq(order.bid_amount, bid_amount);
+    assert_eq(order.ask_amount, ask_amount);
+    assert_eq(order.bid_token_is_zero, true); // token0 -> token1
+    assert_eq(is_fulfilled, true);
 }
 
 // Unhappy path tests for create_order
 
 #[test(should_fail_with = "ZERO_BID_AMOUNT")]
-unconstrained fn test_create_order_zero_bid_amount() {
+unconstrained fn create_order_zero_bid_amount() {
     let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
@@ -224,7 +241,7 @@ unconstrained fn test_create_order_zero_bid_amount() {
 }
 
 #[test(should_fail_with = "ZERO_ASK_AMOUNT")]
-unconstrained fn test_create_order_zero_ask_amount() {
+unconstrained fn create_order_zero_ask_amount() {
     let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
@@ -246,7 +263,7 @@ unconstrained fn test_create_order_zero_ask_amount() {
 }
 
 #[test(should_fail_with = "BID_TOKEN_IS_INVALID")]
-unconstrained fn test_create_order_invalid_bid_token() {
+unconstrained fn create_order_invalid_bid_token() {
     let (mut env, orderbook_address, _token0_address, token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
@@ -269,7 +286,7 @@ unconstrained fn test_create_order_invalid_bid_token() {
 }
 
 #[test(should_fail_with = "ASK_TOKEN_IS_INVALID")]
-unconstrained fn test_create_order_invalid_ask_token() {
+unconstrained fn create_order_invalid_ask_token() {
     let (mut env, orderbook_address, token0_address, _token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
@@ -292,7 +309,7 @@ unconstrained fn test_create_order_invalid_ask_token() {
 }
 
 #[test(should_fail_with = "SAME_TOKEN_TRADE")]
-unconstrained fn test_create_order_same_tokens() {
+unconstrained fn create_order_same_tokens() {
     let (mut env, orderbook_address, token0_address, _token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
@@ -312,274 +329,3 @@ unconstrained fn test_create_order_same_tokens() {
         ),
     );
 }
-
-#[test(should_fail_with = "Balance too low")]
-unconstrained fn test_create_order_insufficient_balance() {
-    let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
-        setup_orderbook_with_tokens(true);
-
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce = 1;
-
-    // Don't mint any tokens to owner, so they have insufficient balance
-
-    // Create authwit for transferring tokens to orderbook
-    let transfer_call_interface = Token::at(token0_address).transfer_to_public(
-        owner,
-        orderbook_address,
-        bid_amount,
-        authwit_nonce,
-    );
-    add_private_authwit_from_call_interface(owner, orderbook_address, transfer_call_interface);
-
-    // This should fail due to insufficient balance
-    let _order_id = env.call_private(
-        owner,
-        Orderbook::at(orderbook_address).create_order(
-            token0_address,
-            token1_address,
-            bid_amount,
-            ask_amount,
-            authwit_nonce,
-        ),
-    );
-}
-
-#[test(should_fail_with = "Unknown auth witness for message hash")]
-unconstrained fn test_create_order_missing_authwit() {
-    let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
-        setup_orderbook_with_tokens(true);
-
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce = 1;
-
-    // Mint tokens to owner
-    mint_to_private(env, token0_address, owner, owner, bid_amount);
-
-    // Don't create authwit - this should fail
-
-    // This should fail due to missing authwit
-    let _order_id = env.call_private(
-        owner,
-        Orderbook::at(orderbook_address).create_order(
-            token0_address,
-            token1_address,
-            bid_amount,
-            ask_amount,
-            authwit_nonce,
-        ),
-    );
-}
-
-// Unhappy path tests for fulfill_order
-
-#[test(should_fail_with = "Balance too low")]
-unconstrained fn test_fulfill_order_insufficient_balance() {
-    let (mut env, orderbook_address, token0_address, token1_address, maker, _) =
-        setup_orderbook_with_tokens(true);
-
-    let taker = env.create_contract_account();
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce_create = 1;
-    let authwit_nonce_fulfill = 2;
-
-    // Setup: mint tokens to maker only (not to taker)
-    mint_to_private(env, token0_address, maker, maker, bid_amount);
-
-    // Create order first
-    let transfer_call_interface = Token::at(token0_address).transfer_to_public(
-        maker,
-        orderbook_address,
-        bid_amount,
-        authwit_nonce_create,
-    );
-    add_private_authwit_from_call_interface(maker, orderbook_address, transfer_call_interface);
-
-    let order_id = env.call_private(
-        maker,
-        Orderbook::at(orderbook_address).create_order(
-            token0_address,
-            token1_address,
-            bid_amount,
-            ask_amount,
-            authwit_nonce_create,
-        ),
-    );
-
-    // Create authwit for taker to transfer ask tokens (but taker has no balance)
-    let maker_partial_note = PartialUintNote::from_field(order_id);
-    let fulfill_transfer_call_interface = Token::at(token1_address)
-        .finalize_transfer_to_private_from_private(
-            taker,
-            maker_partial_note,
-            ask_amount,
-            authwit_nonce_fulfill,
-        );
-    add_private_authwit_from_call_interface(
-        taker,
-        orderbook_address,
-        fulfill_transfer_call_interface,
-    );
-
-    // This should fail due to insufficient balance
-    env.call_private(
-        taker,
-        Orderbook::at(orderbook_address).fulfill_order(order_id, authwit_nonce_fulfill),
-    );
-}
-
-#[test(should_fail_with = "Unknown auth witness for message hash")]
-unconstrained fn test_fulfill_order_missing_authwit() {
-    let (mut env, orderbook_address, token0_address, token1_address, maker, _) =
-        setup_orderbook_with_tokens(true);
-
-    let taker = env.create_contract_account();
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce_create = 1;
-    let authwit_nonce_fulfill = 2;
-
-    // Setup: mint tokens to maker and taker
-    mint_to_private(env, token0_address, maker, maker, bid_amount);
-    mint_to_private(env, token1_address, maker, taker, ask_amount);
-
-    // Create order first
-    let transfer_call_interface = Token::at(token0_address).transfer_to_public(
-        maker,
-        orderbook_address,
-        bid_amount,
-        authwit_nonce_create,
-    );
-    add_private_authwit_from_call_interface(maker, orderbook_address, transfer_call_interface);
-
-    let order_id = env.call_private(
-        maker,
-        Orderbook::at(orderbook_address).create_order(
-            token0_address,
-            token1_address,
-            bid_amount,
-            ask_amount,
-            authwit_nonce_create,
-        ),
-    );
-
-    // Don't create authwit for taker - this should fail
-
-    // This should fail due to missing authwit
-    env.call_private(
-        taker,
-        Orderbook::at(orderbook_address).fulfill_order(order_id, authwit_nonce_fulfill),
-    );
-}
-
-#[test]
-unconstrained fn test_get_order_active() {
-    let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
-        setup_orderbook_with_tokens(true);
-
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce = 1;
-
-    // Mint tokens to owner
-    mint_to_private(env, token0_address, owner, owner, bid_amount);
-
-    // Create authwit for transferring tokens to orderbook
-    let transfer_call_interface = Token::at(token0_address).transfer_to_public(
-        owner,
-        orderbook_address,
-        bid_amount,
-        authwit_nonce,
-    );
-    add_private_authwit_from_call_interface(owner, orderbook_address, transfer_call_interface);
-
-    // Create order
-    let order_id = env.call_private(
-        owner,
-        Orderbook::at(orderbook_address).create_order(
-            token0_address,
-            token1_address,
-            bid_amount,
-            ask_amount,
-            authwit_nonce,
-        ),
-    );
-
-    // Get order and verify it's active
-    let (order, is_fulfilled) =
-        env.simulate_utility(Orderbook::at(orderbook_address).get_order(order_id));
-
-    assert_eq(order.bid_amount, bid_amount);
-    assert_eq(order.ask_amount, ask_amount);
-    assert_eq(order.bid_token_is_zero, true); // token0 -> token1
-    assert_eq(is_fulfilled, false);
-}
-
-#[test]
-unconstrained fn test_get_order_fulfilled() {
-    let (mut env, orderbook_address, token0_address, token1_address, maker, _) =
-        setup_orderbook_with_tokens(true);
-
-    let taker = env.create_contract_account();
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce_create = 1;
-    let authwit_nonce_fulfill = 2;
-
-    // Setup: mint tokens to maker and taker
-    mint_to_private(env, token0_address, maker, maker, bid_amount);
-    mint_to_private(env, token1_address, maker, taker, ask_amount);
-
-    // Create order first
-    let transfer_call_interface = Token::at(token0_address).transfer_to_public(
-        maker,
-        orderbook_address,
-        bid_amount,
-        authwit_nonce_create,
-    );
-    add_private_authwit_from_call_interface(maker, orderbook_address, transfer_call_interface);
-
-    let order_id = env.call_private(
-        maker,
-        Orderbook::at(orderbook_address).create_order(
-            token0_address,
-            token1_address,
-            bid_amount,
-            ask_amount,
-            authwit_nonce_create,
-        ),
-    );
-
-    // Create authwit for taker to transfer ask tokens
-    let maker_partial_note = PartialUintNote::from_field(order_id);
-    let fulfill_transfer_call_interface = Token::at(token1_address)
-        .finalize_transfer_to_private_from_private(
-            taker,
-            maker_partial_note,
-            ask_amount,
-            authwit_nonce_fulfill,
-        );
-    add_private_authwit_from_call_interface(
-        taker,
-        orderbook_address,
-        fulfill_transfer_call_interface,
-    );
-
-    // Fulfill order
-    env.call_private(
-        taker,
-        Orderbook::at(orderbook_address).fulfill_order(order_id, authwit_nonce_fulfill),
-    );
-
-    // Get order and verify it's fulfilled
-    let (order, is_fulfilled) =
-        env.simulate_utility(Orderbook::at(orderbook_address).get_order(order_id));
-
-    assert_eq(order.bid_amount, bid_amount);
-    assert_eq(order.ask_amount, ask_amount);
-    assert_eq(order.bid_token_is_zero, true); // token0 -> token1
-    assert_eq(is_fulfilled, true);
-}