def __init__(self, executor, squash_handler, first_state_root):
self._executor = executor
# In a full implementation, there would be one scheduler
# for each chain the Journal wanted to process but only
# a single executor. We create a single scheduler for now
# and hook it to the executor.
self._scheduler = SerialScheduler(squash_handler, first_state_root)
self._executor.execute(self._scheduler)
self._squash_handler = squash_handler
def test_set_status(self):
"""Tests that set_status() has the correct behavior.
Basically:
1. Adds a batch which has two transactions.
2. Calls next_transaction() to get the first Transaction.
3. Calls next_transaction() to verify that it returns None.
4. Calls set_status() to mark the first transaction applied.
5. Calls next_transaction() to get the second Transaction.
Step 3 returns None because the first transaction hasn't been marked
as applied, and the SerialScheduler will only return one
not-applied Transaction at a time.
Step 5 is expected to return the second Transaction, not None,
since the first Transaction was marked as applied in the previous
step.
"""
private_key = bitcoin.random_key()
public_key = bitcoin.encode_pubkey(
bitcoin.privkey_to_pubkey(private_key), "hex")
context_manager = ContextManager(dict_database.DictDatabase())
squash_handler = context_manager.get_squash_handler()
first_state_root = context_manager.get_first_root()
scheduler = SerialScheduler(squash_handler, first_state_root)
txns = []
for name in ['a', 'b']:
txn = create_transaction(
name=name,
private_key=private_key,
public_key=public_key)
txns.append(txn)
batch = create_batch(
transactions=txns,
private_key=private_key,
public_key=public_key)
scheduler.add_batch(batch)
scheduled_txn_info = scheduler.next_transaction()
self.assertIsNotNone(scheduled_txn_info)
self.assertEquals('a', scheduled_txn_info.txn.payload.decode())
self.assertIsNone(scheduler.next_transaction())
scheduler.set_status(
scheduled_txn_info.txn.header_signature,
status=False,
context_id=None)
scheduled_txn_info = scheduler.next_transaction()
self.assertIsNotNone(scheduled_txn_info)
self.assertEquals('b', scheduled_txn_info.txn.payload.decode())
def test_transaction_order(self):
"""Tests the that transactions are returned in order added.
Adds three batches with varying number of transactions, then tests
that they are returned in the appropriate order when using an iterator.
This test also creates a second iterator and verifies that both
iterators return the same transactions.
This test also finalizes the scheduler and verifies that StopIteration
is thrown by the iterator.
"""
private_key = bitcoin.random_key()
public_key = bitcoin.encode_pubkey(
bitcoin.privkey_to_pubkey(private_key), "hex")
context_manager = ContextManager(dict_database.DictDatabase())
squash_handler = context_manager.get_squash_handler()
first_state_root = context_manager.get_first_root()
scheduler = SerialScheduler(squash_handler, first_state_root)
txns = []
for names in [['a', 'b', 'c'], ['d', 'e'], ['f', 'g', 'h', 'i']]:
batch_txns = []
for name in names:
txn = create_transaction(
name=name,
private_key=private_key,
public_key=public_key)
batch_txns.append(txn)
txns.append(txn)
batch = create_batch(
transactions=batch_txns,
private_key=private_key,
public_key=public_key)
scheduler.add_batch(batch)
scheduler.finalize()
iterable1 = iter(scheduler)
iterable2 = iter(scheduler)
for txn in txns:
scheduled_txn_info = next(iterable1)
self.assertEqual(scheduled_txn_info, next(iterable2))
self.assertIsNotNone(scheduled_txn_info)
self.assertEquals(txn.payload, scheduled_txn_info.txn.payload)
scheduler.set_status(txn.header_signature, False, None)
with self.assertRaises(StopIteration):
next(iterable1)
class FauxJournal(object):
def __init__(self, executor, squash_handler, first_state_root):
self._executor = executor
# In a full implementation, there would be one scheduler
# for each chain the Journal wanted to process but only
# a single executor. We create a single scheduler for now
# and hook it to the executor.
self._scheduler = SerialScheduler(squash_handler, first_state_root)
self._executor.execute(self._scheduler)
self._squash_handler = squash_handler
def get_on_batch_received_handler(self):
def _handler(batch):
return self.on_batch_received(batch)
return _handler
def on_batch_received(self, batch):
self._scheduler.add_batch(batch)
def create_scheduler(self, squash_handler, first_state_root):
return SerialScheduler(squash_handler, first_state_root)
def test_valid_batch_invalid_batch(self):
"""Tests the squash function. That the correct hash is being used
for each txn and that the batch ending state hash is being set.
Basically:
1. Adds two batches, one where all the txns are valid,
and one where one of the txns is invalid.
2. Run through the scheduler executor interaction
as txns are processed.
3. Verify that the valid state root is obtained
through the squash function.
4. Verify that correct batch statuses are set
"""
private_key = bitcoin.random_key()
public_key = bitcoin.encode_pubkey(
bitcoin.privkey_to_pubkey(private_key), "hex")
context_manager = ContextManager(dict_database.DictDatabase())
squash_handler = context_manager.get_squash_handler()
first_state_root = context_manager.get_first_root()
scheduler = SerialScheduler(squash_handler, first_state_root)
# 1)
batch_signatures = []
for names in [['a', 'b'], ['invalid', 'c']]:
batch_txns = []
for name in names:
txn = create_transaction(
name=name,
private_key=private_key,
public_key=public_key)
batch_txns.append(txn)
batch = create_batch(
transactions=batch_txns,
private_key=private_key,
public_key=public_key)
batch_signatures.append(batch.signature)
scheduler.add_batch(batch)
scheduler.finalize()
# 2)
sched1 = iter(scheduler)
invalid_payload = hashlib.sha512('invalid'.encode()).hexdigest()
while not scheduler.complete():
txn_info = next(sched1)
txn_header = transaction_pb2.TransactionHeader()
txn_header.ParseFromString(txn_info.txn.header)
inputs_or_outputs = list(txn_header.inputs)
c_id = context_manager.create_context(txn_info.state_hash,
inputs_or_outputs,
inputs_or_outputs)
if txn_header.payload_sha512 == invalid_payload:
scheduler.set_status(txn_info.txn.signature, False, c_id)
else:
context_manager.set(c_id, [{inputs_or_outputs[0]: 1}])
scheduler.set_status(txn_info.txn.signature,
True,
c_id)
sched2 = iter(scheduler)
# 3)
txn_info_a = next(sched2)
self.assertEquals(first_state_root, txn_info_a.state_hash)
txn_a_header = transaction_pb2.TransactionHeader()
txn_a_header.ParseFromString(txn_info_a.txn.header)
inputs_or_outputs = list(txn_a_header.inputs)
address_a = inputs_or_outputs[0]
c_id_a = context_manager.create_context(first_state_root,
inputs_or_outputs,
inputs_or_outputs)
context_manager.set(c_id_a, [{address_a: 1}])
state_root2 = context_manager.commit_context([c_id_a], virtual=False)
txn_info_b = next(sched2)
self.assertEquals(txn_info_b.state_hash, state_root2)
txn_b_header = transaction_pb2.TransactionHeader()
txn_b_header.ParseFromString(txn_info_b.txn.header)
inputs_or_outputs = list(txn_b_header.inputs)
address_b = inputs_or_outputs[0]
c_id_b = context_manager.create_context(state_root2,
inputs_or_outputs,
inputs_or_outputs)
context_manager.set(c_id_b, [{address_b: 1}])
state_root3 = context_manager.commit_context([c_id_b], virtual=False)
txn_infoInvalid = next(sched2)
self.assertEquals(txn_infoInvalid.state_hash, state_root3)
txn_info_c = next(sched2)
self.assertEquals(txn_info_c.state_hash, state_root3)
# 4)
batch1_status = scheduler.batch_status(batch_signatures[0])
self.assertTrue(batch1_status.valid)
self.assertEquals(batch1_status.state_hash, state_root3)
batch2_status = scheduler.batch_status(batch_signatures[1])
self.assertFalse(batch2_status.valid)
self.assertIsNone(batch2_status.state_hash)