added some negative tests, some more refactoring

Author: Bengt Lofgren

solana/modules/matching-engine-testing/tests/README.md

@@ -2,7 +2,9 @@
 
 ## How to read the tests
 
-Each test is found in the `integration_tests.rs` file.
+Each test is found in the `test_scenarios` directory.
+
+Each file in this directory is a module that contains tests for a specific subset of scenarios (instructions).
 
 Each test is a function that is annotated with `#[tokio::test]`.
 
@@ -12,7 +14,7 @@ The `TestingEngine` is initialised with a `TestingContext`. The `TestingContext`
 
 The `TestingEngine` is used to execute the instruction triggers in the order they are provided. See the `testing_engine/engine.rs` file for more details.
 
-## Integration Tests
+## Happy path integration tests
 
 ### Initialize program
 
@@ -40,4 +42,20 @@ What is expected:
 - Guardian set is closed
 - Close account refund recipient is sent usdc
 
+### Place initial offer (shimless)
+
+What is expected:
+- Fast market order is initialised
+- Initial offer is placed
+- Auction account is created and corresponds to a vaa and the initial offer
+
+### Place initial offer (shim)
+
+What is expected:
+- Fast market order is posted as a vaa
+- Initial offer is placed
+- Auction account is created and corresponds to a vaa and the initial offer
+
+
+
 

solana/modules/matching-engine-testing/tests/mod.rs

@@ -3,7 +3,6 @@
 
 mod shimful;
 mod shimless;
-// Where tests are located
 mod test_scenarios;
 mod testing_engine;
 mod utils;

solana/modules/matching-engine-testing/tests/shimful/README.md

@@ -2,3 +2,10 @@
 
 This directory contains tests that use the fallback program.
 
+## Files
+
+- `fast_market_order_shim.rs` - A function that creates a fast market order account and one that closes it
+- `shims_make_offer.rs` - A function that places an initial offer and one that improves an offer
+- `shims_execute_order.rs` - A function that executes an order
+- `shims_prepare_order_response.rs` - A function that prepares an order response
+- `shims_settle_auction.rs` - A function that settles an auction

solana/modules/matching-engine-testing/tests/shimful/shims_make_offer.rs

@@ -2,7 +2,7 @@ use crate::testing_engine::config::ExpectedError;
 use crate::testing_engine::state::InitialOfferPlacedState;
 
 use super::super::utils;
