passing all tests

Signed-off-by: Jürgen Eckel <juergen@riddleandcode.com>

planetmint/application/validator.py

@@ -492,7 +492,7 @@ class Validator():
             self.migrate_abci_chain()
         if election.operation == VALIDATOR_ELECTION:
             validator_updates = [election.assets[0].data]
-            curr_validator_set = self.models.get_validators(new_height)
+            curr_validator_set = self.models.get_validators(height=new_height)
             updated_validator_set = new_validator_set(curr_validator_set, validator_updates)
 
             updated_validator_set = [v for v in updated_validator_set if v["voting_power"] > 0]

tests/commands/test_commands.py

@@ -25,10 +25,14 @@ from planetmint.backend.connection import Connection
 
 from tests.utils import generate_election, generate_validators
 
-def mock_get_validators(height):
+
+def mock_get_validators(self, height):
     return [
         {
-            "public_key": {"value": "zL/DasvKulXZzhSNFwx4cLRXKkSM9GPK7Y0nZ4FEylM=", "type": "ed25519-base64"},
+            "public_key": {
+                "value": "zL/DasvKulXZzhSNFwx4cLRXKkSM9GPK7Y0nZ4FEylM=",
+                "type": "ed25519-base64",
+            },
             "voting_power": 10,
         }
     ]
@@ -38,18 +42,19 @@ def mock_get_validators(height):
 def test_main_entrypoint(mock_start):
     from planetmint.commands.planetmint import main
     from planetmint.model.dataaccessor import DataAccessor
-    
+
     da = DataAccessor
     del da
     main()
 
     assert mock_start.called
 
+
 #@pytest.mark.bdb
-def test_chain_migration_election_show_shows_inconclusive(b, test_abci_rpc ):
+def test_chain_migration_election_show_shows_inconclusive(b_flushed, test_abci_rpc ):
-    
     from tests.utils import flush_db
-    flush_db(b.models.connection, "dbname")
+    b = b_flushed
+
     validators = generate_validators([1] * 4)
     output = b.models.store_validator_set(1, [v["storage"] for v in validators])
 
@@ -57,7 +62,9 @@ def test_chain_migration_election_show_shows_inconclusive(b, test_abci_rpc ):
     private_key = validators[0]["private_key"]
     voter_keys = [v["private_key"] for v in validators]
 
-    election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys)
+    election, votes = generate_election(
+        b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys
+    )
 
     assert not run_election_show(Namespace(election_id=election.id), b)
 
@@ -74,11 +81,15 @@ def test_chain_migration_election_show_shows_inconclusive(b, test_abci_rpc ):
     b.models.store_block(Block(height=2, transactions=[], app_hash="")._asdict())
     # TODO insert yet another block here when upgrading to Tendermint 0.22.4.
 
-    assert run_election_show(Namespace(election_id=election.id), b) == "status=inconclusive"
+    assert (
+        run_election_show(Namespace(election_id=election.id), b)
+        == "status=inconclusive"
+    )
 
 
 @pytest.mark.bdb
-def test_chain_migration_election_show_shows_concluded(b):
+def test_chain_migration_election_show_shows_concluded(b_flushed):
+    b=b_flushed
     validators = generate_validators([1] * 4)
     b.models.store_validator_set(1, [v["storage"] for v in validators])
 
@@ -86,7 +97,9 @@ def test_chain_migration_election_show_shows_concluded(b):
     private_key = validators[0]["private_key"]
     voter_keys = [v["private_key"] for v in validators]
 
-    election, votes = generate_election(b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys)
+    election, votes = generate_election(
+        b, ChainMigrationElection, public_key, private_key, [{"data": {}}], voter_keys
+    )
 
     assert not run_election_show(Namespace(election_id=election.id), b)
 
@@ -96,7 +109,11 @@ def test_chain_migration_election_show_shows_concluded(b):
     assert run_election_show(Namespace(election_id=election.id), b) == "status=ongoing"
 
     b.models.store_abci_chain(1, "chain-X")
-    b.models.store_block(Block(height=1, transactions=[v.id for v in votes], app_hash="last_app_hash")._asdict())
+    b.models.store_block(
+        Block(
+            height=1, transactions=[v.id for v in votes], app_hash="last_app_hash"
+        )._asdict()
+    )
     b.process_block(2, votes)
 
     assert (
@@ -140,25 +157,41 @@ def test_make_sure_we_dont_remove_any_command():
         ]
     ).command
     assert parser.parse_args(
-        ["election", "new", "chain-migration", "--private-key", "TEMP_PATH_TO_PRIVATE_KEY"]
+        [
+            "election",
+            "new",
+            "chain-migration",
+            "--private-key",
+            "TEMP_PATH_TO_PRIVATE_KEY",
+        ]
     ).command
     assert parser.parse_args(
-        ["election", "approve", "ELECTION_ID", "--private-key", "TEMP_PATH_TO_PRIVATE_KEY"]
+        [
+            "election",
+            "approve",
+            "ELECTION_ID",
+            "--private-key",
+            "TEMP_PATH_TO_PRIVATE_KEY",
+        ]
     ).command
     assert parser.parse_args(["election", "show", "ELECTION_ID"]).command
     assert parser.parse_args(["tendermint-version"]).command
 
 
-
-
 @pytest.mark.bdb
-def test_election_approve_called_with_bad_key(monkeypatch, caplog, b, bad_validator_path, new_validator, node_key, test_abci_rpc):
+def test_election_approve_called_with_bad_key(
+    monkeypatch, caplog, b, bad_validator_path, new_validator, node_key, test_abci_rpc
+):
     from argparse import Namespace
 
-    b, election_id = call_election(monkeypatch, b, new_validator, node_key, test_abci_rpc)
+    b, election_id = call_election(
+        monkeypatch, b, new_validator, node_key, test_abci_rpc
+    )
 
     # call run_upsert_validator_approve with args that point to the election, but a bad signing key
-    args = Namespace(action="approve", election_id=election_id, sk=bad_validator_path, config={})
+    args = Namespace(
+        action="approve", election_id=election_id, sk=bad_validator_path, config={}
+    )
 
     with caplog.at_level(logging.ERROR):
         assert not run_election_approve(args, b, test_abci_rpc)
