def test_init(self, sandbox: Sandbox):
"""Run a node and a baker.
The node runs in archive mode to get metadata in `client.get_block()`.
The protocol is activated in the past so the baker can submit blocks
immediately without waiting for current time."""
node_params = constants.NODE_PARAMS + ['--history-mode', 'archive']
for i in range(NUM_NODES):
sandbox.add_node(i, params=node_params)
# client setup
parameters = protocol.get_parameters()
parameters['round_durations'] = ROUND_DURATIONS
protocol.activate(sandbox.client(0), parameters=parameters)
# baker setup
# delegated_accounts = [f'bootstrap{i}' for i in range(1, 6)]
for i in range(NUM_NODES):
sandbox.add_baker(
i,
[f"bootstrap{i + 1}"],
proto=protocol.DAEMON,
log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS,
)
def test_setup_network(self, sandbox: Sandbox):
parameters = dict(protocol.PARAMETERS)
# each priority has a delay of 1 sec
parameters["time_between_blocks"] = ["1"]
sandbox.add_node(0, params=constants.NODE_PARAMS)
protocol.activate(sandbox.client(0), parameters)
sandbox.add_baker(0, ['bootstrap1'], proto=protocol.DAEMON)
def test_init(self, sandbox: Sandbox):
for i in range(10):
sandbox.add_node(i, params=constants.NODE_PARAMS)
utils.activate_alpha(sandbox.client(0))
for i in range(5):
sandbox.add_baker(i,
f'bootstrap{i + 1}',
proto=constants.ALPHA_DAEMON)
def test_init(self, sandbox: Sandbox):
sandbox.add_node(0, params=constants.NODE_PARAMS)
parameters = dict(protocol.PARAMETERS)
parameters["time_between_blocks"] = ["1", "0"]
protocol.activate(sandbox.client(0), parameters)
sandbox.add_baker(0, 'bootstrap1', proto=protocol.DAEMON)
sandbox.add_node(1, params=constants.NODE_PARAMS)
sandbox.add_baker(1, 'bootstrap2', proto=protocol.DAEMON)
def test_add_tmp_bootstrap_baker(self, sandbox: Sandbox):
""" Launch a temporary baker so that 10 and 11 keep broadcasting
heads to the future joining nodes and help them bootstrap """
# note we use 'bootstrap1' for all baking, this avoids the issue
# of a delegate becoming inactive. For instance, if we want
# to bake with 'bootstrap2' later in the test, it may have became
# inactive
sandbox.add_baker(10, 'bootstrap1', proto=PROTO_A_DAEMON)
def test_setup_network(self, sandbox: Sandbox):
sandbox.add_node(0, params=constants.NODE_PARAMS)
parameters = protocol.get_parameters()
parameters['round_durations'] = {
"round0": str(ROUND_DURATION),
"round1": str(ROUND_DURATION),
}
protocol.activate(sandbox.client(0), parameters=parameters)
sandbox.add_baker(0, ['bootstrap1'], proto=protocol.DAEMON)
def add_bakers(sandbox: Sandbox, nodes: Iterable[int]) -> None:
for node_id in nodes:
account = f'bootstrap{node_id + 1}'
sandbox.add_baker(
node_id,
[account],
proto=protocol.DAEMON,
log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS,
)
def test_network_gen_operations(self, sandbox: Sandbox, session):
dead_baker = NUM_NODES - 1
cur_time = datetime.now()
cycle = 1
while (datetime.now() - cur_time).total_seconds() < TEST_DURATION:
i = random.randrange(NUM_NODES)
client = sandbox.client(i)
try:
random_op(client)
except subprocess.CalledProcessError:
# some operations may be invalid, e.g. the client sends
# several operation with the same counter
print('# IGNORED INVALID OPERATION')
# test chain progresses every X cycles
if cycle % CHECK_PROGRESS == 0:
client = sandbox.client(0)
level_before = client.get_level()
current_time = datetime.now().strftime("%H:%M:%S")
print(current_time, "client level: ", level_before)
retry = MAX_RETRY
while client.get_level() == level_before and retry >= 1:
if retry != MAX_RETRY:
current_time = datetime.now().strftime("%H:%M:%S")
print(
current_time,
"level did not increase, retries: ",
retry,
)
time.sleep(TIMEOUT)
retry -= 1
msg = f"chain level didn't increase for {MAX_RETRY*TIMEOUT}s"
assert retry, msg
# cyclically kill bakers
if cycle % KILL_BAKER == 0:
baker = (dead_baker + 1) % NUM_NODES
current_time = datetime.now().strftime("%H:%M:%S")
print(current_time, "killing baker on node ", baker)
sandbox.rm_baker(baker, proto=protocol.DAEMON)
time.sleep(1)
# wake up the dead baker
current_time = datetime.now().strftime("%H:%M:%S")
print(current_time, "starting baker on node ", dead_baker)
sandbox.add_baker(
dead_baker,
[f'bootstrap{dead_baker+1}'],
proto=protocol.DAEMON,
log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS,
)
# set the next baker to die
dead_baker = baker
time.sleep(TIME_BETWEEN_CYCLE)
cycle += 1
session['dead_baker'] = dead_baker
def test_init(self, sandbox: Sandbox):
sandbox.add_node(0, params=params(), log_levels=LOG_LEVEL)
parameters = dict(protocol.PARAMETERS)
parameters["time_between_blocks"] = ["1", "0"]
protocol.activate(sandbox.client(0))
sandbox.add_baker(0, 'bootstrap1', proto=protocol.DAEMON)
sandbox.add_node(
1, params=params(), log_levels=LOG_LEVEL, config_client=False
)
def test_start_some_bakers(self, sandbox: Sandbox):
for i in range(NUM_EARLY_START_NODES):
account = f'bootstrap{i + 1}'
sandbox.add_baker(
i,
[account],
proto=protocol.DAEMON,
log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS,
)
def test_all_nodes_run_proto_b(self, sandbox: Sandbox):
# we let a PROTO_A baker bake the last blocks of PROTO_A
sandbox.add_baker(0, BAKER, proto=PROTO_A_DAEMON)
clients = sandbox.all_clients()
all_have_proto = False
while not all_have_proto:
all_have_proto = all(client.get_protocol() == PROTO_B
for client in clients)
time.sleep(POLLING_TIME)
def test_init(self, sandbox: Sandbox):
sandbox.add_node(0, params=params(), log_levels=LOG_LEVEL)
parameters = dict(constants.PARAMETERS)
parameters["time_between_blocks"] = ["1", "0"]
utils.activate_alpha(sandbox.client(0), parameters)
sandbox.add_baker(0, 'bootstrap1', proto=constants.ALPHA_DAEMON)
sandbox.add_node(1,
params=params(),
log_levels=LOG_LEVEL,
config_client=False)
def test_add_bakers_and_endorsers(self, sandbox: Sandbox):
for i in range(NUM_NODES):
sandbox.add_baker(i, [f'bootstrap{i+1}'], proto=protocol.DAEMON)
for i in range(NUM_NODES):
sandbox.add_endorser(
i,
account=f'bootstrap{i+1}',
endorsement_delay=0,
proto=protocol.DAEMON,
)
def test_setup_network(self, sandbox: Sandbox):
parameters = protocol.get_parameters()
# each priority has a delay of 1 sec
# parameters["time_between_blocks"] = ["1"]
for i in range(NUM_NODES):
sandbox.add_node(i, params=constants.NODE_PARAMS)
protocol.activate(sandbox.client(0), parameters=parameters)
time.sleep(3)
for i in range(NUM_NODES - 1):
sandbox.add_baker(i, [f'bootstrap{5 - i}'], protocol.DAEMON)
def test_start_remaining_bakers(self, sandbox: Sandbox):
for i in range(NUM_EARLY_START_NODES, NUM_NODES):
account = f'bootstrap{i + 1}'
sandbox.add_baker(
i,
[account],
proto=protocol.DAEMON,
log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS,
)
time.sleep(ROUND_DURATION)
def test_init(self, sandbox: Sandbox):
"""Run a node and a baker.
The node runs in archive mode to get metadata in `client.get_block()`.
The protocol is activated in the past so the baker can submit blocks
immediately without waiting for current time."""
node_params = constants.NODE_PARAMS + ['--history-mode', 'archive']
sandbox.add_node(0, params=node_params)
protocol.activate(sandbox.client(0), activate_in_the_past=True)
sandbox.add_baker(0, 'bootstrap1', proto=protocol.DAEMON)
def test_init(self, sandbox: Sandbox):
sandbox.add_node(0, params=constants.NODE_PARAMS)
parameters = dict(protocol.PARAMETERS)
# smaller threshold to make (almost sure) that 3/5 of the delegates
# have enough endorsing power
parameters['consensus_threshold'] = 5
parameters['round_durations'] = {"round0": '3', "round1": '3'}
protocol.activate(sandbox.client(0), parameters)
for i in range(1, NEW_NODES):
sandbox.add_node(i, params=constants.NODE_PARAMS)
for i in range(3):
sandbox.add_baker(i, [f'bootstrap{i + 1}'], proto=protocol.DAEMON)
def test_setup_network(self, sandbox: Sandbox):
sandbox.add_node(0, params=params(), log_levels=LOG_LEVEL)
protocol.activate(sandbox.client(0))
sandbox.add_node(1,
params=params(),
config_client=False,
log_levels=LOG_LEVEL)
sandbox.add_node(2,
params=params(2),
config_client=False,
log_levels=LOG_LEVEL)
sandbox.add_baker(0, 'bootstrap5', proto=protocol.DAEMON)
def test_setup_network(self, sandbox: Sandbox):
sandbox.add_node(0, params=params(), log_levels=LOG_LEVEL)
utils.activate_alpha(sandbox.client(0))
sandbox.add_node(1,
params=params(),
config_client=False,
log_levels=LOG_LEVEL)
sandbox.add_node(2,
params=params(2),
config_client=False,
log_levels=LOG_LEVEL)
sandbox.add_baker(0, 'bootstrap5', proto=constants.ALPHA_DAEMON)
def run_vote_file(sandbox: Sandbox, filename: str) -> None:
sandbox.rm_baker(0, proto=protocol.DAEMON)
sandbox.add_baker(
0,
[f'bootstrap{i}' for i in range(1, 6)],
proto=protocol.DAEMON,
run_params=["--votefile", filename],
)
if not sandbox.log_dir:
pytest.skip()
time.sleep(SLEEP)
assert sandbox.logs
def test_setup_network(self, sandbox: Sandbox):
parameters = dict(constants.PARAMETERS)
# each priority has a delay of 1 sec
parameters["time_between_blocks"] = ["1"]
for i in range(NUM_NODES):
sandbox.add_node(i, params=constants.NODE_PARAMS)
utils.activate_alpha(sandbox.client(0), parameters)
sandbox.add_baker(0, 'bootstrap5', proto=constants.ALPHA_DAEMON)
sandbox.add_baker(1, 'bootstrap4', proto=constants.ALPHA_DAEMON)
sandbox.add_endorser(0, account='bootstrap1', endorsement_delay=1,
proto=constants.ALPHA_DAEMON)
sandbox.add_endorser(1, account='bootstrap2', endorsement_delay=1,
proto=constants.ALPHA_DAEMON)
def test_init(self, sandbox: Sandbox):
for i in range(NUM_NODES):
sandbox.add_node(i, params=constants.NODE_PARAMS)
proto_params = dict(protocol.TENDERBAKE_PARAMETERS)
parameters = copy.deepcopy(proto_params)
parameters['round_durations'] = ROUND_DURATIONS
parameters['consensus_threshold'] = (
2 * (parameters['consensus_threshold'] // 3) + 1)
protocol.activate(sandbox.client(0), parameters=parameters)
for i in range(NUM_NODES):
sandbox.add_baker(
i,
[f'bootstrap{i + 1}'],
proto=protocol.DAEMON,
log_levels=constants.TENDERBAKE_BAKER_LOG_LEVELS,
)
def test_add_baker(self, sandbox: Sandbox):
sandbox.add_baker(0, 'bootstrap1', proto=PROTO_A_DAEMON)
def test_start_proto_b_baker(self, sandbox: Sandbox):
"""Proto_B will be elected, launch a new Proto_B baker"""
sandbox.add_baker(1, 'bootstrap1', proto=PROTO_B_DAEMON)
def test_start_baker_testchain(self, sandbox: Sandbox):
sandbox.add_baker(3, 'bootstrap1', proto=PROTO_B_DAEMON,
params=['--chain', 'test'])
def test_setup_network(self, sandbox: Sandbox):
sandbox.add_node(0, params=params(0), log_levels=LOG_LEVEL)
protocol.activate(sandbox.client(0))
time.sleep(3)
sandbox.add_baker(0, ['bootstrap5'], proto=protocol.DAEMON)
def test_setup_network(self, sandbox: Sandbox):
sandbox.add_node(0, params=params(), log_levels=LOG_LEVEL)
sandbox.add_baker(0, ['bootstrap5'], proto=protocol.DAEMON)
def add_fully_delegated_baker(sandbox: Sandbox, node: int, protocol: str):
"""Add a baker that has all known bootstrap accounts delegated to it."""
sandbox.add_baker(node, [], proto=protocol)
def test_add_bakers(self, sandbox: Sandbox):
for i in range(NUM_NODES):
sandbox.add_baker(i, [f'bootstrap{i+1}'], proto=protocol.DAEMON)
def test_init(self, sandbox: Sandbox):
for i in range(10):
sandbox.add_node(i, params=constants.NODE_PARAMS)
protocol.activate(sandbox.client(0))
for i in range(5):
sandbox.add_baker(i, f'bootstrap{i + 1}', proto=protocol.DAEMON)