-use crate::testing_engine::setup::{Solver, TestingContext};
+use crate::testing_engine::setup::{TestingActor, TestingContext};
 use matching_engine::fallback::place_initial_offer::{
     PlaceInitialOfferCctpShim as PlaceInitialOfferCctpShimFallback,
     PlaceInitialOfferCctpShimAccounts as PlaceInitialOfferCctpShimFallbackAccounts,
@@ -42,14 +42,14 @@ pub async fn place_initial_offer_fallback(
     test_context: &mut ProgramTestContext,
     payer_signer: &Rc<Keypair>,
     vaa_data: &utils::vaa::PostedVaaData,
-    solver: Solver,
+    actor: TestingActor,
     fast_market_order_account: &Pubkey,
     auction_accounts: &utils::auction::AuctionAccounts,
     offer_price: u64,
     expected_error: Option<&ExpectedError>,
 ) -> Option<InitialOfferPlacedState> {
     let program_id = testing_context.get_matching_engine_program_id();
-    let fast_market_order = create_fast_market_order_state_from_vaa_data(vaa_data, solver.pubkey());
+    let fast_market_order = create_fast_market_order_state_from_vaa_data(vaa_data, actor.pubkey());
 
     let auction_address = Pubkey::find_program_address(
         &[Auction::SEED_PREFIX, &fast_market_order.digest()],
@@ -76,11 +76,11 @@ pub async fn place_initial_offer_fallback(
     )
     .0;
 
-    solver
+    actor
         .approve_usdc(test_context, &transfer_authority, 420_000__000_000)
         .await;
 
-    let solver_usdc_balance_before = solver.get_balance(test_context).await;
+    let actor_usdc_balance_before = actor.get_token_account_balance(test_context).await;
 
     let place_initial_offer_ix_data = PlaceInitialOfferCctpShimFallbackData::new(offer_price);
 
@@ -122,9 +122,9 @@ pub async fn place_initial_offer_fallback(
         .execute_and_verify_transaction(test_context, transaction, expected_error)
         .await;
     if expected_error.is_none() {
-        let solver_usdc_balance_after = solver.get_balance(test_context).await;
+        let actor_usdc_balance_after = actor.get_token_account_balance(test_context).await;
         assert!(
-            solver_usdc_balance_after < solver_usdc_balance_before,
+            actor_usdc_balance_after < actor_usdc_balance_before,
             "Solver USDC balance should have decreased"
         );
         let new_active_auction_state = utils::auction::ActiveAuctionState {

solana/modules/matching-engine-testing/tests/shimless/README.md

@@ -2,3 +2,11 @@
 
 This directory contains tests that do not use the fallback program.
 
+## Files
+
+- `place_initial_offer.rs` - A function that places an initial offer
+- `make_offer.rs` - A function that places an initial offer and one that improves an offer
+- `execute_order.rs` - A function that executes an order
+- `prepare_order_response.rs` - A function that prepares an order response
+- `settle_auction.rs` - A function that settles an auction
+

solana/modules/matching-engine-testing/tests/shimless/initialize.rs

@@ -10,7 +10,7 @@ use anchor_lang::AccountDeserialize;
 use anchor_spl::{associated_token::spl_associated_token_account, token::spl_token};
 use solana_program::{bpf_loader_upgradeable, system_program};
 
-use crate::testing_engine::config::ExpectedError;
+use crate::testing_engine::config::{ExpectedError, ExpectedLog};
 
 use crate::testing_engine::setup::TestingContext;
 use anchor_lang::{InstructionData, ToAccountMetas};
@@ -142,14 +142,14 @@ pub async fn initialize_program(
     test_context: &mut ProgramTestContext,
     auction_parameters_config: AuctionParametersConfig,
     expected_error: Option<&ExpectedError>,
+    expected_log_messages: Option<&Vec<ExpectedLog>>,
 ) -> Option<InitializeFixture> {
     let program_id = testing_context.get_matching_engine_program_id();
     let usdc_mint_address = testing_context.get_usdc_mint_address();
     let cctp_mint_recipient = testing_context.get_cctp_mint_recipient();
     let (custodian, _custodian_bump) =
         Pubkey::find_program_address(&[Custodian::SEED_PREFIX], &program_id);
 
-    // TODO: Figure out this seed? Where does the 0u32 come from?
     let (auction_config, _auction_config_bump) = Pubkey::find_program_address(
         &[
             AuctionConfig::SEED_PREFIX,
@@ -218,6 +218,35 @@ pub async fn initialize_program(
         .execute_and_verify_transaction(test_context, versioned_transaction, expected_error)
         .await;
 
+    if let Some(expected_log_messages) = expected_log_messages {
+        // Recreate the instruction
+        let instruction = Instruction {
+            program_id,
+            accounts: accounts.to_account_metas(None),
+            data: ix_data.data(),
+        };
+        let mut transaction =
+            Transaction::new_with_payer(&[instruction], Some(&test_context.payer.pubkey()));
+        let new_blockhash = testing_context
+            .get_new_latest_blockhash(test_context)
+            .await
+            .expect("Could not get new blockhash");
+        transaction.sign(
+            &[
+                &test_context.payer,
+                &testing_context.testing_actors.owner.keypair(),
+            ],
+            new_blockhash,
+        );
+        let versioned_transaction = VersionedTransaction::from(transaction);
+
+        // Simulate and verify logs
+        testing_context
+            .simulate_and_verify_logs(test_context, versioned_transaction, expected_log_messages)
+            .await
+            .expect("Failed to verify logs");
+    }
+
     if expected_error.is_none() {
         // Verify the results
         let custodian_account = test_context

solana/modules/matching-engine-testing/tests/shimless/make_offer.rs

@@ -25,6 +25,23 @@ use solana_sdk::transaction::Transaction;
 use utils::auction::{ActiveAuctionState, AuctionAccounts, AuctionOffer, AuctionState};
 use utils::vaa::TestVaa;
 
+/// Place an initial offer (shimless)
+///
+/// Place an initial offer by providing a price.
+///
+/// # Arguments
+///
+/// * `testing_context` - The testing context
+/// * `test_context` - The test context
+/// * `accounts` - The auction accounts
+/// * `fast_market_order` - The fast market order
+/// * `offer_price` - The price of the offer
+/// * `payer_signer` - The payer signer
+/// * `expected_error` - The expected error
+///
+/// # Returns
+///
+/// The new auction state if successful, otherwise the old auction state
 pub async fn place_initial_offer_shimless(
     testing_context: &TestingContext,
     test_context: &mut ProgramTestContext,
@@ -76,7 +93,7 @@ pub async fn place_initial_offer_shimless(
     .0;
     {
         // Check if solver has already approved usdc
-        let usdc_account = accounts.solver.token_account_address().unwrap();
+        let usdc_account = accounts.actor.token_account_address().unwrap();
         let usdc_account_info = test_context
             .banks_client
             .get_account(usdc_account)
@@ -89,14 +106,14 @@ pub async fn place_initial_offer_shimless(
         .expect("Failed to deserialize usdc account");
         if token_account_info.delegate.is_none() {
             accounts
-                .solver
+                .actor
                 .approve_usdc(test_context, &transfer_authority, 420_000__000_000)
                 .await;
         } else {
             let delegate = token_account_info.delegate.unwrap();
             if delegate != transfer_authority {
                 accounts
-                    .solver
+                    .actor
                     .approve_usdc(test_context, &transfer_authority, 420_000__000_000)
                     .await;
             }
@@ -173,6 +190,23 @@ pub async fn place_initial_offer_shimless(
     }
 }
 
+/// Improve an offer (shimless)
+///
+/// Improve an offer by providing a new price.
+///
+/// # Arguments
+///
+/// * `testing_context` - The testing context
+/// * `test_context` - The test context
+/// * `solver` - The solver
+/// * `offer_price` - The new price
+/// * `payer_signer` - The payer signer
+/// * `initial_auction_state` - The initial auction state
+/// * `expected_error` - The expected error
+///
+/// # Returns
+///
+/// The new auction state if successful, otherwise the old auction state
 pub async fn improve_offer(
     testing_context: &TestingContext,
     test_context: &mut ProgramTestContext,
@@ -181,7 +215,7 @@ pub async fn improve_offer(
     payer_signer: &Rc<Keypair>,
     initial_auction_state: &AuctionState,
     expected_error: Option<&ExpectedError>,
-) -> Option<AuctionState> {
+) -> AuctionState {
     let program_id = testing_context.get_matching_engine_program_id();
     let active_auction_state = initial_auction_state.get_active_auction().unwrap();
     let auction_config = active_auction_state.auction_config_address;
@@ -254,7 +288,7 @@ pub async fn improve_offer(
             .get_active_auction()
             .unwrap()
             .initial_offer;
-        Some(AuctionState::Active(Box::new(ActiveAuctionState {
+        AuctionState::Active(Box::new(ActiveAuctionState {
             auction_address,
             auction_custody_token_address,
             auction_config_address: auction_config,
@@ -264,8 +298,8 @@ pub async fn improve_offer(
                 offer_token,
                 offer_price,
             },
-        })))
+        }))
     } else {
-        None
+        initial_auction_state.clone()
     }
 }

solana/modules/matching-engine-testing/tests/shimless/prepare_order_response.rs

@@ -30,6 +30,25 @@ pub struct PrepareOrderResponseFixture {
     pub prepared_custody_token: Pubkey,
 }
 
+/// Prepare an order response (shimless)
+///
+/// Prepare an order response by providing a fast market order.
+///
+/// # Arguments
+///
+/// * `testing_context` - The testing context
+/// * `test_context` - The test context
+/// * `payer_signer` - The payer signer
+/// * `testing_engine_state` - The testing engine state
+/// * `to_endpoint_address` - The to endpoint address
+/// * `from_endpoint_address` - The from endpoint address
+/// * `base_fee_token_address` - The base fee token address
+/// * `expected_error` - The expected error
+/// * `expected_log_messages` - The expected log messages
+///
+/// # Returns
+///
+/// The prepared order response fixture if successful, otherwise None
 #[allow(clippy::too_many_arguments)]
 pub async fn prepare_order_response(
     testing_context: &TestingContext,
@@ -40,7 +59,7 @@ pub async fn prepare_order_response(
     from_endpoint_address: &Pubkey,
     base_fee_token_address: &Pubkey,
     expected_error: Option<&ExpectedError>,
-    expected_log_message: Option<&Vec<ExpectedLog>>,
+    expected_log_messages: Option<&Vec<ExpectedLog>>,
 ) -> Option<PrepareOrderResponseFixture> {
     let matching_engine_program_id = &testing_context.get_matching_engine_program_id();
     let usdc_mint_address = &testing_context.get_usdc_mint_address();
@@ -206,13 +225,9 @@ pub async fn prepare_order_response(
             .await
             .expect("Failed to get new blockhash"),
     );
-    if let Some(expected_log_message) = expected_log_message {
-        assert!(
-            expected_error.is_none(),
-            "Expected error is not allowed when expected log message is provided"
-        );
+    if let Some(expected_log_messages) = expected_log_messages {
         testing_context
-            .simulate_and_verify_logs(test_context, transaction, expected_log_message)
+            .simulate_and_verify_logs(test_context, transaction, expected_log_messages)
             .await
             .unwrap();
     } else {

solana/modules/matching-engine-testing/tests/shimless/settle_auction.rs

@@ -14,6 +14,23 @@ use solana_sdk::transaction::Transaction;
 use std::rc::Rc;
 use wormhole_svm_definitions::EVENT_AUTHORITY_SEED;
 
+/// Settle an auction (shimless)
+///
+/// Settle an auction by providing a prepare order response address, prepared custody token, and expected error.
+///
+/// # Arguments
+///
+/// * `testing_context` - The testing context
+/// * `test_context` - The test context
+/// * `payer_signer` - The payer signer
+/// * `auction_state` - The auction state
+/// * `prepare_order_response_address` - The prepare order response address
+/// * `prepared_custody_token` - The prepared custody token
+/// * `expected_error` - The expected error
+///
+/// # Returns
+///
+/// The new auction state if successful, otherwise the old auction state
 pub async fn settle_auction_complete(
     testing_context: &TestingContext,
     test_context: &mut ProgramTestContext,