From f459d535e3f277a03780c8487f45537c45c36467 Mon Sep 17 00:00:00 2001 From: tim Date: Fri, 5 Aug 2016 10:13:34 +0200 Subject: [PATCH] Add Tests for tx serialization logic --- test_transaction.py | 247 +++++++++++++++++++++++++++++--------------- 1 file changed, 162 insertions(+), 85 deletions(-) diff --git a/test_transaction.py b/test_transaction.py index db34895e..624ec17b 100644 --- a/test_transaction.py +++ b/test_transaction.py @@ -1,118 +1,195 @@ from pytest import raises -def test_fulfillment_serialization(ffill, user_vk): - from bigchaindb.transaction import ( - Fulfillment, - ) +def test_fulfillment_serialization(ffill_uri, user_vk): + from bigchaindb.transaction import Fulfillment + from cryptoconditions import Fulfillment as CCFulfillment - ffill = Fulfillment(ffill, [user_vk]) - 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 = { + expected = { 'owners_before': [user_vk], 'fulfillment': ffill_uri, + 'details': CCFulfillment.from_uri(ffill_uri).to_dict(), 'fid': 0, '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): - from bigchaindb.transaction import ( - Fulfillment, - ) +def test_fulfillment_deserialization_with_uri(ffill_uri, user_vk): + from bigchaindb.transaction import 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): - Fulfillment(ffill, user_vk) + Fulfillment(cc_ffill, user_vk) -def test_condition_serialization(user_vk): - from bigchaindb.transaction import ( - Condition, - ) +def test_gen_default_fulfillment(user_vk): + from bigchaindb.transaction import Fulfillment + from cryptoconditions import Ed25519Fulfillment - cond = Condition.gen_default(user_vk) - cond_dict = cond.to_dict() - assert cond_dict['owners_after'] == [user_vk] - assert cond_dict['condition']['uri'] == cond.condition.condition_uri - assert cond_dict['cid'] == 0 + ffill = Fulfillment.gen_default(user_vk) + assert ffill.owners_before == [user_vk] + assert ffill.fid == 0 + assert ffill.fulfillment.to_dict() == Ed25519Fulfillment(public_key=user_vk).to_dict() + assert ffill.tx_input is None -def test_condition_deserialization(user_vk): - from bigchaindb.transaction import ( - Condition, - ) +def test_condition_serialization(cond_uri, user_vk): + from bigchaindb.transaction import Condition - cond = Condition.gen_default(user_vk) - cond_dict = { - 'condition': { - 'uri': cond.condition.condition_uri, - 'details': cond.condition.to_dict() - }, + expected = { + 'condition': cond_uri, 'owners_after': [user_vk], '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): - from bigchaindb.transaction import ( - Condition, - ) +def test_condition_deserialization(cond_uri, user_vk): + from bigchaindb.transaction import 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): - Condition(ffill.condition, user_vk) + Condition(cond_uri, user_vk) -def test_gen_default_condition(user_vk): - from bigchaindb.transaction import ( - Condition, - ) - from cryptoconditions import Ed25519Fulfillment - 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_invalid_data_initialization(): + from bigchaindb.transaction import Data + + with raises(TypeError): + Data([]) -def test_create_default_transaction(user_vk): - from bigchaindb.transaction import ( - Condition, - Transaction, - ) - cond = Condition.gen_default(user_vk) - tx = Transaction([cond]) - assert tx.conditions == [cond] - assert tx.fulfillments == [] - assert tx.inputs is None - assert tx.payload is None +def test_data_serialization(payload, payload_id): + from bigchaindb.transaction import Data + + expected = { + 'payload': payload, + 'hash': payload_id + } + data = Data(payload, payload_id) + + assert data.to_dict() == expected -def test_sign_default_transaction(user_vk, user_sk): - from bigchaindb.transaction import ( - Fulfillment, - Transaction, - ) +def test_data_deserialization(payload, payload_id): + from bigchaindb.transaction import Data - ffill = Fulfillment.gen_default(user_vk) - ffill.to_dict() - cond = ffill.gen_condition() - tx = Transaction(Transaction.CREATE, [ffill], [cond]) - tx.sign([user_sk]) - tx_dict = tx.to_dict() - # TODO: We need to make sure to serialize the transaction correctly!!! - assert len(tx.fulfillments) > 0 - assert tx_dict['transaction']['conditions'][0] == cond.to_dict() + expected = Data(payload, payload_id) + data = Data.from_dict({'payload': payload, 'hash': payload_id}) + + assert data.to_dict() == expected.to_dict() + + +def test_transaction_serialization(default_ffill, default_cond): + from bigchaindb.transaction import Transaction + + 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)