@@ -171,7 +204,9 @@ def test_election_approve_called_with_bad_key(monkeypatch, caplog, b, bad_valida
 @patch("planetmint.config_utils.setup_logging")
 @patch("planetmint.commands.planetmint._run_init")
 @patch("planetmint.config_utils.autoconfigure")
-def test_bigchain_run_start(mock_setup_logging, mock_run_init, mock_autoconfigure, mock_processes_start):
+def test_bigchain_run_start(
+    mock_setup_logging, mock_run_init, mock_autoconfigure, mock_processes_start
+):
     from planetmint.commands.planetmint import run_start
 
     args = Namespace(config=None, yes=True, skip_initialize_database=False)
@@ -209,7 +244,9 @@ def test_bigchain_show_config(capsys):
 
 
 def test__run_init(mocker):
-    init_db_mock = mocker.patch("planetmint.backend.tarantool.sync_io.connection.TarantoolDBConnection.init_database")
+    init_db_mock = mocker.patch(
+        "planetmint.backend.tarantool.sync_io.connection.TarantoolDBConnection.init_database"
+    )
 
     conn = Connection()
     conn.init_database()
@@ -268,7 +305,10 @@ def test_drop_db_does_not_drop_when_interactive_no(mock_db_drop, monkeypatch):
 # switch with pytest. It will just hang. Seems related to the monkeypatching of
 # input_on_stderr.
 def test_run_configure_when_config_does_not_exist(
-    monkeypatch, mock_write_config, mock_generate_key_pair, mock_planetmint_backup_config
+    monkeypatch,
+    mock_write_config,
+    mock_generate_key_pair,
+    mock_planetmint_backup_config,
 ):
     from planetmint.commands.planetmint import run_configure
 
@@ -280,7 +320,10 @@ def test_run_configure_when_config_does_not_exist(
 
 
 def test_run_configure_when_config_does_exist(
-    monkeypatch, mock_write_config, mock_generate_key_pair, mock_planetmint_backup_config
+    monkeypatch,
+    mock_write_config,
+    mock_generate_key_pair,
+    mock_planetmint_backup_config,
 ):
     value = {}
 
@@ -319,7 +362,9 @@ def test_run_configure_with_backend(backend, monkeypatch, mock_write_config):
 
     # update the expected config with the correct backend and keypair
     backend_conf = getattr(planetmint, "_database_" + backend)
-    expected_config.update({"database": backend_conf, "keypair": value["return"]["keypair"]})
+    expected_config.update(
+        {"database": backend_conf, "keypair": value["return"]["keypair"]}
+    )
 
     assert value["return"] == expected_config
 
@@ -341,12 +386,16 @@ def test_calling_main(start_mock, monkeypatch):
     assert argparser_mock.called is True
     parser.add_subparsers.assert_called_with(title="Commands", dest="command")
     subparsers.add_parser.assert_any_call("configure", help="Prepare the config file.")
-    subparsers.add_parser.assert_any_call("show-config", help="Show the current " "configuration")
+    subparsers.add_parser.assert_any_call(
+        "show-config", help="Show the current " "configuration"
+    )
     subparsers.add_parser.assert_any_call("init", help="Init the database")
     subparsers.add_parser.assert_any_call("drop", help="Drop the database")
 
     subparsers.add_parser.assert_any_call("start", help="Start Planetmint")
-    subparsers.add_parser.assert_any_call("tendermint-version", help="Show the Tendermint supported " "versions")
+    subparsers.add_parser.assert_any_call(
+        "tendermint-version", help="Show the Tendermint supported " "versions"
+    )
 
     assert start_mock.called is True
 
@@ -386,11 +435,15 @@ def test_run_recover(b, alice, bob, test_models):
     b.models.store_bulk_transactions([tx1, tx2])
 
     # create a random block
-    block8 = Block(app_hash="random_app_hash1", height=8, transactions=["txid_doesnt_matter"])._asdict()
+    block8 = Block(
+        app_hash="random_app_hash1", height=8, transactions=["txid_doesnt_matter"]
+    )._asdict()
     b.models.store_block(block8)
 
     # create the next block
-    block9 = Block(app_hash="random_app_hash1", height=9, transactions=[tx1.id])._asdict()
+    block9 = Block(
+        app_hash="random_app_hash1", height=9, transactions=[tx1.id]
+    )._asdict()
     b.models.store_block(block9)
 
     # create a pre_commit state which is ahead of the commit state
@@ -412,7 +465,9 @@ class MockResponse:
 
 
 @pytest.mark.abci
-def test_election_new_upsert_validator_with_tendermint(b, priv_validator_path, user_sk, validators, test_abci_rpc):
+def test_election_new_upsert_validator_with_tendermint(
+    b, priv_validator_path, user_sk, validators, test_abci_rpc
+):
     new_args = Namespace(
         action="new",
         election_type="upsert-validator",
@@ -429,33 +484,46 @@ def test_election_new_upsert_validator_with_tendermint(b, priv_validator_path, u
 
 
 @pytest.mark.bdb
-def test_election_new_upsert_validator_without_tendermint(caplog, b, priv_validator_path, user_sk, test_abci_rpc):
+def test_election_new_upsert_validator_without_tendermint(
-    def mock_write(modelist, endpoint, mode_commit, transaction, mode):
+    monkeypatch, caplog, b, priv_validator_path, user_sk, test_abci_rpc
+):
+    def mock_write(self, modelist, endpoint, mode_commit, transaction, mode):
         b.models.store_bulk_transactions([transaction])
         return (202, "")
 
-    b.models.get_validators = mock_get_validators
+    with monkeypatch.context() as m:
-    test_abci_rpc.write_transaction = mock_write
+        from planetmint.model.dataaccessor import DataAccessor
 
-    args = Namespace(
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
-        action="new",
+        m.setattr("planetmint.abci.rpc.ABCI_RPC.write_transaction", mock_write)
-        election_type="upsert-validator",
-        public_key="CJxdItf4lz2PwEf4SmYNAu/c/VpmX39JEgC5YpH7fxg=",
-        power=1,
-        node_id="fb7140f03a4ffad899fabbbf655b97e0321add66",
-        sk=priv_validator_path,
-        config={},
-    )
 
-    with caplog.at_level(logging.INFO):
+        args = Namespace(
-        election_id = run_election_new_upsert_validator(args, b, test_abci_rpc)
+            action="new",
-        assert caplog.records[0].msg == "[SUCCESS] Submitted proposal with id: " + election_id
+            election_type="upsert-validator",
-        assert b.models.get_transaction(election_id)
+            public_key="CJxdItf4lz2PwEf4SmYNAu/c/VpmX39JEgC5YpH7fxg=",
+            power=1,
+            node_id="fb7140f03a4ffad899fabbbf655b97e0321add66",
+            sk=priv_validator_path,
+            config={},
+        )
+
+        with caplog.at_level(logging.INFO):
+            election_id = run_election_new_upsert_validator(args, b, test_abci_rpc)
+            assert (
+                caplog.records[0].msg
+                == "[SUCCESS] Submitted proposal with id: " + election_id
+            )
+            assert b.models.get_transaction(election_id)
+        m.undo()
 
 
 @pytest.mark.abci
-def test_election_new_chain_migration_with_tendermint(b, priv_validator_path, user_sk, validators, test_abci_rpc):
+def test_election_new_chain_migration_with_tendermint(
-    new_args = Namespace(action="new", election_type="migration", sk=priv_validator_path, config={})
+    b, priv_validator_path, user_sk, validators, test_abci_rpc
+):
+    new_args = Namespace(
+        action="new", election_type="migration", sk=priv_validator_path, config={}
+    )
 
     election_id = run_election_new_chain_migration(new_args, b, test_abci_rpc)
 
@@ -463,24 +531,36 @@ def test_election_new_chain_migration_with_tendermint(b, priv_validator_path, us
 
 
 @pytest.mark.bdb
-def test_election_new_chain_migration_without_tendermint(caplog, b, priv_validator_path, user_sk, test_abci_rpc):
+def test_election_new_chain_migration_without_tendermint(
-    def mock_write(modelist, endpoint, mode_commit, transaction, mode):
+    monkeypatch, caplog, b, priv_validator_path, user_sk, test_abci_rpc
+):
+    def mock_write(self, modelist, endpoint, mode_commit, transaction, mode):
         b.models.store_bulk_transactions([transaction])
         return (202, "")
 
-    b.models.get_validators = mock_get_validators
+    with monkeypatch.context() as m:
-    test_abci_rpc.write_transaction = mock_write
+        from planetmint.model.dataaccessor import DataAccessor
 
-    args = Namespace(action="new", election_type="migration", sk=priv_validator_path, config={})
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
+        m.setattr("planetmint.abci.rpc.ABCI_RPC.write_transaction", mock_write)
 
-    with caplog.at_level(logging.INFO):
+        args = Namespace(
-        election_id = run_election_new_chain_migration(args, b, test_abci_rpc)
+            action="new", election_type="migration", sk=priv_validator_path, config={}
-        assert caplog.records[0].msg == "[SUCCESS] Submitted proposal with id: " + election_id
+        )
-        assert b.models.get_transaction(election_id)
+
+        with caplog.at_level(logging.INFO):
+            election_id = run_election_new_chain_migration(args, b, test_abci_rpc)
+            assert (
+                caplog.records[0].msg
+                == "[SUCCESS] Submitted proposal with id: " + election_id
+            )
+            assert b.models.get_transaction(election_id)
 
 
 @pytest.mark.bdb
-def test_election_new_upsert_validator_invalid_election(caplog, b, priv_validator_path, user_sk, test_abci_rpc):
+def test_election_new_upsert_validator_invalid_election(
+    caplog, b, priv_validator_path, user_sk, test_abci_rpc
+):
     args = Namespace(
         action="new",
         election_type="upsert-validator",
@@ -497,32 +577,40 @@ def test_election_new_upsert_validator_invalid_election(caplog, b, priv_validato
 
 
 @pytest.mark.bdb
-def test_election_new_upsert_validator_invalid_power(caplog, b, priv_validator_path, user_sk, test_abci_rpc):
+def test_election_new_upsert_validator_invalid_power(
+    monkeypatch, caplog, b, priv_validator_path, user_sk, test_abci_rpc
+):
     from transactions.common.exceptions import InvalidPowerChange
 
-    def mock_write(modelist, endpoint, mode_commit, transaction, mode):
+    def mock_write(self, modelist, endpoint, mode_commit, transaction, mode):
         b.models.store_bulk_transactions([transaction])
         return (400, "")
 
-    test_abci_rpc.write_transaction = mock_write
+    with monkeypatch.context() as m:
-    b.models.get_validators = mock_get_validators
+        from planetmint.model.dataaccessor import DataAccessor
-    args = Namespace(
-        action="new",
-        election_type="upsert-validator",
-        public_key="CJxdItf4lz2PwEf4SmYNAu/c/VpmX39JEgC5YpH7fxg=",
-        power=10,
-        node_id="fb7140f03a4ffad899fabbbf655b97e0321add66",
-        sk=priv_validator_path,
-        config={},
-    )
 
-    with caplog.at_level(logging.ERROR):
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
-        assert not run_election_new_upsert_validator(args, b, test_abci_rpc)
+        m.setattr("planetmint.abci.rpc.ABCI_RPC.write_transaction", mock_write)
-        assert caplog.records[0].msg.__class__ == InvalidPowerChange
+
+        args = Namespace(
+            action="new",
+            election_type="upsert-validator",
+            public_key="CJxdItf4lz2PwEf4SmYNAu/c/VpmX39JEgC5YpH7fxg=",
+            power=10,
+            node_id="fb7140f03a4ffad899fabbbf655b97e0321add66",
+            sk=priv_validator_path,
+            config={},
+        )
+
+        with caplog.at_level(logging.ERROR):
+            assert not run_election_new_upsert_validator(args, b, test_abci_rpc)
+            assert caplog.records[0].msg.__class__ == InvalidPowerChange
 
 
 @pytest.mark.abci
-def test_election_approve_with_tendermint(b, priv_validator_path, user_sk, validators, test_abci_rpc):
+def test_election_approve_with_tendermint(
+    b, priv_validator_path, user_sk, validators, test_abci_rpc
+):
     public_key = "CJxdItf4lz2PwEf4SmYNAu/c/VpmX39JEgC5YpH7fxg="
     new_args = Namespace(
         action="new",
@@ -537,36 +625,61 @@ def test_election_approve_with_tendermint(b, priv_validator_path, user_sk, valid
     election_id = run_election_new_upsert_validator(new_args, b, test_abci_rpc)
     assert election_id
 
-    args = Namespace(action="approve", election_id=election_id, sk=priv_validator_path, config={})
+    args = Namespace(
+        action="approve", election_id=election_id, sk=priv_validator_path, config={}
+    )
     approve = run_election_approve(args, b, test_abci_rpc)
 
     assert b.models.get_transaction(approve)
 
 
 @pytest.mark.bdb
-def test_election_approve_without_tendermint(monkeypatch, caplog, b, priv_validator_path, new_validator, node_key, test_abci_rpc):
+def test_election_approve_without_tendermint(
+    monkeypatch, caplog, b, priv_validator_path, new_validator, node_key, test_abci_rpc
+):
+    def mock_write(self, modelist, endpoint, mode_commit, transaction, mode):
+        b.models.store_bulk_transactions([transaction])
+        return (202, "")
+
     from planetmint.commands.planetmint import run_election_approve
     from argparse import Namespace
+    
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
 
-    b, election_id = call_election(monkeypatch, b, new_validator, node_key, test_abci_rpc)
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
+        m.setattr("planetmint.abci.rpc.ABCI_RPC.write_transaction", mock_write)
+        
+        b, election_id = call_election_internal(
+            b, new_validator, node_key
+        )
+        
+        # call run_election_approve with args that point to the election
+        args = Namespace(
+            action="approve", election_id=election_id, sk=priv_validator_path, config={}
+        )
 
-    # call run_election_approve with args that point to the election
+        # assert returned id is in the db
-    args = Namespace(action="approve", election_id=election_id, sk=priv_validator_path, config={})
+        with caplog.at_level(logging.INFO):
-
+            approval_id = run_election_approve(args, b, test_abci_rpc)
-    # assert returned id is in the db
+            assert caplog.records[0].msg == "[SUCCESS] Your vote has been submitted"
-    with caplog.at_level(logging.INFO):
+            assert b.models.get_transaction(approval_id)
-        approval_id = run_election_approve(args, b, test_abci_rpc)
+        m.undo()
-        assert caplog.records[0].msg == "[SUCCESS] Your vote has been submitted"
-        assert b.models.get_transaction(approval_id)
 
 
 
 from unittest import mock
+
+
 @pytest.mark.bdb
-def test_election_approve_failure(monkeypatch, caplog, b, priv_validator_path, new_validator, node_key, test_abci_rpc):
+def test_election_approve_failure(
+    monkeypatch, caplog, b, priv_validator_path, new_validator, node_key, test_abci_rpc
+):
     from argparse import Namespace
 
-    b, election_id = call_election(monkeypatch, b, new_validator, node_key, test_abci_rpc)
+    b, election_id = call_election(
+        monkeypatch, b, new_validator, node_key, test_abci_rpc
+    )
 
     def mock_write(modelist, endpoint, mode_commit, transaction, mode):
         b.models.store_bulk_transactions([transaction])
@@ -575,7 +688,9 @@ def test_election_approve_failure(monkeypatch, caplog, b, priv_validator_path, n
     test_abci_rpc.write_transaction = mock_write
 
     # call run_upsert_validator_approve with args that point to the election
-    args = Namespace(action="approve", election_id=election_id, sk=priv_validator_path, config={})
+    args = Namespace(
+        action="approve", election_id=election_id, sk=priv_validator_path, config={}
+    )
 
     with caplog.at_level(logging.ERROR):
         assert not run_election_approve(args, b, test_abci_rpc)
@@ -595,29 +710,32 @@ def test_bigchain_tendermint_version(capsys):
     assert sorted(output_config["tendermint"]) == sorted(__tm_supported_versions__)
 
 
+def call_election_internal(b, new_validator, node_key):
+    # our voters is a list of length 1, populated from our mocked validator
+    voters = b.get_recipients_list()
+    # and our voter is the public key from the voter list
+    voter = node_key.public_key
+    valid_election = ValidatorElection.generate(
+        [voter], voters, new_validator, None
+    ).sign([node_key.private_key])
+
+    # patch in an election with a vote issued to the user
+    election_id = valid_election.id
+    b.models.store_bulk_transactions([valid_election])
+
+    return b, election_id
+
 
 def call_election(monkeypatch, b, new_validator, node_key, abci_rpc):
-
     def mock_write(self, modelist, endpoint, mode_commit, transaction, mode):
         b.models.store_bulk_transactions([transaction])
         return (202, "")
+
     with monkeypatch.context() as m:
-        m.setattr("planetmint.model.dataaccessor.DataAccessor.get_validators", mock_get_validators)
+        from planetmint.model.dataaccessor import DataAccessor
+
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
         m.setattr("planetmint.abci.rpc.ABCI_RPC.write_transaction", mock_write)
-        
+        b, election_id = call_election_internal( b, new_validator, node_key )
-        # patch the validator set. We now have one validator with power 10
-        #b.models.get_validators = mock_get_validators
-        #abci_rpc.write_transaction = mock_write
-
-        # our voters is a list of length 1, populated from our mocked validator
-        voters = b.get_recipients_list()
-        # and our voter is the public key from the voter list
-        voter = node_key.public_key
-        valid_election = ValidatorElection.generate([voter], voters, new_validator, None).sign([node_key.private_key])
-
-        # patch in an election with a vote issued to the user
-        election_id = valid_election.id
-        b.models.store_bulk_transactions([valid_election])
-        
         m.undo()
         return b, election_id

tests/conftest.py

@@ -310,6 +310,36 @@ def b():
     validator.models.connection.connect()
     return validator
     
+@pytest.fixture
+def b_flushed(_setup_database):
+    from planetmint.application import Validator
+    from transactions.common.memoize import to_dict, from_dict
+    from transactions.common.transaction import Transaction
+    from .utils import flush_db
+    from planetmint.config import Config
+
+    old_validator_instance = Validator()
+    del old_validator_instance.models
+    del old_validator_instance
+    
+    
+
+    conn = Connection()
+    conn.close()
+    conn.connect()
+
+    dbname = Config().get()["database"]["name"]
+    flush_db(conn, dbname)
+
+    to_dict.cache_clear()
+    from_dict.cache_clear()
+    Transaction._input_valid.cache_clear()    
+
+    validator = Validator()
+    validator.models.connection.close()
+    validator.models.connection.connect()
+    return validator
+
 
 @pytest.fixture
 def eventqueue_fixture():
@@ -318,27 +348,6 @@ def eventqueue_fixture():
     return Queue()
 
 
-@pytest.fixture
-def b_mock(b, network_validators):
-    b.models.get_validators = mock_get_validators(network_validators)
-    return b
-
-
-def mock_get_validators(network_validators):
-    def validator_set(height):
-        validators = []
-        for public_key, power in network_validators.items():
-            validators.append(
-                {
-                    "public_key": {"type": "ed25519-base64", "value": public_key},
-                    "voting_power": power,
-                }
-            )
-        return validators
-
-    return validator_set
-
-
 @pytest.fixture
 def create_tx(alice, user_pk):
     from transactions.types.assets.create import Create
@@ -544,6 +553,7 @@ def utxo_collection(tarantool_client, _setup_database):
     return tarantool_client.get_space("utxos")
 
 
+@pytest.fixture
 def network_validators(node_keys):
     validator_pub_power = {}
     voting_power = [8, 10, 7, 9]
@@ -692,16 +702,8 @@ def new_validator():
 
 
 @pytest.fixture
-def valid_upsert_validator_election(b_mock, node_key, new_validator):
+def valid_upsert_validator_election(b, node_key, new_validator):
-    voters = b_mock.get_recipients_list()
+    voters = b.get_recipients_list()
-    return ValidatorElection.generate(
-        [node_key.public_key], voters, new_validator, None
-    ).sign([node_key.private_key])
-
-
-@pytest.fixture
-def valid_upsert_validator_election_2(b_mock, node_key, new_validator):
-    voters = b_mock.get_recipients_list()
     return ValidatorElection.generate(
         [node_key.public_key], voters, new_validator, None
     ).sign([node_key.private_key])
@@ -722,45 +724,6 @@ def ongoing_validator_election(b, valid_upsert_validator_election, ed25519_node_
     b.models.store_block(block_1._asdict())
     return valid_upsert_validator_election
 
-
-@pytest.fixture
-def ongoing_validator_election_2(
-    b, valid_upsert_validator_election_2, ed25519_node_keys
-):
-    validators = b.models.get_validators(height=1)
-    genesis_validators = {"validators": validators, "height": 0, "election_id": None}
-    query.store_validator_set(b.models.connection, genesis_validators)
-
-    b.models.store_bulk_transactions([valid_upsert_validator_election_2])
-    block_1 = Block(
-        app_hash="hash_2", height=1, transactions=[valid_upsert_validator_election_2.id]
-    )
-    b.models.store_block(block_1._asdict())
-    return valid_upsert_validator_election_2
-
-
-@pytest.fixture
-def validator_election_votes(b_mock, ongoing_validator_election, ed25519_node_keys):
-    voters = b_mock.get_recipients_list()
-    votes = generate_votes(ongoing_validator_election, voters, ed25519_node_keys)
-    return votes
-
-
-@pytest.fixture
-def validator_election_votes_2(b_mock, ongoing_validator_election_2, ed25519_node_keys):
-    voters = b_mock.get_recipients_list()
-    votes = generate_votes(ongoing_validator_election_2, voters, ed25519_node_keys)
-    return votes
-
-
-def generate_votes(election, voters, keys):
-    votes = []
-    for voter, _ in enumerate(voters):
-        v = gen_vote(election, voter, keys)
-        votes.append(v)
-    return votes
-
-
 @pytest.fixture
 def signed_2_0_create_tx():
     return {

tests/migrations/test_migration_election.py

@@ -1,9 +1,25 @@
+import pytest
 from transactions.types.elections.chain_migration_election import ChainMigrationElection
 
-
+@pytest.mark.bdb
-def test_valid_migration_election(b_mock, node_key):
+def test_valid_migration_election(monkeypatch, b, node_key, network_validators):
-    voters = b_mock.get_recipients_list()
+    def mock_get_validators(self, height):
-    election = ChainMigrationElection.generate([node_key.public_key], voters, [{"data": {}}], None).sign(
+        validators = []
-        [node_key.private_key]
+        for public_key, power in network_validators.items():
-    )
+            validators.append(
-    assert b_mock.validate_election(election)
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
+    
+        voters = b.get_recipients_list()
+        election = ChainMigrationElection.generate([node_key.public_key], voters, [{"data": {}}], None).sign(
+            [node_key.private_key]
+        )
+        assert b.validate_election(election)
+        m.undo()

tests/tendermint/test_core.py

@@ -45,7 +45,7 @@ def generate_init_chain_request(chain_id, vals=None):
     vals = vals if vals is not None else [generate_validator()]
     return types.RequestInitChain(validators=vals, chain_id=chain_id)
 
-
+@pytest.mark.bdb
 def test_init_chain_successfully_registers_chain(b):
     request = generate_init_chain_request("chain-XYZ")
     res = ApplicationLogic(validator=b).init_chain(request)

tests/upsert_validator/conftest.py

@@ -11,15 +11,15 @@ from transactions.types.elections.validator_election import ValidatorElection
 
 
 @pytest.fixture
-def valid_upsert_validator_election_b(b, node_key, new_validator):
+def valid_upsert_validator_election(b, node_key, new_validator):
     voters = b.get_recipients_list()
     return ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
 
 
 @pytest.fixture
 @patch("transactions.types.elections.election.uuid4", lambda: "mock_uuid4")
-def fixed_seed_election(b_mock, node_key, new_validator):
+def fixed_seed_election(b, node_key, new_validator):
-    voters = b_mock.get_recipients_list()
+    voters = b.get_recipients_list()
     return ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
 
 

tests/upsert_validator/test_upsert_validator_vote.py

@@ -23,195 +23,294 @@ pytestmark = [pytest.mark.execute]
 
 
 @pytest.mark.bdb
-def test_upsert_validator_valid_election_vote(b_mock, valid_upsert_validator_election, ed25519_node_keys):
+def test_upsert_validator_valid_election_vote(monkeypatch, b, network_validators,new_validator,node_key,ed25519_node_keys):
-    b_mock.models.store_bulk_transactions([valid_upsert_validator_election])
+    def mock_get_validators(self, height):
+        validators = []
+        for public_key, power in network_validators.items():
+            validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
+        voters = b.get_recipients_list()
+        valid_upsert_validator_election= ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
 
-    input0 = valid_upsert_validator_election.to_inputs()[0]
+        b.models.store_bulk_transactions([valid_upsert_validator_election])
-    votes = valid_upsert_validator_election.outputs[0].amount
-    public_key0 = input0.owners_before[0]
-    key0 = ed25519_node_keys[public_key0]
 
-    election_pub_key = election_id_to_public_key(valid_upsert_validator_election.id)
+        input0 = valid_upsert_validator_election.to_inputs()[0]
+        votes = valid_upsert_validator_election.outputs[0].amount
+        public_key0 = input0.owners_before[0]
+        key0 = ed25519_node_keys[public_key0]
 
-    vote = Vote.generate(
+        election_pub_key = election_id_to_public_key(valid_upsert_validator_election.id)
-        [input0], [([election_pub_key], votes)], election_ids=[valid_upsert_validator_election.id]
+
-    ).sign([key0.private_key])
+        vote = Vote.generate(
-    assert b_mock.validate_transaction(vote)
+            [input0], [([election_pub_key], votes)], election_ids=[valid_upsert_validator_election.id]
+        ).sign([key0.private_key])
+        assert b.validate_transaction(vote)
+        m.undo()
 
 
 @pytest.mark.bdb
-def test_upsert_validator_valid_non_election_vote(b_mock, valid_upsert_validator_election, ed25519_node_keys):
+def test_upsert_validator_valid_non_election_vote(monkeypatch, b, network_validators,node_key,new_validator, ed25519_node_keys):
-    b_mock.models.store_bulk_transactions([valid_upsert_validator_election])
+    def mock_get_validators(self, height):
+        validators = []
+        for public_key, power in network_validators.items():
+            validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
+        voters = b.get_recipients_list()
+        valid_upsert_validator_election= ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
 
-    input0 = valid_upsert_validator_election.to_inputs()[0]
+        b.models.store_bulk_transactions([valid_upsert_validator_election])
-    votes = valid_upsert_validator_election.outputs[0].amount
-    public_key0 = input0.owners_before[0]
-    key0 = ed25519_node_keys[public_key0]
 
-    election_pub_key = election_id_to_public_key(valid_upsert_validator_election.id)
+        input0 = valid_upsert_validator_election.to_inputs()[0]
+        votes = valid_upsert_validator_election.outputs[0].amount
+        public_key0 = input0.owners_before[0]
+        key0 = ed25519_node_keys[public_key0]
 
-    # Ensure that threshold conditions are now allowed
+        election_pub_key = election_id_to_public_key(valid_upsert_validator_election.id)
-    with pytest.raises(ValidationError):
+
-        Vote.generate(
+        # Ensure that threshold conditions are now allowed
-            [input0], [([election_pub_key, key0.public_key], votes)], election_ids=[valid_upsert_validator_election.id]
+        with pytest.raises(ValidationError):
+            Vote.generate(
+                [input0], [([election_pub_key, key0.public_key], votes)], election_ids=[valid_upsert_validator_election.id]
+            ).sign([key0.private_key])
+        m.undo()
+
+
+@pytest.mark.bdb
+def test_upsert_validator_delegate_election_vote(monkeypatch, b, network_validators, node_key, new_validator, ed25519_node_keys):
+    def mock_get_validators(self, height):
+        validators = []
+        for public_key, power in network_validators.items():
+            validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)    
+    
+        alice = generate_key_pair()
+        voters = b.get_recipients_list()
+        valid_upsert_validator_election= ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
+
+        b.models.store_bulk_transactions([valid_upsert_validator_election])
+
+        input0 = valid_upsert_validator_election.to_inputs()[0]
+        votes = valid_upsert_validator_election.outputs[0].amount
+        public_key0 = input0.owners_before[0]
+        key0 = ed25519_node_keys[public_key0]
+
+        delegate_vote = Vote.generate(
+            [input0],
+            [([alice.public_key], 3), ([key0.public_key], votes - 3)],
+            election_ids=[valid_upsert_validator_election.id],
         ).sign([key0.private_key])
 
+        assert b.validate_transaction(delegate_vote)
 
-@pytest.mark.bdb
+        b.models.store_bulk_transactions([delegate_vote])
-def test_upsert_validator_delegate_election_vote(b_mock, valid_upsert_validator_election, ed25519_node_keys):
+        election_pub_key = election_id_to_public_key(valid_upsert_validator_election.id)
-    alice = generate_key_pair()
 
-    b_mock.models.store_bulk_transactions([valid_upsert_validator_election])
+        alice_votes = delegate_vote.to_inputs()[0]
+        alice_casted_vote = Vote.generate(
+            [alice_votes], [([election_pub_key], 3)], election_ids=[valid_upsert_validator_election.id]
+        ).sign([alice.private_key])
+        assert b.validate_transaction(alice_casted_vote)
 
-    input0 = valid_upsert_validator_election.to_inputs()[0]
+        key0_votes = delegate_vote.to_inputs()[1]
-    votes = valid_upsert_validator_election.outputs[0].amount
+        key0_casted_vote = Vote.generate(
-    public_key0 = input0.owners_before[0]
+            [key0_votes], [([election_pub_key], votes - 3)], election_ids=[valid_upsert_validator_election.id]
-    key0 = ed25519_node_keys[public_key0]
+        ).sign([key0.private_key])
-
+        assert b.validate_transaction(key0_casted_vote)
-    delegate_vote = Vote.generate(
+        m.undo()
-        [input0],
-        [([alice.public_key], 3), ([key0.public_key], votes - 3)],
-        election_ids=[valid_upsert_validator_election.id],
-    ).sign([key0.private_key])
-
-    assert b_mock.validate_transaction(delegate_vote)
-
-    b_mock.models.store_bulk_transactions([delegate_vote])
-    election_pub_key = election_id_to_public_key(valid_upsert_validator_election.id)
-
-    alice_votes = delegate_vote.to_inputs()[0]
-    alice_casted_vote = Vote.generate(
-        [alice_votes], [([election_pub_key], 3)], election_ids=[valid_upsert_validator_election.id]
-    ).sign([alice.private_key])
-    assert b_mock.validate_transaction(alice_casted_vote)
-
-    key0_votes = delegate_vote.to_inputs()[1]
-    key0_casted_vote = Vote.generate(
-        [key0_votes], [([election_pub_key], votes - 3)], election_ids=[valid_upsert_validator_election.id]
-    ).sign([key0.private_key])
-    assert b_mock.validate_transaction(key0_casted_vote)
 
 
 @pytest.mark.bdb
-def test_upsert_validator_invalid_election_vote(b_mock, valid_upsert_validator_election, ed25519_node_keys):
+def test_upsert_validator_invalid_election_vote(monkeypatch, b, network_validators, node_key, new_validator, ed25519_node_keys):
-    b_mock.models.store_bulk_transactions([valid_upsert_validator_election])
+    def mock_get_validators(self, height):
+        validators = []
+        for public_key, power in network_validators.items():
+            validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)    
+        voters = b.get_recipients_list()
+        valid_upsert_validator_election= ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
 
-    input0 = valid_upsert_validator_election.to_inputs()[0]
+        b.models.store_bulk_transactions([valid_upsert_validator_election])
-    votes = valid_upsert_validator_election.outputs[0].amount
-    public_key0 = input0.owners_before[0]
-    key0 = ed25519_node_keys[public_key0]
 
-    election_pub_key = election_id_to_public_key(valid_upsert_validator_election.id)
+        input0 = valid_upsert_validator_election.to_inputs()[0]
+        votes = valid_upsert_validator_election.outputs[0].amount
+        public_key0 = input0.owners_before[0]
+        key0 = ed25519_node_keys[public_key0]
 
-    vote = Vote.generate(
+        election_pub_key = election_id_to_public_key(valid_upsert_validator_election.id)
-        [input0], [([election_pub_key], votes + 1)], election_ids=[valid_upsert_validator_election.id]
-    ).sign([key0.private_key])
 
-    with pytest.raises(AmountError):
+        vote = Vote.generate(
-        assert b_mock.validate_transaction(vote)
+            [input0], [([election_pub_key], votes + 1)], election_ids=[valid_upsert_validator_election.id]
+        ).sign([key0.private_key])
+
+        with pytest.raises(AmountError):
+            assert b.validate_transaction(vote)
 
 
 @pytest.mark.bdb
-def test_valid_election_votes_received(b_mock, valid_upsert_validator_election, ed25519_node_keys):
+def test_valid_election_votes_received(monkeypatch, b, network_validators, node_key, new_validator, ed25519_node_keys):
-    alice = generate_key_pair()
+    def mock_get_validators(self, height):
-    b_mock.models.store_bulk_transactions([valid_upsert_validator_election])
+        validators = []
-    assert b_mock.get_commited_votes(valid_upsert_validator_election) == 0
+        for public_key, power in network_validators.items():
+            validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)    
+        alice = generate_key_pair()
+        voters = b.get_recipients_list()
+        valid_upsert_validator_election= ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
 
-    input0 = valid_upsert_validator_election.to_inputs()[0]
+        b.models.store_bulk_transactions([valid_upsert_validator_election])
-    votes = valid_upsert_validator_election.outputs[0].amount
+        assert b.get_commited_votes(valid_upsert_validator_election) == 0
-    public_key0 = input0.owners_before[0]
-    key0 = ed25519_node_keys[public_key0]
 
-    # delegate some votes to alice
+        input0 = valid_upsert_validator_election.to_inputs()[0]
-    delegate_vote = Vote.generate(
+        votes = valid_upsert_validator_election.outputs[0].amount
-        [input0],
+        public_key0 = input0.owners_before[0]
-        [([alice.public_key], 4), ([key0.public_key], votes - 4)],
+        key0 = ed25519_node_keys[public_key0]
-        election_ids=[valid_upsert_validator_election.id],
-    ).sign([key0.private_key])
-    b_mock.models.store_bulk_transactions([delegate_vote])
-    assert b_mock.get_commited_votes(valid_upsert_validator_election) == 0
 
-    election_public_key = election_id_to_public_key(valid_upsert_validator_election.id)
+        # delegate some votes to alice
-    alice_votes = delegate_vote.to_inputs()[0]
+        delegate_vote = Vote.generate(
-    key0_votes = delegate_vote.to_inputs()[1]
+            [input0],
+            [([alice.public_key], 4), ([key0.public_key], votes - 4)],
+            election_ids=[valid_upsert_validator_election.id],
+        ).sign([key0.private_key])
+        b.models.store_bulk_transactions([delegate_vote])
+        assert b.get_commited_votes(valid_upsert_validator_election) == 0
 
-    alice_casted_vote = Vote.generate(
+        election_public_key = election_id_to_public_key(valid_upsert_validator_election.id)
-        [alice_votes],
+        alice_votes = delegate_vote.to_inputs()[0]
-        [([election_public_key], 2), ([alice.public_key], 2)],
+        key0_votes = delegate_vote.to_inputs()[1]
-        election_ids=[valid_upsert_validator_election.id],
-    ).sign([alice.private_key])
 
-    assert b_mock.validate_transaction(alice_casted_vote)
+        alice_casted_vote = Vote.generate(
-    b_mock.models.store_bulk_transactions([alice_casted_vote])
+            [alice_votes],
+            [([election_public_key], 2), ([alice.public_key], 2)],
+            election_ids=[valid_upsert_validator_election.id],
+        ).sign([alice.private_key])
 
-    # Check if the delegated vote is count as valid vote
+        assert b.validate_transaction(alice_casted_vote)
-    assert b_mock.get_commited_votes(valid_upsert_validator_election) == 2
+        b.models.store_bulk_transactions([alice_casted_vote])
 
-    key0_casted_vote = Vote.generate(
+        # Check if the delegated vote is count as valid vote
-        [key0_votes], [([election_public_key], votes - 4)], election_ids=[valid_upsert_validator_election.id]
+        assert b.get_commited_votes(valid_upsert_validator_election) == 2
-    ).sign([key0.private_key])
 
-    assert b_mock.validate_transaction(key0_casted_vote)
+        key0_casted_vote = Vote.generate(
-    b_mock.models.store_bulk_transactions([key0_casted_vote])
+            [key0_votes], [([election_public_key], votes - 4)], election_ids=[valid_upsert_validator_election.id]
-    assert b_mock.get_commited_votes(valid_upsert_validator_election) == votes - 2
+        ).sign([key0.private_key])
+
+        assert b.validate_transaction(key0_casted_vote)
+        b.models.store_bulk_transactions([key0_casted_vote])
+        assert b.get_commited_votes(valid_upsert_validator_election) == votes - 2
 
 
 @pytest.mark.bdb
-def test_valid_election_conclude(b_mock, valid_upsert_validator_election, ed25519_node_keys):
+def test_valid_election_conclude(monkeypatch, b, network_validators, node_key, new_validator, ed25519_node_keys):
-    # Node 0: cast vote
+    def mock_get_validators(self, height):
-    tx_vote0 = gen_vote(valid_upsert_validator_election, 0, ed25519_node_keys)
+        validators = []
+        for public_key, power in network_validators.items():
+            validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)    
+        voters = b.get_recipients_list()
+        valid_upsert_validator_election= ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
 
-    # check if the vote is valid even before the election doesn't exist
+        # Node 0: cast vote
-    with pytest.raises(ValidationError):
+        tx_vote0 = gen_vote(valid_upsert_validator_election, 0, ed25519_node_keys)
-        assert b_mock.validate_transaction(tx_vote0)
 
-    # store election
+        # check if the vote is valid even before the election doesn't exist
-    b_mock.models.store_bulk_transactions([valid_upsert_validator_election])
+        with pytest.raises(ValidationError):
-    # cannot conclude election as not votes exist
+            assert b.validate_transaction(tx_vote0)
-    assert not b_mock.has_election_concluded(valid_upsert_validator_election)
 
-    # validate vote
+        # store election
-    assert b_mock.validate_transaction(tx_vote0)
+        b.models.store_bulk_transactions([valid_upsert_validator_election])
-    assert not b_mock.has_election_concluded(valid_upsert_validator_election, [tx_vote0])
+        # cannot conclude election as not votes exist
+        assert not b.has_election_concluded(valid_upsert_validator_election)
 
-    b_mock.models.store_bulk_transactions([tx_vote0])
+        # validate vote
-    assert not b_mock.has_election_concluded(valid_upsert_validator_election)
+        assert b.validate_transaction(tx_vote0)
+        assert not b.has_election_concluded(valid_upsert_validator_election, [tx_vote0])
 
-    # Node 1: cast vote
+        b.models.store_bulk_transactions([tx_vote0])
-    tx_vote1 = gen_vote(valid_upsert_validator_election, 1, ed25519_node_keys)
+        assert not b.has_election_concluded(valid_upsert_validator_election)
 
-    # Node 2: cast vote
+        # Node 1: cast vote
-    tx_vote2 = gen_vote(valid_upsert_validator_election, 2, ed25519_node_keys)
+        tx_vote1 = gen_vote(valid_upsert_validator_election, 1, ed25519_node_keys)
 
-    # Node 3: cast vote
+        # Node 2: cast vote
-    tx_vote3 = gen_vote(valid_upsert_validator_election, 3, ed25519_node_keys)
+        tx_vote2 = gen_vote(valid_upsert_validator_election, 2, ed25519_node_keys)
 
-    assert b_mock.validate_transaction(tx_vote1)
+        # Node 3: cast vote
-    assert not b_mock.has_election_concluded(valid_upsert_validator_election, [tx_vote1])
+        tx_vote3 = gen_vote(valid_upsert_validator_election, 3, ed25519_node_keys)
 
-    # 2/3 is achieved in the same block so the election can be.has_concludedd
+        assert b.validate_transaction(tx_vote1)
-    assert b_mock.has_election_concluded(valid_upsert_validator_election, [tx_vote1, tx_vote2])
+        assert not b.has_election_concluded(valid_upsert_validator_election, [tx_vote1])
 
-    b_mock.models.store_bulk_transactions([tx_vote1])
+        # 2/3 is achieved in the same block so the election can be.has_concludedd
-    assert not b_mock.has_election_concluded(valid_upsert_validator_election)
+        assert b.has_election_concluded(valid_upsert_validator_election, [tx_vote1, tx_vote2])
 
-    assert b_mock.validate_transaction(tx_vote2)
+        b.models.store_bulk_transactions([tx_vote1])
-    assert b_mock.validate_transaction(tx_vote3)
+        assert not b.has_election_concluded(valid_upsert_validator_election)
 
-    # conclusion can be triggered my different votes in the same block
+        assert b.validate_transaction(tx_vote2)
-    assert b_mock.has_election_concluded(valid_upsert_validator_election, [tx_vote2])
+        assert b.validate_transaction(tx_vote3)
-    assert b_mock.has_election_concluded(valid_upsert_validator_election, [tx_vote2, tx_vote3])
 
-    b_mock.models.store_bulk_transactions([tx_vote2])
+        # conclusion can be triggered my different votes in the same block
+        assert b.has_election_concluded(valid_upsert_validator_election, [tx_vote2])
+        assert b.has_election_concluded(valid_upsert_validator_election, [tx_vote2, tx_vote3])
 
-    # Once the blockchain records >2/3 of the votes the election is assumed to be.has_concludedd
+        b.models.store_bulk_transactions([tx_vote2])
-    # so any invocation of `.has_concluded` for that election should return False
-    assert not b_mock.has_election_concluded(valid_upsert_validator_election)
 
-    # Vote is still valid but the election cannot be.has_concluded as it it assumed that it has
+        # Once the blockchain records >2/3 of the votes the election is assumed to be.has_concludedd
-    # been.has_concludedd before
+        # so any invocation of `.has_concluded` for that election should return False
-    assert b_mock.validate_transaction(tx_vote3)
+        assert not b.has_election_concluded(valid_upsert_validator_election)
-    assert not b_mock.has_election_concluded(valid_upsert_validator_election, [tx_vote3])
+
+        # Vote is still valid but the election cannot be.has_concluded as it it assumed that it has
+        # been.has_concludedd before
+        assert b.validate_transaction(tx_vote3)
+        assert not b.has_election_concluded(valid_upsert_validator_election, [tx_vote3])
 
 
 @pytest.mark.abci

tests/upsert_validator/test_validator_election.py

@@ -21,110 +21,268 @@ from transactions.common.exceptions import (
 pytestmark = pytest.mark.bdb
 
 
-def test_upsert_validator_valid_election(b_mock, new_validator, node_key):
+def test_upsert_validator_valid_election(monkeypatch, b, network_validators, new_validator, node_key):
-    voters = b_mock.get_recipients_list()
+    def mock_get_validators(self, height):
-    election = ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign(
+        validators = []
-        [node_key.private_key]
+        for public_key, power in network_validators.items():
-    )
+            validators.append(
-    assert b_mock.validate_election(election)
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
+        voters = b.get_recipients_list()
+        election = ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign(
+            [node_key.private_key]
+        )
+        assert b.validate_election(election)
+        m.undo()
 
 
-def test_upsert_validator_invalid_election_public_key(b_mock, new_validator, node_key):
+def test_upsert_validator_invalid_election_public_key(monkeypatch, b, network_validators, new_validator, node_key):
-    from transactions.common.exceptions import InvalidPublicKey
+    def mock_get_validators(self, height):
+        validators = []
+        for public_key, power in network_validators.items():
+            validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
+        from transactions.common.exceptions import InvalidPublicKey
 
-    for iv in ["ed25519-base32", "ed25519-base64"]:
+        for iv in ["ed25519-base32", "ed25519-base64"]:
-        new_validator[0]["data"]["public_key"]["type"] = iv
+            new_validator[0]["data"]["public_key"]["type"] = iv
-        voters = b_mock.get_recipients_list()
+            voters = b.get_recipients_list()
 
-        with pytest.raises(InvalidPublicKey):
+            with pytest.raises(InvalidPublicKey):
-            ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
+                ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
+        m.undo()
 
 
-def test_upsert_validator_invalid_power_election(b_mock, new_validator, node_key):
+def test_upsert_validator_invalid_power_election(monkeypatch, b, network_validators, new_validator, node_key):
-    voters = b_mock.get_recipients_list()
+    def mock_get_validators(self, height):
-    new_validator[0]["data"]["power"] = 30
+        validators = []
+        for public_key, power in network_validators.items():
+            validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
+        voters = b.get_recipients_list()
+        new_validator[0]["data"]["power"] = 30
 
-    election = ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign(
+        election = ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign(
-        [node_key.private_key]
+            [node_key.private_key]
-    )
+        )
-    with pytest.raises(InvalidPowerChange):
+        with pytest.raises(InvalidPowerChange):
-        b_mock.validate_election(election)
+            b.validate_election(election)
+        m.undo()
 
 
-def test_upsert_validator_invalid_proposed_election(b_mock, new_validator, node_key):
+def test_upsert_validator_invalid_proposed_election(monkeypatch, b, network_validators, new_validator, node_key):
     from transactions.common.crypto import generate_key_pair
+    def mock_get_validators(self, height):
+        validators = []
+        for public_key, power in network_validators.items():
+            validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
 
-    alice = generate_key_pair()
+        alice = generate_key_pair()
-    voters = b_mock.get_recipients_list()
+        voters = b.get_recipients_list()
-    election = ValidatorElection.generate([alice.public_key], voters, new_validator, None).sign([alice.private_key])
+        election = ValidatorElection.generate([alice.public_key], voters, new_validator, None).sign([alice.private_key])
-    with pytest.raises(InvalidProposer):
+        with pytest.raises(InvalidProposer):
-        b_mock.validate_election(election)
+            b.validate_election(election)
 
 
-def test_upsert_validator_invalid_inputs_election(b_mock, new_validator, node_key):
+def test_upsert_validator_invalid_inputs_election(monkeypatch, b, network_validators, new_validator, node_key):
     from transactions.common.crypto import generate_key_pair
-
+    def mock_get_validators(self, height):
-    alice = generate_key_pair()
+        validators = []
-    voters = b_mock.get_recipients_list()
+        for public_key, power in network_validators.items():
-    election = ValidatorElection.generate([node_key.public_key, alice.public_key], voters, new_validator, None).sign(
+            validators.append(
-        [node_key.private_key, alice.private_key]
+                {
-    )
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
-    with pytest.raises(MultipleInputsError):
+                    "voting_power": power,
-        b_mock.validate_election(election)
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
+        alice = generate_key_pair()
+        voters = b.get_recipients_list()
+        election = ValidatorElection.generate([node_key.public_key, alice.public_key], voters, new_validator, None).sign(
+            [node_key.private_key, alice.private_key]
+        )
+        with pytest.raises(MultipleInputsError):
+            b.validate_election(election)
+        m.undo()
 
 
 @patch("transactions.types.elections.election.uuid4", lambda: "mock_uuid4")
-def test_upsert_validator_invalid_election(b_mock, new_validator, node_key, fixed_seed_election):
+def test_upsert_validator_invalid_election(monkeypatch, b, network_validators, new_validator, node_key):
-    voters = b_mock.get_recipients_list()
+    def mock_get_validators(self, height):
-    duplicate_election = ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign(
+        validators = []
-        [node_key.private_key]
+        for public_key, power in network_validators.items():
-    )
+            validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)
+    
+    
+        voters = b.get_recipients_list()
+        duplicate_election = ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign(
+            [node_key.private_key]
+        )
+        voters = b.get_recipients_list()
+        fixed_seed_election=  ValidatorElection.generate([node_key.public_key], voters, new_validator, None).sign([node_key.private_key])
 
-    with pytest.raises(DuplicateTransaction):
+        with pytest.raises(DuplicateTransaction):
-        b_mock.validate_election(fixed_seed_election, [duplicate_election])
+            b.validate_election(fixed_seed_election, [duplicate_election])
 
-    b_mock.models.store_bulk_transactions([fixed_seed_election])
+        b.models.store_bulk_transactions([fixed_seed_election])
 
-    with pytest.raises(DuplicateTransaction):
+        with pytest.raises(DuplicateTransaction):
-        b_mock.validate_election(duplicate_election)
+            b.validate_election(duplicate_election)
 
-    # Try creating an election with incomplete voter set
+        # Try creating an election with incomplete voter set
-    invalid_election = ValidatorElection.generate([node_key.public_key], voters[1:], new_validator, None).sign(
+        invalid_election = ValidatorElection.generate([node_key.public_key], voters[1:], new_validator, None).sign(
-        [node_key.private_key]
+            [node_key.private_key]
-    )
+        )
 
-    with pytest.raises(UnequalValidatorSet):
+        with pytest.raises(UnequalValidatorSet):
-        b_mock.validate_election(invalid_election)
+            b.validate_election(invalid_election)
 
-    recipients = b_mock.get_recipients_list()
+        recipients = b.get_recipients_list()
-    altered_recipients = []
+        altered_recipients = []
-    for r in recipients:
+        for r in recipients:
-        ([r_public_key], voting_power) = r
+            ([r_public_key], voting_power) = r
-        altered_recipients.append(([r_public_key], voting_power - 1))
+            altered_recipients.append(([r_public_key], voting_power - 1))
 
-    # Create a transaction which doesn't enfore the network power
+        # Create a transaction which doesn't enfore the network power
-    tx_election = ValidatorElection.generate([node_key.public_key], altered_recipients, new_validator, None).sign(
+        tx_election = ValidatorElection.generate([node_key.public_key], altered_recipients, new_validator, None).sign(
-        [node_key.private_key]
+            [node_key.private_key]
-    )
+        )
 
-    with pytest.raises(UnequalValidatorSet):
+        with pytest.raises(UnequalValidatorSet):
-        b_mock.validate_election(tx_election)
+            b.validate_election(tx_election)
+        m.undo()
 
 
-def test_get_status_ongoing(b, ongoing_validator_election, new_validator):
+def test_get_status_ongoing(monkeypatch, b, network_validators, node_key, new_validator, ed25519_node_keys):
-    status = ValidatorElection.ONGOING
+    def mock_get_validators(self, height):
-    resp = b.get_election_status(ongoing_validator_election)
+        _validators = []
-    assert resp == status
+        for public_key, power in network_validators.items():
+            _validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return _validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        from planetmint.backend import schema, query
+        from planetmint.abci.block import Block
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)    
+
+        voters = b.get_recipients_list()
+        valid_upsert_validator_election= ValidatorElection.generate(
+            [node_key.public_key], voters, new_validator, None
+        ).sign([node_key.private_key])
+
+        validators = b.models.get_validators(height=1)
+        genesis_validators = {"validators": validators, "height": 0}
+        query.store_validator_set(b.models.connection, genesis_validators)
+        b.models.store_bulk_transactions([valid_upsert_validator_election])
+        query.store_election(
+            b.models.connection, valid_upsert_validator_election.id, 1, is_concluded=False
+        )
+        block_1 = Block(
+            app_hash="hash_1", height=1, transactions=[valid_upsert_validator_election.id]
+        )
+        b.models.store_block(block_1._asdict())
+        
+        
+        status = ValidatorElection.ONGOING
+        resp = b.get_election_status(valid_upsert_validator_election)
+        assert resp == status
+        m.undo()
 
 
-def test_get_status_concluded(b, concluded_election, new_validator):
+def test_get_status_concluded(monkeypatch, b, network_validators, node_key, new_validator, ed25519_node_keys):
-    status = ValidatorElection.CONCLUDED
+    def mock_get_validators(self, height):
-    resp = b.get_election_status(concluded_election)
+        _validators = []
-    assert resp == status
+        for public_key, power in network_validators.items():
+            _validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return _validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        from planetmint.backend import schema, query
+        from planetmint.abci.block import Block
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)    
+
+        voters = b.get_recipients_list()
+        valid_upsert_validator_election= ValidatorElection.generate(
+            [node_key.public_key], voters, new_validator, None
+        ).sign([node_key.private_key])
+
+        validators = b.models.get_validators(height=1)
+        genesis_validators = {"validators": validators, "height": 0}
+        query.store_validator_set(b.models.connection, genesis_validators)
+        b.models.store_bulk_transactions([valid_upsert_validator_election])
+        query.store_election(
+            b.models.connection, valid_upsert_validator_election.id, 1, is_concluded=False
+        )
+        block_1 = Block(
+            app_hash="hash_1", height=1, transactions=[valid_upsert_validator_election.id]
+        )
+        b.models.store_block(block_1._asdict())
+        query.store_election(b.models.connection, valid_upsert_validator_election.id, 2, is_concluded=True)
+        
+        status = ValidatorElection.CONCLUDED
+        resp = b.get_election_status(valid_upsert_validator_election)
+        assert resp == status
+        m.undo()
 
 
-def test_get_status_inconclusive(b, inconclusive_election, new_validator):
+def test_get_status_inconclusive(monkeypatch, b, network_validators, node_key, new_validator):
-    def set_block_height_to_3():
+
+
+    def set_block_height_to_3(self):
         return {"height": 3}
 
     def custom_mock_get_validators(height):
@@ -166,25 +324,99 @@ def test_get_status_inconclusive(b, inconclusive_election, new_validator):
                     "voting_power": 8,
                 },
             ]
+    def mock_get_validators(self, height):
+        _validators = []
+        for public_key, power in network_validators.items():
+            _validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return _validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        from planetmint.backend import schema, query
+        from planetmint.abci.block import Block
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)    
 
-    b.models.get_validators = custom_mock_get_validators
+        voters = b.get_recipients_list()
-    b.models.get_latest_block = set_block_height_to_3
+        valid_upsert_validator_election= ValidatorElection.generate(
-    status = ValidatorElection.INCONCLUSIVE
+            [node_key.public_key], voters, new_validator, None
-    resp = b.get_election_status(inconclusive_election)
+        ).sign([node_key.private_key])
-    assert resp == status
+
+        validators = b.models.get_validators(height=1)
+        genesis_validators = {"validators": validators, "height": 0}
+        query.store_validator_set(b.models.connection, genesis_validators)
+        b.models.store_bulk_transactions([valid_upsert_validator_election])
+        query.store_election(
+            b.models.connection, valid_upsert_validator_election.id, 1, is_concluded=False
+        )
+        block_1 = Block(
+            app_hash="hash_1", height=1, transactions=[valid_upsert_validator_election.id]
+        )
+        b.models.store_block(block_1._asdict())
 
 
-def test_upsert_validator_show(caplog, ongoing_validator_election, b):
+
+        validators = b.models.get_validators(height=1)
+        validators[0]["voting_power"] = 15
+        validator_update = {"validators": validators, "height": 2, "election_id": "some_other_election"}
+
+        query.store_validator_set(b.models.connection, validator_update)
+        m.undo()
+    with monkeypatch.context() as m2:
+        m2.setattr(DataAccessor, "get_validators", custom_mock_get_validators)
+        m2.setattr(DataAccessor, "get_latest_block", set_block_height_to_3)    
+        status = ValidatorElection.INCONCLUSIVE
+        resp = b.get_election_status(valid_upsert_validator_election)
+        assert resp == status
+        m2.undo()
+
+
+def test_upsert_validator_show(monkeypatch, caplog, b, node_key, new_validator, network_validators):
     from planetmint.commands.planetmint import run_election_show
+    def mock_get_validators(self, height):
+        _validators = []
+        for public_key, power in network_validators.items():
+            _validators.append(
+                {
+                    "public_key": {"type": "ed25519-base64", "value": public_key},
+                    "voting_power": power,
+                }
+            )
+        return _validators
+    with monkeypatch.context() as m:
+        from planetmint.model.dataaccessor import DataAccessor
+        from planetmint.backend import schema, query
+        from planetmint.abci.block import Block
+        m.setattr(DataAccessor, "get_validators", mock_get_validators)    
 
-    election_id = ongoing_validator_election.id
+        voters = b.get_recipients_list()
-    public_key = public_key_to_base64(ongoing_validator_election.assets[0]["data"]["public_key"]["value"])
+        valid_upsert_validator_election= ValidatorElection.generate(
-    power = ongoing_validator_election.assets[0]["data"]["power"]
+            [node_key.public_key], voters, new_validator, None
-    node_id = ongoing_validator_election.assets[0]["data"]["node_id"]
+        ).sign([node_key.private_key])
-    status = ValidatorElection.ONGOING
 
-    show_args = Namespace(action="show", election_id=election_id)
+        validators = b.models.get_validators(height=1)
+        genesis_validators = {"validators": validators, "height": 0}
+        query.store_validator_set(b.models.connection, genesis_validators)
+        b.models.store_bulk_transactions([valid_upsert_validator_election])
+        query.store_election(
+            b.models.connection, valid_upsert_validator_election.id, 1, is_concluded=False
+        )
+        block_1 = Block(
+            app_hash="hash_1", height=1, transactions=[valid_upsert_validator_election.id]
+        )
+        b.models.store_block(block_1._asdict())
+        election_id = valid_upsert_validator_election.id
+        public_key = public_key_to_base64(valid_upsert_validator_election.assets[0]["data"]["public_key"]["value"])
+        power = valid_upsert_validator_election.assets[0]["data"]["power"]
+        node_id = valid_upsert_validator_election.assets[0]["data"]["node_id"]
+        status = ValidatorElection.ONGOING
 
-    msg = run_election_show(show_args, b)
+        show_args = Namespace(action="show", election_id=election_id)
 
-    assert msg == f"public_key={public_key}\npower={power}\nnode_id={node_id}\nstatus={status}"
+        msg = run_election_show(show_args, b)
+
+        assert msg == f"public_key={public_key}\npower={power}\nnode_id={node_id}\nstatus={status}"
+        m.undo()