def setUp(self):
self.gossip = MockNetwork()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.state_delta_processor = MockStateDeltaProcessor()
self.permission_verifier = MockPermissionVerifier()
def __init__(self):
self.block_tree_manager = BlockTreeManager()
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.state_view_factory = MockStateViewFactory({})
self.permission_verifier = MockPermissionVerifier()
self.publisher = BlockPublisher(
transaction_executor=MockTransactionExecutor(),
block_cache=self.block_tree_manager.block_cache,
state_view_factory=self.state_view_factory,
settings_cache=SettingsCache(
SettingsViewFactory(
self.block_tree_manager.state_view_factory), ),
block_sender=self.block_sender,
batch_sender=self.batch_sender,
squash_handler=None,
chain_head=self.block_tree_manager.chain_head,
identity_signer=self.block_tree_manager.identity_signer,
data_dir=None,
config_dir=None,
check_publish_block_frequency=0.1,
batch_observers=[],
permission_verifier=self.permission_verifier)
self.init_chain_head = self.block_tree_manager.chain_head
self.result_block = None
# A list of batches is created at the beginning of each test.
# The test assertions and the publisher function wrappers
# take these batches as a default argument.
self.batch_count = 8
self.batches = self.make_batches()
def setUp(self):
self.block_tree_manager = BlockTreeManager(with_genesis=False)
self.gossip = MockNetwork()
self.executor = SynchronousExecutor()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.chain_id_manager = MockChainIdManager()
self.state_delta_processor = MockStateDeltaProcessor()
self.chain_head_lock = RLock()
def chain_updated(head, committed_batches=None,
uncommitted_batches=None):
pass
self.chain_ctrl = ChainController(
block_cache=self.block_tree_manager.block_cache,
state_view_factory=MockStateViewFactory(
self.block_tree_manager.state_db),
block_sender=self.block_sender,
executor=self.executor,
transaction_executor=MockTransactionExecutor(),
chain_head_lock=self.chain_head_lock,
on_chain_updated=chain_updated,
squash_handler=None,
chain_id_manager=self.chain_id_manager,
state_delta_processor=self.state_delta_processor,
identity_signing_key=self.block_tree_manager.identity_signing_key,
data_dir=None,
config_dir=None)
self.assertIsNone(self.chain_ctrl.chain_head)
def setUp(self, mock_batch_injector_factory):
mock_batch_injector_factory.create_injectors.return_value = []
self.block_tree_manager = BlockTreeManager()
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.state_view_factory = MockStateViewFactory({})
self.permission_verifier = MockPermissionVerifier()
self.publisher = BlockPublisher(
block_store=self.block_tree_manager.block_store,
block_manager=self.block_tree_manager.block_manager,
transaction_executor=MockTransactionExecutor(),
state_view_factory=self.state_view_factory,
block_sender=self.block_sender,
batch_sender=self.batch_sender,
identity_signer=self.block_tree_manager.identity_signer,
data_dir=None,
config_dir=None,
batch_observers=[],
permission_verifier=self.permission_verifier,
batch_injector_factory=mock_batch_injector_factory)
self.init_chain_head = self.block_tree_manager.chain_head
self.result_block = None
# A list of batches is created at the beginning of each test.
# The test assertions and the publisher function wrappers
# take these batches as a default argument.
self.batch_count = 8
self.batches = self.make_batches()
def __init__(self, with_genesis=True):
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.block_store = BlockStore(DictDatabase())
self.block_cache = BlockCache(self.block_store)
self.state_db = {}
# add the mock reference to the consensus
consensus_setting_addr = ConfigView.setting_address(
'sawtooth.consensus.algorithm')
self.state_db[consensus_setting_addr] = _setting_entry(
'sawtooth.consensus.algorithm', 'test_journal.mock_consensus')
self.state_view_factory = MockStateViewFactory(self.state_db)
self.signing_key = signing.generate_privkey()
self.public_key = signing.generate_pubkey(self.signing_key)
self.identity_signing_key = signing.generate_privkey()
chain_head = None
if with_genesis:
self.genesis_block = self.generate_genesis_block()
self.set_chain_head(self.genesis_block)
chain_head = self.genesis_block
self.block_publisher = BlockPublisher(
transaction_executor=MockTransactionExecutor(),
block_cache=self.block_cache,
state_view_factory=self.state_view_factory,
block_sender=self.block_sender,
batch_sender=self.block_sender,
squash_handler=None,
chain_head=chain_head,
identity_signing_key=self.identity_signing_key,
data_dir=None,
config_dir=None)
def setUp(self):
self.block_tree_manager = BlockTreeManager()
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.state_view_factory = MockStateViewFactory({})
self.publisher = BlockPublisher(
transaction_executor=MockTransactionExecutor(),
block_cache=self.block_tree_manager.block_cache,
state_view_factory=self.state_view_factory,
block_sender=self.block_sender,
batch_sender=self.batch_sender,
squash_handler=None,
chain_head=self.block_tree_manager.chain_head,
identity_signing_key=self.block_tree_manager.identity_signing_key,
data_dir=None,
config_dir=None)
self.init_chain_head = self.block_tree_manager.chain_head
self.result_block = None
# A list of batches is created at the beginning of each test.
# The test assertions and the publisher function wrappers
# take these batches as a default argument.
self.batch_count = 8
self.batches = self.make_batches()
def __init__(self):
self.block_sender = MockBlockSender()
self.block_store = BlockStore(DictDatabase())
self.block_cache = BlockCache(self.block_store)
self.state_db = {}
# add the mock reference to the consensus
self.state_db[_setting_address('sawtooth.consensus.algorithm')] = \
_setting_entry('sawtooth.consensus.algorithm',
'test_journal.mock_consensus')
self.state_view_factory = MockStateViewFactory(self.state_db)
self.signing_key = signing.generate_privkey()
self.public_key = signing.encode_pubkey(
signing.generate_pubkey(self.signing_key), "hex")
self.identity_signing_key = signing.generate_privkey()
self.genesis_block = self._generate_genesis_block()
self.set_chain_head(self.genesis_block)
self.block_publisher = BlockPublisher(
transaction_executor=MockTransactionExecutor(),
block_cache=self.block_cache,
state_view_factory=self.state_view_factory,
block_sender=self.block_sender,
squash_handler=None,
chain_head=self.genesis_block,
identity_signing_key=self.identity_signing_key)
def setUp(self):
self.block_tree_manager = BlockTreeManager()
self.gossip = MockNetwork()
self.executor = SynchronousExecutor()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.chain_id_manager = MockChainIdManager()
def chain_updated(head,
committed_batches=None,
uncommitted_batches=None):
pass
self.chain_ctrl = ChainController(
block_cache=self.block_tree_manager.block_cache,
state_view_factory=MockStateViewFactory(
self.block_tree_manager.state_db),
block_sender=self.block_sender,
executor=self.executor,
transaction_executor=MockTransactionExecutor(),
on_chain_updated=chain_updated,
squash_handler=None,
chain_id_manager=self.chain_id_manager,
identity_signing_key=self.block_tree_manager.identity_signing_key,
data_dir=None)
init_root = self.chain_ctrl.chain_head
self.assert_is_chain_head(init_root)
# create a chain of length 5 extending the root
_, head = self.generate_chain(init_root, 5)
self.receive_and_process_blocks(head)
self.assert_is_chain_head(head)
self.init_head = head
def __init__(self):
self.block_store = {}
self.block_sender = MockBlockSender()
self.block_publisher = BlockPublisher(
consensus=TestModePublisher(),
transaction_executor=MockTransactionExecutor(),
block_sender=self.block_sender,
squash_handler=None,
chain_head=self._generate_genesis_block())
block = self.generate_block(add_to_store=True,
status=BlockStatus.Valid)
self.set_chain_head(block)
def __init__(self):
self.block_tree_manager = BlockTreeManager()
self.gossip = MockNetwork()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.chain_id_manager = MockChainIdManager()
self._chain_head_lock = RLock()
self.permission_verifier = MockPermissionVerifier()
self.state_view_factory = MockStateViewFactory(
self.block_tree_manager.state_db)
self.transaction_executor = MockTransactionExecutor(
batch_execution_result=None)
self.executor = SynchronousExecutor()
self.block_validator = BlockValidator(
state_view_factory=self.state_view_factory,
block_cache=self.block_tree_manager.block_cache,
transaction_executor=self.transaction_executor,
squash_handler=None,
identity_signer=self.block_tree_manager.identity_signer,
data_dir=None,
config_dir=None,
permission_verifier=self.permission_verifier,
thread_pool=self.executor)
def chain_updated(head,
committed_batches=None,
uncommitted_batches=None):
pass
self.chain_ctrl = ChainController(
block_cache=self.block_tree_manager.block_cache,
block_validator=self.block_validator,
state_view_factory=self.state_view_factory,
chain_head_lock=self._chain_head_lock,
on_chain_updated=chain_updated,
chain_id_manager=self.chain_id_manager,
data_dir=None,
config_dir=None,
chain_observers=[])
init_root = self.chain_ctrl.chain_head
self.assert_is_chain_head(init_root)
# create a chain of length 5 extending the root
_, head = self.generate_chain(init_root, 5)
self.receive_and_process_blocks(head)
self.assert_is_chain_head(head)
self.init_head = head
def __init__(self, with_genesis=True):
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.block_store = BlockStore(
DictDatabase(indexes=BlockStore.create_index_configuration()))
self.block_cache = BlockCache(self.block_store)
self.state_db = {}
self.block_manager = BlockManager()
self.block_manager.add_store("commit_store", self.block_store)
# add the mock reference to the consensus
consensus_setting_addr = SettingsView.setting_address(
'sawtooth.consensus.algorithm')
self.state_db[consensus_setting_addr] = _setting_entry(
'sawtooth.consensus.algorithm', 'test_journal.mock_consensus')
self.state_view_factory = MockStateViewFactory(self.state_db)
context = create_context('secp256k1')
private_key = context.new_random_private_key()
crypto_factory = CryptoFactory(context)
self.signer = crypto_factory.new_signer(private_key)
identity_private_key = context.new_random_private_key()
self.identity_signer = crypto_factory.new_signer(identity_private_key)
chain_head = None
if with_genesis:
self.genesis_block = self.generate_genesis_block()
chain_head = self.genesis_block
self.block_manager.put([chain_head.block])
self.block_manager.persist(chain_head.block.header_signature,
"commit_store")
self.block_publisher = BlockPublisher(
block_manager=self.block_manager,
transaction_executor=MockTransactionExecutor(),
transaction_committed=self.block_store.has_transaction,
batch_committed=self.block_store.has_batch,
state_view_factory=self.state_view_factory,
settings_cache=SettingsCache(
SettingsViewFactory(self.state_view_factory), ),
block_sender=self.block_sender,
batch_sender=self.block_sender,
chain_head=chain_head.block,
identity_signer=self.identity_signer,
data_dir=None,
config_dir=None,
permission_verifier=MockPermissionVerifier(),
batch_observers=[])
def __init__(self, with_genesis=True):
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.dir = tempfile.mkdtemp()
self.block_db = NativeLmdbDatabase(
os.path.join(self.dir, 'block.lmdb'),
BlockStore.create_index_configuration())
self.block_store = BlockStore(self.block_db)
self.block_cache = BlockCache(self.block_store)
self.state_db = NativeLmdbDatabase(
os.path.join(self.dir, "merkle.lmdb"),
MerkleDatabase.create_index_configuration())
self.state_view_factory = NativeStateViewFactory(self.state_db)
self.block_manager = BlockManager()
self.block_manager.add_commit_store(self.block_store)
context = create_context('secp256k1')
private_key = context.new_random_private_key()
crypto_factory = CryptoFactory(context)
self.signer = crypto_factory.new_signer(private_key)
identity_private_key = context.new_random_private_key()
self.identity_signer = crypto_factory.new_signer(identity_private_key)
chain_head = None
if with_genesis:
self.genesis_block = self.generate_genesis_block()
chain_head = self.genesis_block
self.block_manager.put([chain_head.block])
self.block_manager.persist(chain_head.block.header_signature,
"commit_store")
self.block_publisher = BlockPublisher(
block_manager=self.block_manager,
transaction_executor=MockTransactionExecutor(),
transaction_committed=self.block_store.has_transaction,
batch_committed=self.block_store.has_batch,
state_view_factory=self.state_view_factory,
block_sender=self.block_sender,
batch_sender=self.block_sender,
chain_head=chain_head.block,
identity_signer=self.identity_signer,
data_dir=None,
config_dir=None,
permission_verifier=MockPermissionVerifier(),
batch_observers=[])
def __init__(self, with_genesis=True):
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.block_store = BlockStore(DictDatabase(
indexes=BlockStore.create_index_configuration()))
self.block_cache = BlockCache(self.block_store)
self.state_db = {}
# add the mock reference to the consensus
consensus_setting_addr = SettingsView.setting_address(
'sawtooth.consensus.algorithm')
self.state_db[consensus_setting_addr] = _setting_entry(
'sawtooth.consensus.algorithm', 'test_journal.mock_consensus')
self.state_view_factory = MockStateViewFactory(self.state_db)
context = create_context('secp256k1')
private_key = context.new_random_private_key()
crypto_factory = CryptoFactory(context)
self.signer = crypto_factory.new_signer(private_key)
identity_private_key = context.new_random_private_key()
self.identity_signer = crypto_factory.new_signer(identity_private_key)
chain_head = None
if with_genesis:
self.genesis_block = self.generate_genesis_block()
self.set_chain_head(self.genesis_block)
chain_head = self.genesis_block
self.block_publisher = BlockPublisher(
transaction_executor=MockTransactionExecutor(),
block_cache=self.block_cache,
state_view_factory=self.state_view_factory,
settings_cache=SettingsCache(
SettingsViewFactory(self.state_view_factory),
),
block_sender=self.block_sender,
batch_sender=self.block_sender,
squash_handler=None,
chain_head=chain_head,
identity_signer=self.identity_signer,
data_dir=None,
config_dir=None,
permission_verifier=MockPermissionVerifier(),
check_publish_block_frequency=0.1,
batch_observers=[])
def setUp(self):
self.blocks = BlockTreeManager()
self.gossip = MockNetwork()
self.executor = SynchronousExecutor()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
def chain_updated(head):
pass
self.chain_ctrl = ChainController(
consensus=TestModeVerifier(),
block_store=self.blocks.block_store,
block_sender=self.block_sender,
executor=self.executor,
transaction_executor=MockTransactionExecutor(),
on_chain_updated=chain_updated,
squash_handler=None)
def __init__(self):
self.block_sender = MockBlockSender()
self.block_store = BlockStoreAdapter({})
self.block_cache = BlockCache(self.block_store)
self.signing_key = signing.generate_privkey()
self.public_key = signing.encode_pubkey(
signing.generate_pubkey(self.signing_key), "hex")
self.genesis_block = self._generate_genesis_block()
self.block_store[self.genesis_block.identifier] = self.genesis_block
self.set_chain_head(self.genesis_block)
self.block_publisher = BlockPublisher(
consensus=TestModePublisher(),
transaction_executor=MockTransactionExecutor(),
block_sender=self.block_sender,
squash_handler=None,
chain_head=self.genesis_block)
def __init__(self):
self.block_tree_manager = BlockTreeManager(with_genesis=False)
self.gossip = MockNetwork()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.chain_id_manager = MockChainIdManager()
self.chain_head_lock = RLock()
self.permission_verifier = MockPermissionVerifier()
self.state_view_factory = MockStateViewFactory(
self.block_tree_manager.state_db)
self.transaction_executor = MockTransactionExecutor(
batch_execution_result=None)
self.executor = SynchronousExecutor()
self.block_validator = BlockValidator(
state_view_factory=self.state_view_factory,
block_cache=self.block_tree_manager.block_cache,
transaction_executor=self.transaction_executor,
squash_handler=None,
identity_signer=self.block_tree_manager.identity_signer,
data_dir=None,
config_dir=None,
permission_verifier=self.permission_verifier,
thread_pool=self.executor)
def chain_updated(head,
committed_batches=None,
uncommitted_batches=None):
pass
self.chain_ctrl = ChainController(
block_cache=self.block_tree_manager.block_cache,
block_validator=self.block_validator,
state_view_factory=self.state_view_factory,
chain_head_lock=self.chain_head_lock,
on_chain_updated=chain_updated,
chain_id_manager=self.chain_id_manager,
data_dir=None,
config_dir=None,
chain_observers=[])
self.assertIsNone(self.chain_ctrl.chain_head)
def setUp(self):
self.blocks = BlockTreeManager()
self.gossip = MockNetwork()
self.executor = SynchronousExecutor()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.state_view_factory = MockStateViewFactory()
def chain_updated(head, committed_batches=None,
uncommitted_batches=None):
pass
self.chain_ctrl = ChainController(
consensus_module=mock_consensus,
block_cache=self.blocks.block_cache,
state_view_factory=self.state_view_factory,
block_sender=self.block_sender,
executor=self.executor,
transaction_executor=MockTransactionExecutor(),
on_chain_updated=chain_updated,
squash_handler=None)
def setUp(self):
self.blocks = BlockTreeManager()
self.block_sender = MockBlockSender()
def __init__(self):
self.gossip = MockNetwork()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.permission_verifier = MockPermissionVerifier()
def setUp(self):
self.blocks = BlockTreeManager()
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.state_view_factory = MockStateViewFactory({})
def setUp(self):
self.gossip = MockNetwork()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()