def test_journal_transaction_block_update_block_weight(self):
# Test block update weight
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block = TransactionBlock(minfo)
trans_block.Status = tbStatus.valid
(gossip, journal) = self._create_journal()
node = gossip.LocalNode
trans_block.sign_from_node(gossip.LocalNode)
trans_block.update_block_weight(journal)
# No transactions
self.assertEquals(trans_block.TransactionDepth, 0)
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
transaction.sign_from_node(node)
trans_block.TransactionIDs += [transaction.Identifier]
trans_block.update_block_weight(journal)
# One transaction
self.assertEquals(trans_block.TransactionDepth, 1)
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 1,
'PreviousBlockID': trans_block.Identifier}
new_trans_block = TransactionBlock(minfo)
new_trans_block.Status = tbStatus.valid
journal.block_store[trans_block.Identifier] = trans_block
new_trans_block.update_block_weight(journal)
# Get depth from previous block
self.assertEquals(new_trans_block.TransactionDepth, 1)
def test_journal_transaction_block_update_block_weight(self):
# Test block update weight
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
transBlock = TransactionBlock(minfo)
transBlock.Status = tbStatus.valid
signingkey = SigObj.generate_signing_key()
ident = SigObj.generate_identifier(signingkey)
node = Node(identifier=ident, signingkey=signingkey,
address=("localhost", 10003))
# Takes a journal, create a temporary directory to use with the journal
path = tempfile.mkdtemp()
journal = Journal(node, DataDirectory=path)
transBlock.sign_from_node(node)
transBlock.update_block_weight(journal)
# No transactions
self.assertEquals(transBlock.TransactionDepth, 0)
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
transaction.sign_from_node(node)
transBlock.TransactionIDs += [transaction.Identifier]
transBlock.update_block_weight(journal)
# One transaction
self.assertEquals(transBlock.TransactionDepth, 1)
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 1,
'PreviousBlockID': transBlock.Identifier}
newTransBlock = TransactionBlock(minfo)
newTransBlock.Status = tbStatus.valid
journal.BlockStore[transBlock.Identifier] = transBlock
newTransBlock.update_block_weight(journal)
# Get depth from previous block
self.assertEquals(newTransBlock.TransactionDepth, 1)
def test_journal_transaction_block_update_block_weight(self):
# Test block update weight
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block = TransactionBlock(minfo)
trans_block.Status = tbStatus.valid
(gossip, journal) = self._create_journal()
node = gossip.LocalNode
trans_block.sign_from_node(gossip.LocalNode)
trans_block.update_block_weight(journal)
# No transactions
self.assertEquals(trans_block.TransactionDepth, 0)
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
transaction.sign_from_node(node)
trans_block.TransactionIDs += [transaction.Identifier]
trans_block.update_block_weight(journal)
# One transaction
self.assertEquals(trans_block.TransactionDepth, 1)
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 1,
'PreviousBlockID': trans_block.Identifier}
new_trans_block = TransactionBlock(minfo)
new_trans_block.Status = tbStatus.valid
journal.block_store[trans_block.Identifier] = trans_block
new_trans_block.update_block_weight(journal)
# Get depth from previous block
self.assertEquals(new_trans_block.TransactionDepth, 1)
def test_journal_transaction_block_cmp_unsigned(self):
# Test AssertionError is raised if TransactionBlock are not signed
# Need a signature to use Identifier
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
transBlock1 = TransactionBlock(minfo)
transBlock2 = TransactionBlock(minfo)
transBlock1.Status = tbStatus.valid
transBlock2.Status = tbStatus.valid
try:
cmp(transBlock2, transBlock1)
self.fail("This should cause an AssertionError")
except AssertionError, e2:
self.assertIsInstance(e2, AssertionError)
def test_journal_transaction_block_cmp_unsigned(self):
# Test AssertionError is raised if TransactionBlock are not signed
# Need a signature to use Identifier
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block1 = TransactionBlock(minfo)
trans_block2 = TransactionBlock(minfo)
trans_block1.Status = tbStatus.valid
trans_block2.Status = tbStatus.valid
try:
cmp(trans_block2, trans_block1)
self.fail("This should cause an AssertionError")
except AssertionError, e2:
self.assertIsInstance(e2, AssertionError)
def _create_tblock(self, node, blocknum, prevB, transId):
minfo = {'__SIGNATURE__': 'Test', "BlockNum": blocknum,
"PreviousBlockID": prevB, "TransactionIDs": transId}
transBlock = TransactionBlock(minfo)
transBlock.sign_from_node(node)
transBlock.Status = Status.valid
return transBlock
def _create_tblock(self, node, blocknum, prev_block, trans_id):
minfo = {'__SIGNATURE__': 'Test', "BlockNum": blocknum,
"PreviousBlockID": prev_block, "TransactionIDs": trans_id}
trans_block = TransactionBlock(minfo)
trans_block.sign_from_node(node)
trans_block.Status = Status.valid
return trans_block
def test_journal_transaction_block_cmp_valid_blocks(self):
# Test the overridden cmp function
# Needs the Blocks to be signed and valid
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block1 = TransactionBlock(minfo)
trans_block2 = TransactionBlock(minfo)
node = self._create_node()
# Need to sign TransactionBlock, use sign_from_node form signed object
trans_block1.sign_from_node(node)
trans_block2.sign_from_node(node)
trans_block1.Status = tbStatus.valid
trans_block2.Status = tbStatus.valid
# Test Equal Transaction Blocks
self.assertEquals(cmp(trans_block2, trans_block1), 0)
# Test a Transaction Block with greater Transaction Depth
trans_block2.TransactionDepth = 10
self.assertEquals(cmp(trans_block2, trans_block1), 1)
# Test a Transaction Block with lesser Transaction Depth
trans_block1.TransactionDepth = 20
self.assertEquals(cmp(trans_block2, trans_block1), -1)
def test_journal_transaction_block_cmp_valid_blocks(self):
# Test the overridden cmp function
# Needs the Blocks to be signed and valid
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block1 = TransactionBlock(minfo)
trans_block2 = TransactionBlock(minfo)
node = self._create_node()
# Need to sign TransactionBlock, use sign_from_node form signed object
trans_block1.sign_from_node(node)
trans_block2.sign_from_node(node)
trans_block1.Status = tbStatus.valid
trans_block2.Status = tbStatus.valid
# Test Equal Transaction Blocks
self.assertEquals(cmp(trans_block2, trans_block1), 0)
# Test a Transaction Block with greater Transaction Depth
trans_block2.TransactionDepth = 10
self.assertEquals(cmp(trans_block2, trans_block1), 1)
# Test a Transaction Block with lesser Transaction Depth
trans_block1.TransactionDepth = 20
self.assertEquals(cmp(trans_block2, trans_block1), -1)
def test_journal_transaction_block_update_block_weight(self):
# Test block update weight
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
transBlock = TransactionBlock(minfo)
transBlock.Status = tbStatus.valid
signingkey = SigObj.generate_signing_key()
ident = SigObj.generate_identifier(signingkey)
node = Node(identifier=ident,
signingkey=signingkey,
address=("localhost", 10003))
# Takes a journal, create a temporary directory to use with the journal
path = tempfile.mkdtemp()
journal = Journal(node, DataDirectory=path)
transBlock.sign_from_node(node)
transBlock.update_block_weight(journal)
# No transactions
self.assertEquals(transBlock.TransactionDepth, 0)
minfo = {
'__SIGNATURE__': 'Test',
'__NONCE__': time.time(),
'Dependencies': []
}
transaction = Transaction(minfo)
transaction.sign_from_node(node)
transBlock.TransactionIDs += [transaction.Identifier]
transBlock.update_block_weight(journal)
# One transaction
self.assertEquals(transBlock.TransactionDepth, 1)
minfo = {
'__SIGNATURE__': 'Test',
"BlockNum": 1,
'PreviousBlockID': transBlock.Identifier
}
newTransBlock = TransactionBlock(minfo)
newTransBlock.Status = tbStatus.valid
journal.BlockStore[transBlock.Identifier] = transBlock
newTransBlock.update_block_weight(journal)
# Get depth from previous block
self.assertEquals(newTransBlock.TransactionDepth, 1)
def test_journal_transaction_block_build_message(self):
# Test build_message, returns a TransactionBlockMessage
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block = TransactionBlock(minfo)
node = self._create_node()
trans_block.sign_from_node(node)
trans_block.Status = tbStatus.valid
msg = trans_block.build_message()
self.assertEquals(msg.MessageType,
"/journal.messages.TransactionBlockMessage" +
"/TransactionBlock")
self.assertEquals(msg.TransactionBlock, trans_block)
def test_journal_transaction_block_build_message(self):
# Test build_message, returns a TransactionBlockMessage
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block = TransactionBlock(minfo)
node = self._create_node()
trans_block.sign_from_node(node)
trans_block.Status = tbStatus.valid
msg = trans_block.build_message()
self.assertEquals(msg.MessageType,
"/journal.messages.TransactionBlockMessage" +
"/TransactionBlock")
self.assertEquals(msg.TransactionBlock, trans_block)
def test_journal_transaction_block_dump(self):
# Test that transactions dump the correct info
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block = TransactionBlock(minfo)
node = self._create_node()
trans_block.sign_from_node(node)
trans_block.Status = tbStatus.valid
tb_dic = trans_block.dump()
self.assertEquals(tb_dic["TransactionIDs"], [])
self.assertEquals(tb_dic["TransactionBlockType"], "/TransactionBlock")
self.assertEquals(tb_dic["BlockNum"], 0)
self.assertIsNotNone(tb_dic["Signature"])
self.assertNotEquals(tb_dic["Signature"], "")
def test_journal_transaction_block_dump(self):
# Test that transactions dump the correct info
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block = TransactionBlock(minfo)
node = self._create_node()
trans_block.sign_from_node(node)
trans_block.Status = tbStatus.valid
tb_dic = trans_block.dump()
self.assertEquals(tb_dic["TransactionIDs"], [])
self.assertEquals(tb_dic["TransactionBlockType"], "/TransactionBlock")
self.assertEquals(tb_dic["BlockNum"], 0)
self.assertIsNotNone(tb_dic["Signature"])
self.assertNotEquals(tb_dic["Signature"], "")
def test_journal_transaction_block_cmp_valid_blocks(self):
# Test the overridden cmp function
# Needs the Blocks to be signed and valid
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
transBlock1 = TransactionBlock(minfo)
transBlock2 = TransactionBlock(minfo)
signingkey = SigObj.generate_signing_key()
ident = SigObj.generate_identifier(signingkey)
node = Node(identifier=ident, signingkey=signingkey,
address=("localhost", 8800))
# Need to sign TransactionBlock, use sign_from_node form signed object
transBlock1.sign_from_node(node)
transBlock2.sign_from_node(node)
transBlock1.Status = tbStatus.valid
transBlock2.Status = tbStatus.valid
# Test Equal Transaction Blocks
self.assertEquals(cmp(transBlock2, transBlock1), 0)
# Test a Transaction Block with greater Transaction Depth
transBlock2.TransactionDepth = 10
self.assertEquals(cmp(transBlock2, transBlock1), 1)
# Test a Transaction Block with lesser Transaction Depth
transBlock1.TransactionDepth = 20
self.assertEquals(cmp(transBlock2, transBlock1), -1)
def test_journal_transaction_block_cmp_valid_blocks(self):
# Test the overridden cmp function
# Needs the Blocks to be signed and valid
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
transBlock1 = TransactionBlock(minfo)
transBlock2 = TransactionBlock(minfo)
signingkey = SigObj.generate_signing_key()
ident = SigObj.generate_identifier(signingkey)
node = Node(identifier=ident, signingkey=signingkey,
address=("localhost", 8800))
# Need to sign TransactionBlock, use sign_from_node form signed object
transBlock1.sign_from_node(node)
transBlock2.sign_from_node(node)
transBlock1.Status = tbStatus.valid
transBlock2.Status = tbStatus.valid
# Test Equal Transaction Blocks
self.assertEquals(cmp(transBlock2, transBlock1), 0)
# Test a Transaction Block with greater Transaction Depth
transBlock2.TransactionDepth = 10
self.assertEquals(cmp(transBlock2, transBlock1), 1)
# Test a Transaction Block with lesser Transaction Depth
transBlock1.TransactionDepth = 20
self.assertEquals(cmp(transBlock2, transBlock1), -1)
def test_journal_transaction_block_build_message(self):
# Test build_message, returns a TransactionBlockMessage
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
transBlock = TransactionBlock(minfo)
signingkey = SigObj.generate_signing_key()
ident = SigObj.generate_identifier(signingkey)
node = Node(identifier=ident, signingkey=signingkey,
address=("localhost", 8800))
transBlock.sign_from_node(node)
transBlock.Status = tbStatus.valid
msg = transBlock.build_message()
self.assertEquals(msg.MessageType,
"/journal.messages.TransactionBlockMessage" +
"/TransactionBlock")
self.assertEquals(msg.TransactionBlock, transBlock)
def test_journal_transaction_block_build_message(self):
# Test build_message, returns a TransactionBlockMessage
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
transBlock = TransactionBlock(minfo)
signingkey = SigObj.generate_signing_key()
ident = SigObj.generate_identifier(signingkey)
node = Node(identifier=ident, signingkey=signingkey,
address=("localhost", 8800))
transBlock.sign_from_node(node)
transBlock.Status = tbStatus.valid
msg = transBlock.build_message()
self.assertEquals(msg.MessageType,
"/journal.messages.TransactionBlockMessage" +
"/TransactionBlock")
self.assertEquals(msg.TransactionBlock, transBlock)
def test_journal_transaction_block_dump(self):
# Test that transactions dump the correct info
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
transBlock = TransactionBlock(minfo)
signingkey = SigObj.generate_signing_key()
ident = SigObj.generate_identifier(signingkey)
node = Node(identifier=ident, signingkey=signingkey,
address=("localhost", 8800))
transBlock.sign_from_node(node)
transBlock.Status = tbStatus.valid
tbDic = transBlock.dump()
self.assertEquals(tbDic["TransactionIDs"], [])
self.assertEquals(tbDic["TransactionBlockType"], "/TransactionBlock")
self.assertEquals(tbDic["BlockNum"], 0)
self.assertIsNotNone(tbDic["Signature"])
self.assertNotEquals(tbDic["Signature"], "")
def test_journal_transaction_block_dump(self):
# Test that transactions dump the correct info
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
transBlock = TransactionBlock(minfo)
signingkey = SigObj.generate_signing_key()
ident = SigObj.generate_identifier(signingkey)
node = Node(identifier=ident, signingkey=signingkey,
address=("localhost", 8800))
transBlock.sign_from_node(node)
transBlock.Status = tbStatus.valid
tbDic = transBlock.dump()
self.assertEquals(tbDic["TransactionIDs"], [])
self.assertEquals(tbDic["TransactionBlockType"], "/TransactionBlock")
self.assertEquals(tbDic["BlockNum"], 0)
self.assertIsNotNone(tbDic["Signature"])
self.assertNotEquals(tbDic["Signature"], "")