Added test for contract dependencies

market/test/test_blockchain.py

@@ -6,6 +6,7 @@
 from dispersy.util import blocking_call_on_reactor_thread
 
 from market.community.market.community import BlockchainCommunity
+from market.community.blockchain.community import BLOCK_GENESIS_HASH
 from market.models import ObjectType
 from market.models.contract import Contract
 from market.test.testcommunity import TestCommunity
@@ -50,51 +51,89 @@ def test_contract_sign_and_store(self):
         self.assertEqual(contract.document, self.document)
         self.assertTrue(contract.verify())
 
-        for community in self.communities:
-            def get_next_difficulty(c, b):
-                # First block should be create immediately
-                return 0xffffff0000000000000000000000000000000000000000000000000000000000 if not b else 0
-
-            community.get_next_difficulty = lambda b, c = community: get_next_difficulty(c, b)
+        self.set_fixed_difficulty()
+        self.node2.cancel_pending_task('create_block')
 
         yield DeferredList([self.get_next_message(self.node1, u'block'),
                             self.get_next_message(self.node2, u'block')], fireOnOneCallback=True)
 
-        first_block1 = self.node1.data_manager.get_block_indexes().first().block_id
-        first_block2 = self.node2.data_manager.get_block_indexes().first().block_id
+        first_block1 = list(self.node1.data_manager.get_block_indexes())[-1].block_id
+        first_block2 = list(self.node2.data_manager.get_block_indexes())[-1].block_id
 
         # Check if a block is created
         self.assertTrue(first_block2)
         # Check if both bank agree on the block
         self.assertEqual(first_block2, first_block1)
 
+    @blocking_call_on_reactor_thread
+    def test_contract_order(self):
+        self.set_fixed_difficulty()
+        self.node1.cancel_pending_task('create_block')
+        self.node2.cancel_pending_task('create_block')
+
+        c1 = self.create_contract(self.node1, self.node2)
+        c2 = self.create_contract(self.node1, self.node2, previous_hash=c1.id)
+
+        self.node1.incoming_contracts[c2.id] = c2
+        self.node1.create_block()
+
+        # c2 should not be on the blockchain yet, since it has c1 as dependency
+        self.assertTrue(self.node1.incoming_contracts.values() == [c2])
+
+        self.node1.incoming_contracts[c1.id] = c1
+        self.node1.create_block()
+
+        # c1 should be on the blockchain
+        self.assertTrue(self.node1.incoming_contracts.values() == [c2])
+
+        self.node1.create_block()
+
+        # c2 should be on the blockchain
+        self.assertTrue(self.node1.incoming_contracts.values() == [])
+
+        # Check blockchain
+        contract_ids = []
+        for block_index in reversed(list(self.node1.data_manager.get_block_indexes())):
+            if block_index.block_id != BLOCK_GENESIS_HASH:
+                block = self.node1.data_manager.get_block(block_index.block_id)
+                contract_ids += [c.id for c in block.contracts]
+        self.assertTrue(contract_ids == [c1.id, c2.id])
+
     @blocking_call_on_reactor_thread
     @inlineCallbacks
     def test_traversal_request(self):
         # Create dummy contract chain. We need to create the contract twice (once for each node) or storm will complain
-        node1_contract1 = self.create_contract(self.node1.my_member, self.node2.my_member)
-        node1_contract2 = self.create_contract(self.node2.my_member, self.node1.my_member, node1_contract1.id)
+        node1_contract1 = self.create_contract(self.node1, self.node2)
+        node1_contract2 = self.create_contract(self.node2, self.node1, previous_hash=node1_contract1.id)
         self.node1.data_manager.add_contract(node1_contract1)
         self.node1.data_manager.add_contract(node1_contract2)
 
-        node2_contract1 = self.create_contract(self.node1.my_member, self.node2.my_member)
-        node2_contract2 = self.create_contract(self.node2.my_member, self.node1.my_member, node2_contract1.id)
+        node2_contract1 = self.create_contract(self.node1, self.node2)
+        node2_contract2 = self.create_contract(self.node2, self.node1, previous_hash=node2_contract1.id)
         self.node2.data_manager.add_contract(node2_contract1)
         self.node2.data_manager.add_contract(node2_contract2)
 
         contract = yield self.node1.send_traversal_request(node1_contract1.id)
         self.assertEqual(contract.to_public_key, self.node1.my_member.public_key)
 
-    def create_contract(self, from_member, to_member, previous_hash=''):
+    def set_fixed_difficulty(self):
+        for community in self.communities:
+            def get_next_difficulty(c, b):
+                # Mine all blocks (almost) instantly
+                return 0xffffff0000000000000000000000000000000000000000000000000000000000
+
+            community.get_next_difficulty = lambda b, c = community: get_next_difficulty(c, b)
+
+    def create_contract(self, from_node, to_node, previous_hash='', object_type=ObjectType.MORTGAGE):
         contract = Contract()
-        contract.from_public_key = from_member.public_key
-        contract.to_public_key = to_member.public_key
+        contract.from_public_key = from_node.my_member.public_key
+        contract.to_public_key = to_node.my_member.public_key
         contract.document = self.document
-        contract.type = ObjectType.MORTGAGE
+        contract.type = object_type
         contract.previous_hash = previous_hash
         contract.time = 1
-        contract.sign(from_member)
-        contract.sign(to_member)
+        contract.sign(from_node.my_member)
+        contract.sign(to_node.my_member)
         return contract
 
     def create_community(self, *args, **kwargs):

market/test/testcommunity.py

@@ -1,17 +1,18 @@
 import sys
 import logging
-import unittest
 
 from tempfile import mkdtemp
 
 # This will ensure nose starts the reactor. Do not remove
 from nose.twistedtools import reactor
-from twisted.internet.defer import Deferred
+from twisted.internet.defer import Deferred, inlineCallbacks
 from twisted.python import log
+from twisted.trial import unittest
 
 from dispersy.dispersy import Dispersy
 from dispersy.endpoint import StandaloneEndpoint
 from dispersy.candidate import Candidate
+from dispersy.util import blocking_call_on_reactor_thread
 
 logging.basicConfig(stream=sys.stderr)
 logging.getLogger("MarketLogger").setLevel(logging.DEBUG)
@@ -27,11 +28,14 @@ def setUp(self):
         self.communities = []
         self.message_callbacks = {}
 
+    @blocking_call_on_reactor_thread
+    @inlineCallbacks
     def tearDown(self):
         super(TestCommunity, self).tearDown()
 
         for community in self.communities:
-            community.dispersy.stop()
+            if community.dispersy.running:
+                yield community.dispersy.stop()
 
     def create_community(self, cls, *args, **kwargs):
         temp_dir = unicode(mkdtemp(suffix="_dispersy_test_session"))
@@ -78,7 +82,7 @@ def timeout(d):
                 raise Exception('get_next_message timeout')
 
         deferred = Deferred()
-        reactor.callLater(10, timeout, deferred)
+        community.register_task(deferred, reactor.callLater(10, timeout, deferred))
         self.message_callbacks[community] = self.message_callbacks.get(community, {})
         self.message_callbacks[community][message_name] = self.message_callbacks.get(message_name, [])
         self.message_callbacks[community][message_name].append(deferred)