Fixed some issues with getTransfers.

Author: todofixthis

iota/api.py

@@ -489,7 +489,7 @@ def get_new_addresses(self, index=None, count=1):
     return self.getNewAddresses(seed=self.seed, index=index, count=count)
 
   def get_transfers(self, start=0, end=None, inclusion_states=False):
-    # type: (int, Optional[int], bool) -> List[Bundle]
+    # type: (int, Optional[int], bool) -> dict
     """
     Returns all transfers associated with the seed.
 
@@ -512,7 +512,12 @@ def get_transfers(self, start=0, end=None, inclusion_states=False):
       disabled by default.
 
     :return:
-      List of bundles.
+      Dict containing the following values::
+
+         {
+           'bundles': List[Bundle]
+             Matching bundles, sorted by tail transaction timestamp.
+         }
 
     References:
       - https://github.com/iotaledger/wiki/blob/master/api-proposal.md#gettransfers

iota/commands/extended/get_transfers.py

@@ -71,7 +71,11 @@ def _execute(self, request):
     tails     = set()
     non_tails = set()
 
-    transactions = self._find_transactions(hashes=hashes)
+    gt_response = GetTrytesCommand(self.adapter)(hashes=hashes)
+    transactions = list(map(
+      Transaction.from_tryte_string,
+      gt_response['trytes'],
+    ))
 
     for txn in transactions:
       if txn.is_tail:
@@ -100,7 +104,7 @@ def _execute(self, request):
 
     # Find the bundles for each transaction.
     for txn in transactions:
-      gb_response = GetBundlesCommand(self.adapter)(transactions=txn.hash)
+      gb_response = GetBundlesCommand(self.adapter)(transaction=txn.hash)
       txn_bundles = gb_response['bundles'] # type: List[Bundle]
 
       if inclusion_states:
@@ -109,11 +113,13 @@ def _execute(self, request):
 
       all_bundles.extend(txn_bundles)
 
-    # Sort bundles by tail transaction timestamp.
-    return list(sorted(
-      all_bundles,
-      key = lambda bundle_: bundle_.tail_transaction.timestamp,
-    ))
+    return {
+      # Sort bundles by tail transaction timestamp.
+      'bundles': list(sorted(
+        all_bundles,
+        key = lambda bundle_: bundle_.tail_transaction.timestamp,
+      )),
+    }
 
 
   def _find_transactions(self, **kwargs):

iota/types.py

@@ -235,6 +235,10 @@ def __init__(self, trytes, pad=None):
 
     self._trytes = trytes # type: bytearray
 
+  def __hash__(self):
+    # type: () -> int
+    return hash(binary_type(self._trytes))
+
   def __repr__(self):
     # type: () -> Text
     return '{cls}({trytes!r})'.format(

test/__init__.py

@@ -61,15 +61,28 @@ def send_request(self, payload, **kwargs):
 
     try:
       response = self.responses[command].pop(0)
-    except (KeyError, IndexError):
+    except KeyError:
       raise with_context(
         exc = BadApiResponse(
-          'Unknown request {command!r} (expected one of: {seeds!r}).'.format(
+          'No seeded response for {command!r} '
+          '(expected one of: {seeds!r}).'.format(
             command = command,
             seeds   = list(sorted(self.responses.keys())),
           ),
         ),
 
+        context = {
+          'request': payload,
+        },
+      )
+    except IndexError:
+      raise with_context(
+        exc = BadApiResponse(
+          '{command} called too many times; no seeded responses left.'.format(
+            command = command,
+          ),
+        ),
+
         context = {
           'request': payload,
         },

test/commands/extended/get_transfers_test.py

@@ -6,9 +6,10 @@
 
 import filters as f
 from filters.test import BaseFilterTestCase
+from mock import Mock, patch
 from six import binary_type, text_type
 
-from iota import Iota
+from iota import Address, Iota, Bundle, Tag, Transaction
 from iota.commands.extended.get_transfers import GetTransfersCommand, \
   GetTransfersRequestFilter
 from iota.crypto.types import Seed
@@ -336,8 +337,104 @@ def test_full_scan(self):
     """
     Scanning the Tangle for all transfers.
     """
-    # :todo: Implement test.
-    self.skipTest('Not implemented yet.')
+    addy1 =\
+      Address(
+        b'TESTVALUEONE9DONTUSEINPRODUCTION99999YDZ'
+        b'E9TAFAJGJA9CECKDAEPHBICDR9LHFCOFRBQDHC9IG'
+      )
+
+    addy2 =\
+      Address(
+        b'TESTVALUETWO9DONTUSEINPRODUCTION99999TES'
+        b'GINEIDLEEHRAOGEBMDLENFDAFCHEIHZ9EBZDD9YHL'
+      )
+
+    # To speed up the test, we will mock the address generator.
+    # :py:class:`iota.crypto.addresses.AddressGenerator` already has
+    # its own test case, so this does not impact the stability of the
+    # codebase.
+    # noinspection PyUnusedLocal
+    def create_generator(ag, start, step=1):
+      for addy in [addy1, addy2][start::step]:
+        yield addy
+
+    # The first address received IOTA.
+    self.adapter.seed_response(
+      'findTransactions',
+
+      {
+        'duration': 42,
+
+        'hashes': [
+          'TESTVALUEFIVE9DONTUSEINPRODUCTION99999VH'
+          'YHRHJETGYCAFZGABTEUBWCWAS9WF99UHBHRHLIOFJ',
+        ],
+      },
+    )
+
+    # The second address is unused.
+    self.adapter.seed_response(
+      'findTransactions',
+
+      {
+        'duration': 1,
+        'hashes':   [],
+      },
+    )
+
+    self.adapter.seed_response(
+      'getTrytes',
+
+      {
+        'duration': 99,
+
+        # Thankfully, we do not have to seed a realistic response for
+        # ``getTrytes``, as we will be mocking the ``getBundles``
+        # command that uses on it.
+        'trytes': [''],
+      },
+    )
+
+    bundle = Bundle([
+      Transaction(
+        address = addy1,
+        timestamp = 1483033814,
+
+        # These values are not relevant to the test.
+        hash_ = None,
+        signature_message_fragment = None,
+        value = 42,
+        tag = Tag(b''),
+        current_index = 0,
+        last_index = 0,
+        bundle_hash = None,
+        trunk_transaction_hash = None,
+        branch_transaction_hash = None,
+        nonce = None,
+      )
+    ])
+
+    mock_get_bundles = Mock(return_value={
+      'bundles': [bundle],
+    })
+
+    with patch(
+        'iota.crypto.addresses.AddressGenerator.create_generator',
+        create_generator,
+    ):
+      with patch(
+          'iota.commands.extended.get_bundles.GetBundlesCommand._execute',
+          mock_get_bundles,
+      ):
+        response = self.command(seed=Seed.random())
+
+    self.assertDictEqual(
+      response,
+
+      {
+        'bundles': [bundle],
+      },
+    )
 
   def test_start(self):
     """