def test_journal_transaction_block_missing_transactions(self):
# Test missing transactions, should return list of missing
# transactions
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block = TransactionBlock(minfo)
(gossip, journal) = self._create_journal()
node = gossip.LocalNode
trans_block.sign_from_node(node)
missing = trans_block.missing_transactions(journal)
# No missing transactions
self.assertEquals(missing, [])
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
transaction.sign_from_node(node)
trans_block.TransactionIDs += [transaction.Identifier]
missing = trans_block.missing_transactions(journal)
# One missing transactions
self.assertEquals(missing, [transaction.Identifier])
journal.transaction_store[transaction.Identifier] = transaction
missing = trans_block.missing_transactions(journal)
# Back to no missing transactions
self.assertEquals(missing, [])
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_missing_transactions(self):
# Test missing transactions, should return list of missing transactions
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", 10002))
path = tempfile.mkdtemp()
# Takes a journal, create a temporary directory to use with the journal
journal = Journal(node, DataDirectory=path)
transBlock.sign_from_node(node)
missing = transBlock.missing_transactions(journal)
# No missing transactions
self.assertEquals(missing, [])
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
transaction.sign_from_node(node)
transBlock.TransactionIDs += [transaction.Identifier]
missing = transBlock.missing_transactions(journal)
# One missing transactions
self.assertEquals(missing, [transaction.Identifier])
journal.TransactionStore[transaction.Identifier] = transaction
missing = transBlock.missing_transactions(journal)
# Back to no missing transactions
self.assertEquals(missing, [])
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_missing_transactions(self):
# Test missing transactions, should return list of missing
# transactions
minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0}
trans_block = TransactionBlock(minfo)
(gossip, journal) = self._create_journal()
node = gossip.LocalNode
trans_block.sign_from_node(node)
missing = trans_block.missing_transactions(journal)
# No missing transactions
self.assertEquals(missing, [])
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
transaction.sign_from_node(node)
trans_block.TransactionIDs += [transaction.Identifier]
missing = trans_block.missing_transactions(journal)
# One missing transactions
self.assertEquals(missing, [transaction.Identifier])
journal.transaction_store[transaction.Identifier] = transaction
missing = trans_block.missing_transactions(journal)
# Back to no missing transactions
self.assertEquals(missing, [])
def test_journal_transaction_block_missing_transactions(self):
# Test missing transactions, should return list of missing transactions
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", 10002))
path = tempfile.mkdtemp()
# Takes a journal, create a temporary directory to use with the journal
journal = Journal(node, DataDirectory=path)
transBlock.sign_from_node(node)
missing = transBlock.missing_transactions(journal)
# No missing transactions
self.assertEquals(missing, [])
minfo = {
'__SIGNATURE__': 'Test',
'__NONCE__': time.time(),
'Dependencies': []
}
transaction = Transaction(minfo)
transaction.sign_from_node(node)
transBlock.TransactionIDs += [transaction.Identifier]
missing = transBlock.missing_transactions(journal)
# One missing transactions
self.assertEquals(missing, [transaction.Identifier])
journal.TransactionStore[transaction.Identifier] = transaction
missing = transBlock.missing_transactions(journal)
# Back to no missing transactions
self.assertEquals(missing, [])
def test_journal_transaction_add_to_pending(self):
# Test transaction add_to_pending, should always return true
minfo = {
'__SIGNATURE__': 'Test',
'__NONCE__': time.time(),
'Dependencies': []
}
transaction = Transaction(minfo)
self.assertTrue(transaction.add_to_pending())
def test_journal_transaction_apply(self):
# Test Transaction apply, Does nothing at this point
minfo = {
'__SIGNATURE__': 'Test',
'__NONCE__': time.time(),
'Dependencies': []
}
transaction = Transaction(minfo)
transaction.apply("store")
def test_journal_transaction_build_message(self):
# Test that build_message returns a message of MessageType
# TransactionMessage and that msg is linked to the transaction
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
msg = transaction.build_message()
self.assertEquals(msg.MessageType,
"/journal.messages.TransactionMessage/Transaction")
self.assertEquals(msg.Transaction, transaction)
def test_journal_transaction_build_message(self):
# Test that build_message returns a message of MessageType
# TransactionMessage and that msg is linked to the transaction
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
msg = transaction.build_message()
self.assertEquals(msg.MessageType,
"/journal.messages.TransactionMessage/Transaction")
self.assertEquals(msg.Transaction, transaction)
def test_journal_transaction_dump(self):
# Test that transactions dump the correct info
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
time.sleep(.05)
transaction = Transaction(minfo)
tDic = transaction.dump()
self.assertLess(tDic["Nonce"], time.time())
self.assertEquals(tDic["Dependencies"], [])
self.assertEquals(tDic["TransactionType"], '/Transaction')
def test_journal_transaction_dump(self):
# Test that transactions dump the correct info
now = time.time()
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': now, 'Dependencies': []}
transaction = Transaction(minfo)
time.sleep(0.5)
t_dict = transaction.dump()
new = time.time()
self.assertLess(t_dict["Nonce"], new)
self.assertEqual(t_dict["Dependencies"], [])
self.assertEqual(t_dict["TransactionType"], '/Transaction')
def test_journal_transaction_dump(self):
# Test that transactions dump the correct info
now = time.time()
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': now,
'Dependencies': []}
transaction = Transaction(minfo)
time.sleep(0.5)
t_dict = transaction.dump()
new = time.time()
self.assertLess(t_dict["Nonce"], new)
self.assertEquals(t_dict["Dependencies"], [])
self.assertEquals(t_dict["TransactionType"], '/Transaction')
def test_web_api_transaction(self):
# Test _handletxnrequest
local_node = self._create_node(8802)
gossip = Gossip(local_node)
path = tempfile.mkdtemp()
# Setup ledger and RootPage
ledger = Journal(gossip, data_directory=path, genesis_ledger=True)
validator = TestValidator(ledger)
transaction_page = TransactionPage(validator)
# TransactionBlock to the ledger
txns = []
i = 0
while i < 10:
txn = Transaction()
txn.sign_from_node(local_node)
txns += [txn.Identifier]
ledger.TransactionStore[txn.Identifier] = txn
i += 1
trans_block = self._create_tblock(local_node, 0, common.NullIdentifier,
txns)
ledger.BlockStore[trans_block.Identifier] = trans_block
ledger.handle_advance(trans_block)
# GET /transaction
request = self._create_get_request("/transaction/", {})
r = transaction_page.do_get(request)
print request.path, r
r = r[1:-1].replace('"', "")
r = r.replace(" ", "").split(",")
self.assertEquals(r, txns)
# GET /transaction?blockcount=1
request = self._create_get_request("/transaction", {"blockcount": [1]})
r = transaction_page.do_get(request)
r = r[1:-1].replace('"', "")
r = r.replace(" ", "").split(",")
self.assertEquals(r, txns)
# Returns None if testing
# GET /transaction/{TransactionID}
request = self._create_get_request("/transaction/" + txns[1], {})
txn = ledger.TransactionStore[txns[1]]
tinfo = txn.dump()
tinfo['Identifier'] = txn.Identifier
tinfo['Status'] = txn.Status
if txn.Status == tStatus.committed:
tinfo['InBlock'] = txn.InBlock
self.assertEquals(yaml.load(transaction_page.do_get(request)), tinfo)
# GET /transaction/{TransactionID{}/InBlock
request = self._create_get_request("/transaction/" + txns[1] +
"/InBlock", {})
self.assertEquals(transaction_page.do_get(request).replace('"', ""),
txn.InBlock)
def test_web_api_transaction(self):
# Test _handletxnrequest
LocalNode = self._create_node(8802)
path = tempfile.mkdtemp()
# Setup ledger and RootPage
ledger = Journal(LocalNode, DataDirectory=path, GenesisLedger=True)
validator = TestValidator(ledger)
root = RootPage(validator)
# TransactionBlock to the ledger
txns = []
i = 0
while i < 10:
txn = Transaction()
txn.sign_from_node(LocalNode)
txns += [txn.Identifier]
ledger.TransactionStore[txn.Identifier] = txn
i += 1
transBlock = self._create_tblock(LocalNode, 0, common.NullIdentifier,
txns)
ledger.BlockStore[transBlock.Identifier] = transBlock
ledger.handle_advance(transBlock)
request = self._create_get_request("/transaction", {})
# GET /transaction
request = self._create_get_request("/transaction", {})
r = root.do_get(request)
r = r[1:-1].replace('"', "")
r = r.replace(" ", "").split(",")
self.assertEquals(r, txns)
# GET /transaction?blockcount=1
request = self._create_get_request("/transaction", {"blockcount": [1]})
r = root.do_get(request)
r = r[1:-1].replace('"', "")
r = r.replace(" ", "").split(",")
self.assertEquals(r, txns)
# Returns None if testing
# GET /transaction/{TransactionID}
request = self._create_get_request("/transaction/" + txns[1], {})
txn = ledger.TransactionStore[txns[1]]
tinfo = txn.dump()
tinfo['Identifier'] = txn.Identifier
tinfo['Status'] = txn.Status
if txn.Status == tStatus.committed:
tinfo['InBlock'] = txn.InBlock
self.assertEquals(yaml.load(root.do_get(request)), tinfo)
# GET /transaction/{TransactionID{}/InBlock
request = self._create_get_request("/transaction/" + txns[1] +
"/InBlock", {})
self.assertEquals(root.do_get(request).replace('"', ""),
txn.InBlock)
def test_web_api_transaction(self):
validator = self._create_validator()
gossip = validator.gossip
journal = validator.journal
transaction_page = TransactionPage(validator)
# TransactionBlock to the journal
txns = []
i = 0
while i < 10:
txn = Transaction()
txn.sign_from_node(gossip.LocalNode)
txns += [txn.Identifier]
journal.transaction_store[txn.Identifier] = txn
i += 1
trans_block = self._create_tblock(gossip.LocalNode,
0,
common.NullIdentifier,
txns)
journal.block_store[trans_block.Identifier] = trans_block
journal.handle_advance(trans_block)
# GET /transaction
request = self._create_get_request("/transaction/", {})
r = transaction_page.do_get(request)
print request.path, r
r = r[1:-1].replace('"', "")
r = r.replace(" ", "").split(",")
self.assertEquals(r, txns)
# GET /transaction?blockcount=1
request = self._create_get_request("/transaction", {"blockcount": [1]})
r = transaction_page.do_get(request)
r = r[1:-1].replace('"', "")
r = r.replace(" ", "").split(",")
self.assertEquals(r, txns)
# Returns None if testing
# GET /transaction/{TransactionID}
request = self._create_get_request("/transaction/" + txns[1], {})
txn = journal.transaction_store[txns[1]]
tinfo = txn.dump()
tinfo['Identifier'] = txn.Identifier
tinfo['Status'] = txn.Status
if txn.Status == tStatus.committed:
tinfo['InBlock'] = txn.InBlock
self.assertEquals(yaml.load(transaction_page.do_get(request)), tinfo)
# GET /transaction/{TransactionID{}/InBlock
request = self._create_get_request("/transaction/" + txns[1] +
"/InBlock", {})
self.assertEquals(transaction_page.do_get(request).replace('"', ""),
txn.InBlock)
def test_web_api_transaction(self):
validator = self._create_validator()
gossip = validator.gossip
journal = validator.journal
transaction_page = TransactionPage(validator)
# TransactionBlock to the journal
txns = []
i = 0
while i < 10:
txn = Transaction()
txn.sign_from_node(gossip.LocalNode)
txns += [txn.Identifier]
journal.transaction_store[txn.Identifier] = txn
i += 1
trans_block = self._create_tblock(gossip.LocalNode, 0,
common.NullIdentifier, txns)
journal.block_store[trans_block.Identifier] = trans_block
journal.handle_advance(trans_block)
# GET /transaction
request = self._create_get_request("/transaction/", {})
r = transaction_page.do_get(request)
print request.path, r
r = r[1:-1].replace('"', "")
r = r.replace(" ", "").split(",")
self.assertEquals(r, txns)
# GET /transaction?blockcount=1
request = self._create_get_request("/transaction", {"blockcount": [1]})
r = transaction_page.do_get(request)
r = r[1:-1].replace('"', "")
r = r.replace(" ", "").split(",")
self.assertEquals(r, txns)
# Returns None if testing
# GET /transaction/{TransactionID}
request = self._create_get_request("/transaction/" + txns[1], {})
txn = journal.transaction_store[txns[1]]
tinfo = txn.dump()
tinfo['Identifier'] = txn.Identifier
tinfo['Status'] = txn.Status
if txn.Status == tStatus.committed:
tinfo['InBlock'] = txn.InBlock
self.assertEquals(yaml.load(transaction_page.do_get(request)), tinfo)
# GET /transaction/{TransactionID{}/InBlock
request = self._create_get_request(
"/transaction/" + txns[1] + "/InBlock", {})
self.assertEquals(
transaction_page.do_get(request).replace('"', ""), txn.InBlock)
def test_journal_transaction_init(self):
# Test normal init of a transaction
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
self.assertEquals(transaction.Status, tStatus.unknown)
self.assertFalse(transaction.InBlock)
self.assertEquals(transaction.Dependencies, [])
def test_journal_transaction_str(self):
# Test str function for transaction
minfo = {
'__SIGNATURE__': 'Test',
'__NONCE__': time.time(),
'Dependencies': []
}
transaction = Transaction(minfo)
self.assertEqual(str(transaction), '/Transaction')
def test_is_valid_pub_key(self):
pubkey = pybitcointools.privkey_to_pubkey("5KQ4iQQGgbQX9MmfiPUwwHBL1R"
"GPa86NwFbqrWoodjuzruqFVDd")
pub = pybitcointools.encode_pubkey(pubkey, "hex")
minfo = {'Nonce': 100, 'public_key': pub,
'TransactionType': '/Transaction', 'Dependencies': []}
sig = pybitcointools.ecdsa_sign(
signed_object.dict2cbor(minfo),
"5KQ4iQQGgbQX9MmfiPUwwHBL1RGPa86NwFbqrWoodjuzruqFVDd"
)
# Create valid transaction
minfo["Signature"] = sig
temp = Transaction(minfo)
self.assertTrue(temp.is_valid("unused"))
# Change transaction after it was signed
minfo["Nonce"] = time.time()
temp = Transaction(minfo)
self.assertFalse(temp.is_valid("unused"))
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_is_valid_pub_key(self):
pubkey = signing.generate_pubkey("5KQ4iQQGgbQX9MmfiPUwwHBL1R"
"GPa86NwFbqrWoodjuzruqFVDd")
pub = signing.encode_pubkey(pubkey, "hex")
minfo = {
'Nonce': 100,
'PublicKey': pub,
'TransactionType': '/Transaction',
'Dependencies': []
}
sig = signing.sign(
signed_object.dict2cbor(minfo),
"5KQ4iQQGgbQX9MmfiPUwwHBL1RGPa86NwFbqrWoodjuzruqFVDd")
# Create valid transaction
minfo["Signature"] = sig
temp = Transaction(minfo)
self.assertTrue(temp.is_valid("unused"))
# Change transaction after it was signed
minfo["Nonce"] = time.time()
temp = Transaction(minfo)
self.assertFalse(temp.is_valid("unused"))
def test_journal_transaction_add_to_pending(self):
# Test transaction add_to_pending, should always return true
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
self.assertTrue(transaction.add_to_pending())
def test_journal_transaction_apply(self):
# Test Transaction apply, Does nothing at this point
minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(),
'Dependencies': []}
transaction = Transaction(minfo)
transaction.apply("store")