Change default setup_policy of libtester to transition to Savanna

.cicd/defaults.json

@@ -4,6 +4,6 @@
        "prerelease":true
     },
     "referencecontracts":{
-       "ref":"main"
+       "ref":"fix_failures_by_default_tester"
     }
  }

libraries/testing/include/eosio/testing/tester.hpp

@@ -67,6 +67,7 @@ namespace eosio::testing {
       preactivate_feature_and_new_bios,
       old_wasm_parser,
       full_except_do_not_disable_deferred_trx,
+      full_except_do_not_transition_to_savanna,
       full
    };
 
@@ -542,7 +543,6 @@ namespace eosio::testing {
          vector<digest_type>                           protocol_features_to_be_activated_wo_preactivation;
          signed_block_ptr                              lib_block; // updated via irreversible_block signal
          block_id_type                                 lib_id;    // updated via irreversible_block signal
-         bool                                          is_savanna{false};
 
       private:
          std::vector<builtin_protocol_feature_t> get_all_builtin_protocol_features();
@@ -551,13 +551,11 @@ namespace eosio::testing {
 
    class tester : public base_tester {
    public:
-      tester(setup_policy policy = setup_policy::full, db_read_mode read_mode = db_read_mode::HEAD, std::optional<uint32_t> genesis_max_inline_action_size = std::optional<uint32_t>{}, bool is_savanna = false) {
-         this->is_savanna = is_savanna;
+      tester(setup_policy policy = setup_policy::full, db_read_mode read_mode = db_read_mode::HEAD, std::optional<uint32_t> genesis_max_inline_action_size = std::optional<uint32_t>{}) {
          init(policy, read_mode, genesis_max_inline_action_size);
       }
 
-      tester(controller::config config, const genesis_state& genesis, bool is_savanna = false) {
-         this->is_savanna = is_savanna;
+      tester(controller::config config, const genesis_state& genesis) {
          init(std::move(config), genesis);
       }
 
@@ -569,8 +567,7 @@ namespace eosio::testing {
          init(std::move(config), std::move(pfs), genesis);
       }
 
-      tester(const fc::temp_directory& tempdir, bool use_genesis, bool is_savanna = false) {
-         this->is_savanna = is_savanna;
+      tester(const fc::temp_directory& tempdir, bool use_genesis) {
          auto def_conf = default_config(tempdir);
          cfg = def_conf.first;
 
@@ -583,8 +580,7 @@ namespace eosio::testing {
       }
 
       template <typename Lambda>
-      tester(const fc::temp_directory& tempdir, Lambda conf_edit, bool use_genesis, bool is_savanna = false) {
-         this->is_savanna = is_savanna;
+      tester(const fc::temp_directory& tempdir, Lambda conf_edit, bool use_genesis) {
          auto def_conf = default_config(tempdir);
          cfg = def_conf.first;
          conf_edit(cfg);
@@ -623,19 +619,42 @@ namespace eosio::testing {
 
    };
 
-   class savanna_tester : public tester {
+   // The behavior of tester_not_transition_to_savanna under setup_policy::full
+   // behaves as the legacy tester: activating all the protocol features but not
+   // transition to Savanna consensus.
+   // If needed, the tester can be transitioned to Savanna by explicitly calling
+   // set_finalizer host function only.
+   class tester_not_transition_to_savanna : public tester {
    public:
-      savanna_tester(setup_policy policy = setup_policy::full, db_read_mode read_mode = db_read_mode::HEAD, std::optional<uint32_t> genesis_max_inline_action_size = std::optional<uint32_t>{});
-      savanna_tester(controller::config config, const genesis_state& genesis);
-      savanna_tester(const fc::temp_directory& tempdir, bool use_genesis);
+      tester_not_transition_to_savanna(setup_policy policy = setup_policy::full_except_do_not_transition_to_savanna, db_read_mode read_mode = db_read_mode::HEAD, std::optional<uint32_t> genesis_max_inline_action_size = std::optional<uint32_t>{})
+      : tester(policy == setup_policy::full ? setup_policy::full_except_do_not_transition_to_savanna
+                                            : policy,
+               read_mode, genesis_max_inline_action_size) {};
+
+      tester_not_transition_to_savanna(controller::config config, const genesis_state& genesis)
+      : tester(config, genesis) {};
+
+      tester_not_transition_to_savanna(const fc::temp_directory& tempdir, bool use_genesis)
+      : tester(tempdir, use_genesis) {};
 
       template <typename Lambda>
-      savanna_tester(const fc::temp_directory& tempdir, Lambda conf_edit, bool use_genesis)
-      : tester(tempdir, conf_edit, use_genesis, true) { // true for is_savanna
-      }
+      tester_not_transition_to_savanna(const fc::temp_directory& tempdir, Lambda conf_edit, bool use_genesis)
+      : tester(tempdir, conf_edit, use_genesis) {};
+
+      tester_not_transition_to_savanna(const std::function<void(controller&)>& control_setup, setup_policy policy = setup_policy::full, db_read_mode read_mode = db_read_mode::HEAD)
+      : tester(control_setup,
+               policy == setup_policy::full ? setup_policy::full_except_do_not_transition_to_savanna
+                                            : policy,
+               read_mode) {};
+
+      // setup_policy::full does not not transition to Savanna consensus.
+      void execute_setup_policy(const setup_policy policy) {
+         tester::execute_setup_policy(policy == setup_policy::full ? setup_policy::full_except_do_not_transition_to_savanna : policy);
+      };
    };
 
-   using legacy_tester = tester;
+   using legacy_tester  = tester_not_transition_to_savanna;
+   using savanna_tester = tester;
    using testers = boost::mpl::list<legacy_tester, savanna_tester>;
 
    class tester_no_disable_deferred_trx : public tester {
@@ -662,9 +681,7 @@ namespace eosio::testing {
       }
       controller::config vcfg;
 
-      validating_tester(const flat_set<account_name>& trusted_producers = flat_set<account_name>(), deep_mind_handler* dmlog = nullptr, setup_policy p = setup_policy::full, bool is_savanna = false) {
-         this->is_savanna = is_savanna;
-
+      validating_tester(const flat_set<account_name>& trusted_producers = flat_set<account_name>(), deep_mind_handler* dmlog = nullptr, setup_policy p = setup_policy::full) {
          auto def_conf = default_config(tempdir);
 
          vcfg = def_conf.first;
@@ -704,8 +721,7 @@ namespace eosio::testing {
       }
 
       template <typename Lambda>
-      validating_tester(const fc::temp_directory& tempdir, Lambda conf_edit, bool use_genesis, bool is_savanna = false) {
-         this->is_savanna = false;
+      validating_tester(const fc::temp_directory& tempdir, Lambda conf_edit, bool use_genesis) {
          auto def_conf = default_config(tempdir);
          conf_edit(def_conf.first);
          vcfg = def_conf.first;
@@ -780,17 +796,26 @@ namespace eosio::testing {
       }
    };
 
-   class savanna_validating_tester : public validating_tester {
+   // The behavior of validating_tester_not_transition_to_savanna under setup_policy::full
+   // behaves as the legacy validating_tester: activating all the protocol features but not
+   // transition to Savanna consensus.
+   // If needed, the tester can be transitioned to Savanna by explicitly calling
+   // set_finalizer host function only.
+   class validating_tester_not_transition_to_savanna : public validating_tester {
    public:
-      savanna_validating_tester(const flat_set<account_name>& trusted_producers = flat_set<account_name>(), deep_mind_handler* dmlog = nullptr, setup_policy p = setup_policy::full);
+      validating_tester_not_transition_to_savanna(const flat_set<account_name>& trusted_producers = flat_set<account_name>(), deep_mind_handler* dmlog = nullptr, setup_policy p = setup_policy::full_except_do_not_transition_to_savanna)
+      : validating_tester(trusted_producers, dmlog, p == setup_policy::full ? setup_policy::full_except_do_not_transition_to_savanna : p) {};
+
+      validating_tester_not_transition_to_savanna(const fc::temp_directory& tempdir, bool use_genesis)
+      : validating_tester(tempdir, use_genesis) {};
 
       template <typename Lambda>
-      savanna_validating_tester(const fc::temp_directory& tempdir, Lambda conf_edit, bool use_genesis)
-      : validating_tester(tempdir, conf_edit, use_genesis, true) { // true for is_savanna
-      }
+      validating_tester_not_transition_to_savanna(const fc::temp_directory& tempdir, Lambda conf_edit, bool use_genesis)
+      : validating_tester(tempdir, conf_edit, use_genesis) {};
    };
 
-   using legacy_validating_tester = validating_tester;
+   using legacy_validating_tester  = validating_tester_not_transition_to_savanna;
+   using savanna_validating_tester = validating_tester;
    using validating_testers = boost::mpl::list<legacy_validating_tester, savanna_validating_tester>;
 
    // -------------------------------------------------------------------------------------

libraries/testing/tester.cpp

@@ -274,21 +274,26 @@ namespace eosio::testing {
             break;
          }
          case setup_policy::full:
+         case setup_policy::full_except_do_not_transition_to_savanna:
          case setup_policy::full_except_do_not_disable_deferred_trx: {
             schedule_preactivate_protocol_feature();
             produce_block();
             set_before_producer_authority_bios_contract();
-            if( policy == setup_policy::full ) {
-               preactivate_all_builtin_protocol_features();
-            } else {
+            if( policy == setup_policy::full_except_do_not_disable_deferred_trx ) {
                preactivate_all_but_disable_deferred_trx();
+            } else {
+               preactivate_all_builtin_protocol_features();
             }
             produce_block();
             set_bios_contract();
-            if( is_savanna ) {
+
+            // Do not transition to Savanna under full_except_do_not_transition_to_savanna or
+            // full_except_do_not_disable_deferred_trx
+            if( policy == setup_policy::full ) {
                finalizer_keys fin_keys(*this, 4u /* num_keys */, 4u /* finset_size */);
                fin_keys.activate_savanna(0u /* first_key_idx */);
             }
+
             break;
          }
          case setup_policy::none:
@@ -1400,18 +1405,6 @@ namespace eosio::testing {
       execute_setup_policy(policy);
    }
 
-   savanna_tester::savanna_tester(setup_policy policy, db_read_mode read_mode, std::optional<uint32_t> genesis_max_inline_action_size)
-   : tester(policy, read_mode, genesis_max_inline_action_size, true) { // true for is_savanna
-   }
-
-   savanna_tester::savanna_tester(controller::config config, const genesis_state& genesis)
-   : tester(config, genesis, true) { // true for is_savanna
-   }
-
-   savanna_tester::savanna_tester(const fc::temp_directory& tempdir, bool use_genesis)
-   : tester(tempdir, use_genesis, true) { // true for is_savanna
-   }
-
    unique_ptr<controller> validating_tester::create_validating_node(controller::config vcfg, const genesis_state& genesis, bool use_genesis, deep_mind_handler* dmlog) {
       unique_ptr<controller> validating_node = std::make_unique<controller>(vcfg, make_protocol_feature_set(), genesis.compute_chain_id());
       validating_node->add_indices();
@@ -1429,10 +1422,6 @@ namespace eosio::testing {
       return validating_node;
    }
 
-   savanna_validating_tester::savanna_validating_tester(const flat_set<account_name>& trusted_producers, deep_mind_handler* dmlog, setup_policy p)
-   : validating_tester(trusted_producers, dmlog, p, true) { // true for is_savanna
-   }
-
    bool fc_exception_message_is::operator()( const fc::exception& ex ) {
       auto message = ex.get_log().at( 0 ).get_message();
       bool match = (message == expected);

tests/test_snapshot_information.cpp

@@ -20,8 +20,9 @@ BOOST_AUTO_TEST_SUITE(producer_snapshot_tests)
 
 using next_t = pending_snapshot<snapshot_scheduler::snapshot_information>::next_t;
 
-BOOST_AUTO_TEST_CASE_TEMPLATE(test_snapshot_information, SNAPSHOT_SUITE, snapshot_suites) {
-   tester chain;
+template<typename TESTER, typename SNAPSHOT_SUITE>
+void test_snapshot_information() {
+   TESTER chain;
    const std::filesystem::path parent_path = chain.get_config().blocks_dir.parent_path();
 
    chain.create_account("snapshot"_n);
@@ -30,13 +31,22 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_snapshot_information, SNAPSHOT_SUITE, snapsho
    chain.set_abi("snapshot"_n, test_contracts::snapshot_test_abi());
    chain.produce_blocks(1);
 
+   constexpr uint32_t savanna_base_block_num = 9;
    auto block = chain.produce_block();
-   BOOST_REQUIRE_EQUAL(block->block_num(), 6u); // ensure that test setup stays consistent with original snapshot setup
+   if constexpr (std::is_same_v<TESTER, savanna_tester>) {
+      BOOST_REQUIRE_EQUAL(block->block_num(), 6u + savanna_base_block_num); // ensure that test setup stays consistent with original snapshot setup
+   } else {
+      BOOST_REQUIRE_EQUAL(block->block_num(), 6u); // ensure that test setup stays consistent with original snapshot setup
+   }
    // undo the auto-pending from tester
    chain.control->abort_block();
 
    auto block2 = chain.produce_block();
-   BOOST_REQUIRE_EQUAL(block2->block_num(), 7u); // ensure that test setup stays consistent with original snapshot setup
+   if constexpr (std::is_same_v<TESTER, savanna_tester>) {
+      BOOST_REQUIRE_EQUAL(block2->block_num(), 7u + savanna_base_block_num); // ensure that test setup stays consistent with original snapshot setup
+   } else {
+      BOOST_REQUIRE_EQUAL(block2->block_num(), 7u); // ensure that test setup stays consistent with original snapshot setup
+   }
    // undo the auto-pending from tester
    chain.control->abort_block();
 
@@ -61,8 +71,17 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_snapshot_information, SNAPSHOT_SUITE, snapsho
    next_t next;
    pending_snapshot pending{ block2->previous, next, pending_path.generic_string(), final_path.generic_string() };
    test_snap_info = pending.finalize(*chain.control);
-   BOOST_REQUIRE_EQUAL(test_snap_info.head_block_num, 6u);
+   if constexpr (std::is_same_v<TESTER, savanna_tester>) {
+      BOOST_REQUIRE_EQUAL(test_snap_info.head_block_num, 6u + savanna_base_block_num);
+   } else {
+      BOOST_REQUIRE_EQUAL(test_snap_info.head_block_num, 6u);
+   }
    BOOST_REQUIRE_EQUAL(test_snap_info.version, chain_snapshot_header::current_version);
 }
 
+BOOST_AUTO_TEST_CASE_TEMPLATE(snapshot_information_test, SNAPSHOT_SUITE, snapshot_suites) {
+   test_snapshot_information<legacy_tester, SNAPSHOT_SUITE>();
+   test_snapshot_information<savanna_tester, SNAPSHOT_SUITE>();
+}
+
 BOOST_AUTO_TEST_SUITE_END()

unittests/chain_tests.cpp

@@ -16,7 +16,7 @@ using namespace eosio::testing;
 BOOST_AUTO_TEST_SUITE(chain_tests)
 
 BOOST_AUTO_TEST_CASE( replace_producer_keys ) try {
-   validating_tester tester;
+   legacy_validating_tester tester;
 
    const auto new_key = get_public_key(name("newkey"), config::active_name.to_string());
 

unittests/eosio_system_tester.hpp

@@ -16,7 +16,7 @@ using mvo = fc::mutable_variant_object;
 
 namespace eosio_system {
 
-template <typename T>
+template<typename T>
 class eosio_system_tester : public T {
 public:
 

unittests/finality_test_cluster.hpp

@@ -28,7 +28,7 @@ struct finality_node_t : public eosio::testing::tester {
    eosio::testing::finalizer_keys<tester>  finkeys;
    size_t                                  cur_key{0}; // index of key used in current policy
 
-   finality_node_t() : finkeys(*this) {}
+   finality_node_t() : eosio::testing::tester(eosio::testing::setup_policy::full_except_do_not_transition_to_savanna),  finkeys(*this) {}
 
    size_t last_vote_index() const {
       assert(!votes.empty());

unittests/finality_tests.cpp

@@ -10,7 +10,8 @@ BOOST_AUTO_TEST_SUITE(finality_tests)
 
 // test set_finalizer host function serialization and tester set_finalizers
 BOOST_AUTO_TEST_CASE(initial_set_finalizer_test) { try {
-   validating_tester t;
+   // Do not transition to Savanna at constrution. Transition explicitly later.
+   validating_tester_not_transition_to_savanna t;
 
    // Create finalizer keys
    constexpr size_t num_finalizers = 21;
@@ -60,7 +61,8 @@ BOOST_AUTO_TEST_CASE(initial_set_finalizer_test) { try {
 void test_finality_transition(const vector<account_name>& accounts,
                               const base_tester::finalizer_policy_input& input,
                               bool lib_advancing_expected) {
-   validating_tester t;
+   // Do not transition to Savanna at constrution. Transition explicitly later.
+   validating_tester_not_transition_to_savanna t;
 
    t.produce_block();
 

unittests/finalizer_update_tests.cpp

@@ -31,7 +31,8 @@ static void ensure_next_block_finalizer_policy(validating_tester& t,
 // to take effect.
 // ---------------------------------------------------------------------
 BOOST_AUTO_TEST_CASE(savanna_set_finalizer_single_test) { try {
-   validating_tester t;
+   // Do not transition to Savanna at constrution. Transition explicitly later.
+   validating_tester_not_transition_to_savanna t;
    size_t num_keys    = 22u;
    size_t finset_size = 21u;
 
@@ -67,7 +68,8 @@ BOOST_AUTO_TEST_CASE(savanna_set_finalizer_single_test) { try {
 // at the same time.
 // ---------------------------------------------------------------------------
 BOOST_AUTO_TEST_CASE(savanna_set_finalizer_multiple_test) { try {
-   validating_tester t;
+   // Do not transition to Savanna at constrution. Transition explicitly later.
+   validating_tester_not_transition_to_savanna t;
    size_t num_keys    = 50u;
    size_t finset_size = 21u;