Add Tests for tx serialization logic

This commit is contained in:
tim 2016-08-05 10:13:34 +02:00 committed by Sylvain Bellemare
parent ee0de84a30
commit f459d535e3

View File

@ -1,118 +1,195 @@
from pytest import raises from pytest import raises
def test_fulfillment_serialization(ffill, user_vk): def test_fulfillment_serialization(ffill_uri, user_vk):
from bigchaindb.transaction import ( from bigchaindb.transaction import Fulfillment
Fulfillment, from cryptoconditions import Fulfillment as CCFulfillment
)
ffill = Fulfillment(ffill, [user_vk]) expected = {
ffill_dict = ffill.to_dict()
assert ffill_dict['owners_before'] == [user_vk]
assert ffill_dict['input'] == None
assert ffill_dict['fulfillment'] == ffill.fulfillment.serialize_uri()
assert ffill_dict['fid'] == 0
def test_fulfillment_deserialization(ffill_uri, user_vk):
from bigchaindb.transaction import (
Fulfillment,
)
ffill_dict = {
'owners_before': [user_vk], 'owners_before': [user_vk],
'fulfillment': ffill_uri, 'fulfillment': ffill_uri,
'details': CCFulfillment.from_uri(ffill_uri).to_dict(),
'fid': 0, 'fid': 0,
'input': None, 'input': None,
} }
ffill = Fulfillment(CCFulfillment.from_uri(ffill_uri), [user_vk])
assert Fulfillment.from_dict(ffill_dict).to_dict() == ffill_dict assert ffill.to_dict() == expected
def test_invalid_fulfillment_initialization(ffill, user_vk): def test_fulfillment_deserialization_with_uri(ffill_uri, user_vk):
from bigchaindb.transaction import ( from bigchaindb.transaction import Fulfillment
Fulfillment, from cryptoconditions import Fulfillment as CCFulfillment
)
expected = Fulfillment(CCFulfillment.from_uri(ffill_uri), [user_vk])
ffill = {
'owners_before': [user_vk],
'fulfillment': ffill_uri,
'details': CCFulfillment.from_uri(ffill_uri).to_dict(),
'fid': 0,
'input': None,
}
ffill = Fulfillment.from_dict(ffill)
assert ffill.to_dict() == expected.to_dict()
def test_fulfillment_deserialization_with_dict(cc_ffill, user_vk):
from bigchaindb.transaction import Fulfillment
expected = Fulfillment(cc_ffill, [user_vk])
ffill = {
'owners_before': [user_vk],
'fulfillment': None,
'details': cc_ffill.to_dict(),
'fid': 0,
'input': None,
}
ffill = Fulfillment.from_dict(ffill)
assert ffill.to_dict() == expected.to_dict()
def test_invalid_fulfillment_initialization(cc_ffill, user_vk):
from bigchaindb.transaction import Fulfillment
with raises(TypeError): with raises(TypeError):
Fulfillment(ffill, user_vk) Fulfillment(cc_ffill, user_vk)
def test_condition_serialization(user_vk): def test_gen_default_fulfillment(user_vk):
from bigchaindb.transaction import ( from bigchaindb.transaction import Fulfillment
Condition, from cryptoconditions import Ed25519Fulfillment
)
cond = Condition.gen_default(user_vk) ffill = Fulfillment.gen_default(user_vk)
cond_dict = cond.to_dict() assert ffill.owners_before == [user_vk]
assert cond_dict['owners_after'] == [user_vk] assert ffill.fid == 0
assert cond_dict['condition']['uri'] == cond.condition.condition_uri assert ffill.fulfillment.to_dict() == Ed25519Fulfillment(public_key=user_vk).to_dict()
assert cond_dict['cid'] == 0 assert ffill.tx_input is None
def test_condition_deserialization(user_vk): def test_condition_serialization(cond_uri, user_vk):
from bigchaindb.transaction import ( from bigchaindb.transaction import Condition
Condition,
)
cond = Condition.gen_default(user_vk) expected = {
cond_dict = { 'condition': cond_uri,
'condition': {
'uri': cond.condition.condition_uri,
'details': cond.condition.to_dict()
},
'owners_after': [user_vk], 'owners_after': [user_vk],
'cid': 0, 'cid': 0,
} }
assert Condition.from_dict(cond_dict).to_dict() == cond_dict cond = Condition(cond_uri, [user_vk])
assert cond.to_dict() == expected
def test_invalid_condition_initialization(ffill, user_vk): def test_condition_deserialization(cond_uri, user_vk):
from bigchaindb.transaction import ( from bigchaindb.transaction import Condition
Condition,
) expected = Condition(cond_uri, [user_vk])
cond = {
'condition': cond_uri,
'owners_after': [user_vk],
'cid': 0,
}
cond = Condition.from_dict(cond)
assert cond.to_dict() == expected.to_dict()
def test_invalid_condition_initialization(cond_uri, user_vk):
from bigchaindb.transaction import Condition
with raises(TypeError): with raises(TypeError):
Condition(ffill.condition, user_vk) Condition(cond_uri, user_vk)
def test_gen_default_condition(user_vk): def test_invalid_data_initialization():
from bigchaindb.transaction import ( from bigchaindb.transaction import Data
Condition,
) with raises(TypeError):
from cryptoconditions import Ed25519Fulfillment Data([])
cond = Condition.gen_default(user_vk)
assert cond.owners_after == [user_vk]
assert cond.cid == 0
# TODO: Would be nice if Cryptoconditions would implement a `__eq__` method
# NOTE: This doesn't make sense yet...
assert cond.condition.to_dict() == Ed25519Fulfillment(public_key=user_vk).to_dict()
def test_create_default_transaction(user_vk): def test_data_serialization(payload, payload_id):
from bigchaindb.transaction import ( from bigchaindb.transaction import Data
Condition,
Transaction, expected = {
) 'payload': payload,
cond = Condition.gen_default(user_vk) 'hash': payload_id
tx = Transaction([cond]) }
assert tx.conditions == [cond] data = Data(payload, payload_id)
assert tx.fulfillments == []
assert tx.inputs is None assert data.to_dict() == expected
assert tx.payload is None
def test_sign_default_transaction(user_vk, user_sk): def test_data_deserialization(payload, payload_id):
from bigchaindb.transaction import ( from bigchaindb.transaction import Data
Fulfillment,
Transaction,
)
ffill = Fulfillment.gen_default(user_vk) expected = Data(payload, payload_id)
ffill.to_dict() data = Data.from_dict({'payload': payload, 'hash': payload_id})
cond = ffill.gen_condition()
tx = Transaction(Transaction.CREATE, [ffill], [cond]) assert data.to_dict() == expected.to_dict()
tx.sign([user_sk])
tx_dict = tx.to_dict()
# TODO: We need to make sure to serialize the transaction correctly!!! def test_transaction_serialization(default_ffill, default_cond):
assert len(tx.fulfillments) > 0 from bigchaindb.transaction import Transaction
assert tx_dict['transaction']['conditions'][0] == cond.to_dict()
tx_id = 'l0l'
timestamp = '66666666666'
expected = {
'id': tx_id,
'version': Transaction.VERSION,
'transaction': {
# NOTE: This test assumes that Fulfillments and Conditions can successfully be serialized
'fulfillments': [default_ffill.to_dict()],
'conditions': [default_cond.to_dict()],
'operation': Transaction.CREATE,
'timestamp': timestamp,
'data': None,
}
}
tx_dict = Transaction(Transaction.CREATE, [default_ffill], [default_cond]).to_dict()
tx_dict['id'] = tx_id
tx_dict['transaction']['timestamp'] = timestamp
assert tx_dict == expected
def test_transaction_deserialization(default_ffill, default_cond):
from bigchaindb.transaction import Transaction
tx_id = 'l0l'
timestamp = '66666666666'
expected = Transaction(Transaction.CREATE, [default_ffill], [default_cond], None, timestamp, Transaction.VERSION)
tx = {
'id': tx_id,
'version': Transaction.VERSION,
'transaction': {
# NOTE: This test assumes that Fulfillments and Conditions can successfully be serialized
'fulfillments': [default_ffill.to_dict()],
'conditions': [default_cond.to_dict()],
'operation': Transaction.CREATE,
'timestamp': timestamp,
'data': None,
}
}
tx = Transaction.from_dict(tx)
assert tx.to_dict() == expected.to_dict()
def test_invalid_tx_initialization():
from bigchaindb.transaction import Transaction
wrong_data_type = {'payload': 'a totally wrong datatype'}
with raises(TypeError):
Transaction(Transaction.CREATE, wrong_data_type)
with raises(TypeError):
Transaction(Transaction.CREATE, [], wrong_data_type)
with raises(TypeError):
Transaction(Transaction.CREATE, [], [], wrong_data_type)