test_trx_full.cpp File Reference

#include <boost/test/included/unit_test.hpp>
#include <sysio/producer_plugin/producer_plugin.hpp>
#include <sysio/testing/tester.hpp>
#include <sysio/chain/genesis_state.hpp>
#include <sysio/chain/thread_utils.hpp>
#include <sysio/chain/transaction_metadata.hpp>
#include <sysio/chain/trace.hpp>
#include <sysio/chain/name.hpp>
#include <appbase/application.hpp>

Include dependency graph for test_trx_full.cpp:

Go to the source code of this file.

Classes
struct	sysio::test::detail::testit

Namespaces
namespace	sysio
namespace	sysio::test
namespace	sysio::test::detail

Macros
#define	BOOST_TEST_MODULE   full_producer_trxs

Functions
	BOOST_AUTO_TEST_CASE (producer)

Macro Definition Documentation

BOOST_TEST_MODULE

#define BOOST_TEST_MODULE   full_producer_trxs

Definition at line 1 of file test_trx_full.cpp.

Function Documentation

BOOST_AUTO_TEST_CASE()

BOOST_AUTO_TEST_CASE

(

producer

)

Definition at line 102 of file test_trx_full.cpp.

                               {
   boost::filesystem::path temp = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
 
   try {
      std::promise<std::tuple<producer_plugin*, chain_plugin*>> plugin_promise;
      std::future<std::tuple<producer_plugin*, chain_plugin*>> plugin_fut = plugin_promise.get_future();
      std::thread app_thread( [&]() {
         fc::logger::get(DEFAULT_LOGGER).set_log_level(fc::log_level::debug);
         std::vector<const char*> argv =
               {"test", "--data-dir", temp.c_str(), "--config-dir", temp.c_str(),
                "-p", "sysio", "-e", "--max-transaction-time", "475", "--disable-subjective-billing=true" };
         appbase::app().initialize<chain_plugin, producer_plugin>( argv.size(), (char**) &argv[0] );
         appbase::app().startup();
         plugin_promise.set_value(
               {appbase::app().find_plugin<producer_plugin>(), appbase::app().find_plugin<chain_plugin>()} );
         appbase::app().exec();
      } );
 
      auto[prod_plug, chain_plug] = plugin_fut.get();
      auto chain_id = chain_plug->get_chain_id();
 
      std::deque<block_state_ptr> all_blocks;
      std::promise<void> empty_blocks_promise;
      std::future<void> empty_blocks_fut = empty_blocks_promise.get_future();
      auto ab = chain_plug->chain().accepted_block.connect( [&](const block_state_ptr& bsp) {
         static int num_empty = std::numeric_limits<int>::max();
         all_blocks.push_back( bsp );
         if( bsp->block->transactions.empty() ) {
            --num_empty;
            if( num_empty == 0 ) empty_blocks_promise.set_value();
         } else { // we want a few empty blocks after we have some non-empty blocks
            num_empty = 10;
         }
      } );
      auto bs = chain_plug->chain().block_start.connect( [&]( uint32_t bn ) {
      } );
 
      std::deque<packed_transaction_ptr> trxs;
      std::atomic<size_t> next_calls = 0;
      std::atomic<size_t> num_posts = 0;
      std::atomic<size_t> trace_with_except = 0;
      std::atomic<bool> trx_match = true;
      const size_t num_pushes = 4242;
      for( size_t i = 1; i <= num_pushes; ++i ) {
         auto ptrx = make_unique_trx( chain_id );
         dlog( "posting ${id}", ("id", ptrx->id()) );
         app().post( priority::low, [ptrx, &next_calls, &num_posts, &trace_with_except, &trx_match, &trxs]() {
            ++num_posts;
            bool return_failure_traces = false; // 2.2.x+ = num_posts % 2 == 0;
            app().get_method<plugin_interface::incoming::methods::transaction_async>()(ptrx,
               false, // persist_until_expiried
               false, // read_only
               false, // return_failure_traces
               [ptrx, &next_calls, &trace_with_except, &trx_match, &trxs, return_failure_traces]
               (const std::variant<fc::exception_ptr, transaction_trace_ptr>& result) {
                  if( !std::holds_alternative<fc::exception_ptr>( result ) && !std::get<chain::transaction_trace_ptr>( result )->except ) {
                     if( std::get<chain::transaction_trace_ptr>( result )->id == ptrx->id() ) {
                        trxs.push_back( ptrx );
                     } else {
                        elog( "trace not for trx ${id}: ${t}",
                              ("id", ptrx->id())("t", fc::json::to_pretty_string(*std::get<chain::transaction_trace_ptr>(result))) );
                        trx_match = false;
                     }
                  } else if( !return_failure_traces && !std::holds_alternative<fc::exception_ptr>( result ) && std::get<chain::transaction_trace_ptr>( result )->except ) {
                     elog( "trace with except ${e}",
                           ("e", fc::json::to_pretty_string( *std::get<chain::transaction_trace_ptr>( result ) )) );
                     ++trace_with_except;
                  }
                  ++next_calls;
           });
         });
         if( i % (num_pushes/3) == 0 ) {
            // need to sleep or a fast machine might put all trxs in one block
            usleep( config::block_interval_us / 2 );
         }
         if( i % 200 == 0 ) {
            // get_integrity_hash aborts block and places aborted trxs into unapplied_transaction_queue
            // verifying that aborting block does not lose transactions
            app().post(priority::high, [](){
               app().find_plugin<producer_plugin>()->get_integrity_hash();
            });
         }
      }
 
      empty_blocks_fut.wait_for(std::chrono::seconds(15));
 
      BOOST_CHECK_EQUAL( trace_with_except, 0 ); // should not have any traces with except in it
      BOOST_CHECK( all_blocks.size() > 3 ); // should have a few blocks otherwise test is running too fast
      BOOST_CHECK_EQUAL( num_pushes, num_posts );
      BOOST_CHECK_EQUAL( num_pushes, next_calls );
      BOOST_CHECK( trx_match.load() );
 
      appbase::app().quit();
      app_thread.join();
 
      BOOST_REQUIRE( verify_equal(trxs, all_blocks ) );
 
   } catch ( ... ) {
      bfs::remove_all( temp );
      throw;
   }
   bfs::remove_all( temp );
}

Here is the call graph for this function: