test_extraction.cpp File Reference

#include <boost/test/included/unit_test.hpp>
#include <sysio/chain/types.hpp>
#include <sysio/chain/contract_types.hpp>
#include <sysio/chain/trace.hpp>
#include <sysio/chain/transaction.hpp>
#include <sysio/chain/block.hpp>
#include <sysio/chain/block_state.hpp>
#include <sysio/trace_api/test_common.hpp>
#include <sysio/trace_api/chain_extraction.hpp>
#include <fc/bitutil.hpp>

Include dependency graph for test_extraction.cpp:

Go to the source code of this file.

Classes
struct	extraction_test_fixture
struct	extraction_test_fixture::mock_logfile_provider_type

Macros
#define	BOOST_TEST_MODULE   trace_data_extraction

Functions
	BOOST_FIXTURE_TEST_CASE (basic_single_transaction_block, extraction_test_fixture)
	BOOST_FIXTURE_TEST_CASE (basic_multi_transaction_block, extraction_test_fixture)
	BOOST_FIXTURE_TEST_CASE (onerror_transaction_block, extraction_test_fixture)

Macro Definition Documentation

BOOST_TEST_MODULE

#define BOOST_TEST_MODULE   trace_data_extraction

Definition at line 1 of file test_extraction.cpp.

Function Documentation

BOOST_FIXTURE_TEST_CASE() [1/3]

BOOST_FIXTURE_TEST_CASE	(	basic_multi_transaction_block	,
		extraction_test_fixture	)

Definition at line 239 of file test_extraction.cpp.

                                                                                   {
      auto act1 = make_transfer_action( "alice"_n, "bob"_n, "0.0001 SYS"_t, "Memo!" );
      auto act2 = make_transfer_action( "bob"_n, "alice"_n, "0.0001 SYS"_t, "Memo!" );
      auto act3 = make_transfer_action( "fred"_n, "bob"_n, "0.0001 SYS"_t, "Memo!" );
      auto actt1 = make_action_trace( 0, act1, "sysio.token"_n );
      auto actt2 = make_action_trace( 1, act2, "bob"_n );
      auto actt3 = make_action_trace( 2, act3, "fred"_n );
      auto ptrx1 = make_packed_trx( { act1 } );
      auto ptrx2 = make_packed_trx( { act2 } );
      auto ptrx3 = make_packed_trx( { act3 } );
 
      signal_applied_transaction(
            make_transaction_trace( ptrx1.id(), 1, 1, chain::transaction_receipt_header::executed,
                  { actt1 } ),
            std::make_shared<packed_transaction>( ptrx1 ) );
      signal_applied_transaction(
            make_transaction_trace( ptrx2.id(), 1, 1, chain::transaction_receipt_header::executed,
                  { actt2 } ),
            std::make_shared<packed_transaction>( ptrx2 ) );
      signal_applied_transaction(
            make_transaction_trace( ptrx3.id(), 1, 1, chain::transaction_receipt_header::executed,
                  { actt3 } ),
            std::make_shared<packed_transaction>( ptrx3 ) );
 
      // accept the block with three transaction
      auto bsp1 = make_block_state( chain::block_id_type(), 1, 1, "bp.one"_n,
            { chain::packed_transaction(ptrx1), chain::packed_transaction(ptrx2), chain::packed_transaction(ptrx3) } );
      signal_accepted_block( bsp1 );
 
      const std::vector<action_trace_v1> expected_action_trace1 {
         {
            {
               0,
               "sysio.token"_n, "sysio.token"_n, "transfer"_n,
               {{"alice"_n, "active"_n}},
               make_transfer_data("alice"_n, "bob"_n, "0.0001 SYS"_t, "Memo!")
            },
            {}
         }
      };
 
      const std::vector<action_trace_v1> expected_action_trace2 {
         {
            {
               1,
               "bob"_n, "sysio.token"_n, "transfer"_n,
               {{ "bob"_n, "active"_n }},
               make_transfer_data( "bob"_n, "alice"_n, "0.0001 SYS"_t, "Memo!" )
            },
            {}
         }
      };
 
      const std::vector<action_trace_v1> expected_action_trace3 {
         {
            {
               2,
               "fred"_n, "sysio.token"_n, "transfer"_n,
               {{ "fred"_n, "active"_n }},
               make_transfer_data( "fred"_n, "bob"_n, "0.0001 SYS"_t, "Memo!" )
            },
            {}
         }
      };
 
      const std::vector<transaction_trace_v3> expected_transaction_traces {
         {
            {
               ptrx1.id(),
               expected_action_trace1,
               fc::enum_type<uint8_t, chain::transaction_receipt_header::status_enum>{bsp1->block->transactions[0].status},
               bsp1->block->transactions[0].cpu_usage_us,
               bsp1->block->transactions[0].net_usage_words,
               ptrx1.get_signatures(),
               make_trx_header(ptrx1.get_transaction())
            }
         },
         {
            {
               ptrx2.id(),
               expected_action_trace2,
               fc::enum_type<uint8_t, chain::transaction_receipt_header::status_enum>{bsp1->block->transactions[1].status},
               bsp1->block->transactions[1].cpu_usage_us,
               bsp1->block->transactions[1].net_usage_words,
               ptrx2.get_signatures(),
               make_trx_header(ptrx2.get_transaction())
            }
         },
         {
            {
               ptrx3.id(),
               expected_action_trace3,
               fc::enum_type<uint8_t, chain::transaction_receipt_header::status_enum>{bsp1->block->transactions[2].status},
               bsp1->block->transactions[2].cpu_usage_us,
               bsp1->block->transactions[2].net_usage_words,
               ptrx3.get_signatures(),
               make_trx_header(ptrx3.get_transaction())
            }
         }
      };
 
      const block_trace_v2 expected_block_trace {
         bsp1->id,
         1,
         bsp1->prev(),
         chain::block_timestamp_type(1),
         "bp.one"_n,
         bsp1->block->transaction_mroot,
         bsp1->block->action_mroot,
         bsp1->block->schedule_version,
         expected_transaction_traces
      };
 
      BOOST_REQUIRE_EQUAL(max_lib, 0);
      BOOST_REQUIRE(data_log.size() == 1);
      BOOST_REQUIRE(std::holds_alternative<block_trace_v2>(data_log.at(0)));
      BOOST_REQUIRE_EQUAL(std::get<block_trace_v2>(data_log.at(0)), expected_block_trace);
   }

Here is the call graph for this function:

BOOST_FIXTURE_TEST_CASE() [2/3]

BOOST_FIXTURE_TEST_CASE	(	basic_single_transaction_block	,
		extraction_test_fixture	)

Definition at line 155 of file test_extraction.cpp.

   {
      auto act1 = make_transfer_action( "alice"_n, "bob"_n, "0.0001 SYS"_t, "Memo!" );
      auto act2 = make_transfer_action( "alice"_n, "bob"_n, "0.0001 SYS"_t, "Memo!" );
      auto act3 = make_transfer_action( "alice"_n, "bob"_n, "0.0001 SYS"_t, "Memo!" );
      auto actt1 = make_action_trace( 0, act1, "sysio.token"_n );
      auto actt2 = make_action_trace( 1, act2, "alice"_n );
      auto actt3 = make_action_trace( 2, act3, "bob"_n );
      auto ptrx1 = make_packed_trx( { act1, act2, act3 } );
 
      // apply a basic transfer
      signal_applied_transaction(
            make_transaction_trace( ptrx1.id(), 1, 1, chain::transaction_receipt_header::executed,
                  { actt1, actt2, actt3 } ),
            std::make_shared<packed_transaction>(ptrx1) );
      
      // accept the block with one transaction
      auto bsp1 = make_block_state( chain::block_id_type(), 1, 1, "bp.one"_n,
            { chain::packed_transaction(ptrx1) } );
      signal_accepted_block( bsp1 );
      
      const std::vector<action_trace_v1> expected_action_traces {
         {
            {
               0,
               "sysio.token"_n, "sysio.token"_n, "transfer"_n,
               {{"alice"_n, "active"_n}},
               make_transfer_data("alice"_n, "bob"_n, "0.0001 SYS"_t, "Memo!")
            },
            {}
         },
         {
            {
               1,
               "alice"_n, "sysio.token"_n, "transfer"_n,
               {{"alice"_n, "active"_n}},
               make_transfer_data("alice"_n, "bob"_n, "0.0001 SYS"_t, "Memo!")
            },
            {}
         },
         {
            {
               2,
               "bob"_n, "sysio.token"_n, "transfer"_n,
               {{"alice"_n, "active"_n}},
               make_transfer_data("alice"_n, "bob"_n, "0.0001 SYS"_t, "Memo!")
            },
            {}
         }
      };
 
      const transaction_trace_v3 expected_transaction_trace {
         {
            ptrx1.id(),
            expected_action_traces,
            fc::enum_type<uint8_t, chain::transaction_receipt_header::status_enum>{bsp1->block->transactions[0].status},
            bsp1->block->transactions[0].cpu_usage_us,
            bsp1->block->transactions[0].net_usage_words,
            ptrx1.get_signatures(),
            make_trx_header(ptrx1.get_transaction())
         }
      };
 
      const block_trace_v2 expected_block_trace {
         bsp1->id,
         1,
         bsp1->prev(),
         chain::block_timestamp_type(1),
         "bp.one"_n,
         bsp1->block->transaction_mroot,
         bsp1->block->action_mroot,
         bsp1->block->schedule_version,
         std::vector<transaction_trace_v3> {
            expected_transaction_trace
         }
      };
 
      BOOST_REQUIRE_EQUAL(max_lib, 0);
      BOOST_REQUIRE(data_log.size() == 1);
      BOOST_REQUIRE(std::holds_alternative<block_trace_v2>(data_log.at(0)));
      BOOST_REQUIRE_EQUAL(std::get<block_trace_v2>(data_log.at(0)), expected_block_trace);
      BOOST_REQUIRE_EQUAL(id_log.at(bsp1->block_num).size(),  bsp1->block->transactions.size());
   }

