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, 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 __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 __init__(self):
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
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,
batch_sender=self.block_sender,
squash_handler=None,
chain_head=self.genesis_block,
identity_signing_key=self.identity_signing_key)
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 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, 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 __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.gossip = MockNetwork()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
def setUp(self):
self.blocks = BlockTreeManager()
self.block_sender = MockBlockSender()
self.batch_sender = MockBatchSender()
self.state_view_factory = MockStateViewFactory({})