Here is the call graph for this function:

BOOST_FIXTURE_TEST_CASE() [3/3]

BOOST_FIXTURE_TEST_CASE	(	onerror_transaction_block	,
		extraction_test_fixture	)

Definition at line 358 of file test_extraction.cpp.

   {
      auto onerror_act = make_onerror_action( "alice"_n, 1 );
      auto actt1 = make_action_trace( 0, onerror_act, "sysio.token"_n );
      auto ptrx1 = make_packed_trx( { onerror_act } );
 
      auto act2 = make_transfer_action( "bob"_n, "alice"_n, "0.0001 SYS"_t, "Memo!" );
      auto actt2 = make_action_trace( 1, act2, "bob"_n );
      auto transfer_trx = make_packed_trx( { act2 } );
 
      auto onerror_trace = make_transaction_trace( ptrx1.id(), 1, 1, chain::transaction_receipt_header::executed,
                              { actt1 } );
      auto transfer_trace = make_transaction_trace( transfer_trx.id(), 1, 1, chain::transaction_receipt_header::soft_fail,
                                                   { actt2 } );
      onerror_trace->failed_dtrx_trace = transfer_trace;
 
      signal_applied_transaction( onerror_trace, std::make_shared<packed_transaction>( transfer_trx ) );
 
      auto bsp1 = make_block_state( chain::block_id_type(), 1, 1, "bp.one"_n,
            { chain::packed_transaction(transfer_trx) } );
      signal_accepted_block( bsp1 );
 
      const std::vector<action_trace_v1> expected_action_trace {
         {
            {
               0,
               "sysio.token"_n, "sysio"_n, "onerror"_n,
               {{ "alice"_n, "active"_n }},
               make_onerror_data( chain::onerror{ 1, "test ", 4 } )
            },
            {}
         }
      };
 
      const std::vector<transaction_trace_v3> expected_transaction_traces {
         {
            {
               transfer_trx.id(), // transfer_trx.id() because that is the trx id known to the user
               expected_action_trace,
               fc::enum_type<uint8_t, chain::transaction_receipt_header::status_enum>{bsp1->block->transactions[0].status},
               bsp1->block->transactions[0].cpu_usage_us,
               bsp1->block->transactions[0].net_usage_words,
               transfer_trx.get_signatures(),
               make_trx_header(transfer_trx.get_transaction())
            }
         }
      };
 
      const block_trace_v2 expected_block_trace {
         bsp1->id,
         1,
         bsp1->prev(),
         chain::block_timestamp_type(1),
         "bp.one"_n,
         bsp1->block->transaction_mroot,
         bsp1->block->action_mroot,
         bsp1->block->schedule_version,
         expected_transaction_traces
      };
 
      BOOST_REQUIRE_EQUAL(max_lib, 0);
      BOOST_REQUIRE(data_log.size() == 1);
      BOOST_REQUIRE(std::holds_alternative<block_trace_v2>(data_log.at(0)));
      BOOST_REQUIRE_EQUAL(std::get<block_trace_v2>(data_log.at(0)), expected_block_trace);
   }

Here is the call graph for this function: