def test_previously_migrated_blobs_do_not_migrate(self): blob_info = _write_blob('1') # drive a blob through the migration self.call_migrate_blob(blob_info) self.assertNumberOfRealBlobs(1) self.assertNumberOfGcsSimulationBlobs(1) # drive it through a second time inline_patcher = mock.patch('app.migrator.migrate_single_blob_inline') pipeline_patcher = mock.patch( 'app.migrator.MigrateSingleBlobPipeline.start') inline_mock = inline_patcher.start() pipeline_mock = pipeline_patcher.start() try: self.call_migrate_blob(blob_info) finally: inline_patcher.stop() pipeline_mock.stop() # ensure that neither of the copying routines were invoked self.assertEquals(0, inline_mock.call_count) self.assertEquals(0, pipeline_mock.call_count) # ensure that no new GCS simulations have appeared self.assertNumberOfRealBlobs(1) self.assertNumberOfGcsSimulationBlobs(1)
async def test_transaction_found(self): """ A transaction is found with the inputs. A transaction object is returned """ with mock.patch( 'iota.commands.core.find_transactions.FindTransactionsCommand.' '_execute', mock.Mock(return_value=async_return( {'hashes': [ self.transaction_hash, ]})), ): with mock.patch( 'iota.commands.core.get_trytes.GetTrytesCommand._execute', mock.Mock( return_value=async_return({'trytes': [ self.trytes, ]})), ): response = await self.command(addresses=[self.address]) self.assertEqual(len(response['transactions']), 1) transaction = response['transactions'][0] self.assertIsInstance(transaction, Transaction) self.assertEqual(transaction.address, self.address)
async def test_non_tail(self): """ Called with a non-tail transaction. """ # For mocking GetTrytesCommand call self.adapter.seed_response( 'getTrytes', { # Tx with ID=1 'trytes': [self.three_tx_bundle[1].as_tryte_string()] }) # For mocking FindTransactionObjectsCommand call self.adapter.seed_response( 'findTransactions', {'hashes': [tx.hash for tx in self.three_tx_bundle]}) self.adapter.seed_response( 'getTrytes', {'trytes': [tx.as_tryte_string() for tx in self.three_tx_bundle]}) with mock.patch( 'iota.commands.extended.get_latest_inclusion.GetLatestInclusionCommand.__call__', MagicMock(return_value=async_return({ 'states': { self.three_tx_bundle.tail_transaction.hash: True } }))) as mocked_glis: with mock.patch( 'iota.commands.extended.get_bundles.GetBundlesCommand.__call__', MagicMock(return_value=async_return( {'bundles': [ self.three_tx_bundle, ]}))) as mocked_get_bundles: response = await get_bundles_from_transaction_hashes( adapter=self.adapter, transaction_hashes=[self.three_tx_bundle[1].hash], inclusion_states=True, ) self.assertListEqual( response, [ self.three_tx_bundle, ], ) self.assertTrue(response[0].is_confirmed) mocked_glis.assert_called_once_with( hashes=[self.three_tx_bundle.tail_transaction.hash]) mocked_get_bundles.assert_called_once_with( transactions=[self.three_tx_bundle.tail_transaction.hash])
def test_happy_path(self): """ Loading account data for an account. """ # noinspection PyUnusedLocal def mock_iter_used_addresses(adapter, seed, start): """ Mocks the ``iter_used_addresses`` function, so that we can simulate its functionality without actually connecting to the Tangle. References: - :py:func:`iota.commands.extended.utils.iter_used_addresses` """ yield self.addy1, [self.hash1] yield self.addy2, [self.hash2] mock_get_balances = mock.Mock(return_value={'balances': [42, 0]}) # Not particularly realistic, but good enough to prove that the # mocked function was invoked correctly. bundles = [Bundle(), Bundle()] mock_get_bundles_from_transaction_hashes = mock.Mock( return_value=bundles) with mock.patch( 'iota.commands.extended.get_account_data.iter_used_addresses', mock_iter_used_addresses, ): with mock.patch( 'iota.commands.extended.get_account_data.get_bundles_from_transaction_hashes', mock_get_bundles_from_transaction_hashes, ): with mock.patch( 'iota.commands.core.get_balances.GetBalancesCommand._execute', mock_get_balances, ): response = self.command(seed=Seed.random()) self.assertDictEqual( response, { 'addresses': [self.addy1, self.addy2], 'balance': 42, 'bundles': bundles, }, )
async def test_start_parameter_is_given(self): """ The correct address is returned if a start parameter is given. """ # Address 1 self.adapter.seed_response('findTransactions', { 'hashes': ['T' * 81], }) # Address 2 self.seed_unused_address() with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', self.mock_address_generator, ): self.assertEqual([self.address1], await self.get_all_used_addresses(start=1)) self.assertListEqual(self.adapter.requests, [ { 'command': 'findTransactions', 'addresses': [self.address1], }, { 'command': 'findTransactions', 'addresses': [self.address2], }, { 'command': 'wereAddressesSpentFrom', 'addresses': [self.address2], }, ])
def test_happy_path(self): """ Successfully promoting a bundle. """ self.adapter.seed_response('checkConsistency', { 'state': True, }) result_bundle = Bundle.from_tryte_strings([ TransactionTrytes(self.trytes1), TransactionTrytes(self.trytes2), ]) mock_send_transfer = mock.Mock(return_value={ 'bundle': result_bundle, }) with mock.patch( 'iota.commands.extended.send_transfer.SendTransferCommand._execute', mock_send_transfer, ): response = self.command( transaction=self.hash1, depth=3, minWeightMagnitude=16, ) self.assertDictEqual(response, { 'bundle': result_bundle, })
def test_no_stop_threshold_not_met(self): """ No ``stop`` provided, balance does not meet ``threshold``. """ self.adapter.seed_response('getBalances', { 'balances': [42, 29, 0], }) # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. # noinspection PyUnusedLocal def mock_address_generator(ag, start, step=1): for addy in [self.addy0, self.addy1, self.addy2][start::step]: yield addy # When ``stop`` is None, the command uses a generator internally. with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', mock_address_generator, ): with self.assertRaises(BadApiResponse): self.command( seed=Seed.random(), threshold=72, )
def test_no_stop_threshold_not_met(self): """ No ``stop`` provided, balance does not meet ``threshold``. """ self.adapter.seed_response('getBalances', { 'balances': [42, 29, 0], }) # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. # noinspection PyUnusedLocal def mock_address_generator(ag, start, step=1): for addy in [self.addy0, self.addy1, self.addy2][start::step]: yield addy # When ``stop`` is None, the command uses a generator internally. with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', mock_address_generator, ): with self.assertRaises(BadApiResponse): self.command( seed = Seed.random(), threshold = 72, )
def test_stop_threshold_zero(self): """ ``stop`` provided, ``threshold`` is 0. """ # Note that the first address has a zero balance. self.adapter.seed_response('getBalances', { 'balances': [0, 1], }) # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. mock_address_generator = mock.Mock( return_value=[self.addy0, self.addy1]) with mock.patch( 'iota.crypto.addresses.AddressGenerator.get_addresses', mock_address_generator, ): response = self.command( seed=Seed.random(), stop=2, threshold=0, ) self.assertEqual(response['totalBalance'], 1) self.assertEqual(len(response['inputs']), 1) # Address 0 was skipped because it has a zero balance. input0 = response['inputs'][0] self.assertIsInstance(input0, Address) self.assertEqual(input0, self.addy1) self.assertEqual(input0.balance, 1) self.assertEqual(input0.key_index, 1)
def test_generate_multiple_digests(self): """ Generating multiple digests. """ seed = Seed.random() mock_get_private_keys = \ mock.Mock(return_value={'keys': [self.key1, self.key2]}) with mock.patch( 'iota.multisig.commands.get_private_keys.GetPrivateKeysCommand._execute', mock_get_private_keys ): # noinspection PyUnresolvedReferences with mock.patch.object(self.key1, 'get_digest') as mock_get_digest_1: # type: mock.MagicMock mock_get_digest_1.return_value = self.digest1 # noinspection PyUnresolvedReferences with mock.patch.object(self.key2, 'get_digest') as mock_get_digest_2: # type: mock.MagicMock mock_get_digest_2.return_value = self.digest2 result = self.command(seed=seed, index=0, count=2, securityLevel=1) self.assertDictEqual(result, {'digests': [self.digest1, self.digest2]}) mock_get_private_keys.assert_called_once_with({ 'count': 2, 'index': 0, 'securityLevel': 1, 'seed': seed, })
def test_stdin_success(self): with self._capture_output_fixture() as stdout: with mock.patch("sys.stdin", mock.Mock( read=mock.Mock(return_value="hello world ${x}"))): cmdline(["--var", "x=5", "-"]) eq_(stdout.write.mock_calls[0][1][0], "hello world 5")
def test_generate_multiple_digests(self): """ Generating multiple digests. """ seed = Seed.random() mock_get_private_keys =\ mock.Mock(return_value={'keys': [self.key1, self.key2]}) with mock.patch( 'iota.multisig.commands.get_private_keys.GetPrivateKeysCommand._execute', mock_get_private_keys ): # noinspection PyUnresolvedReferences with mock.patch.object(self.key1, 'get_digest') as mock_get_digest_1: # type: mock.MagicMock mock_get_digest_1.return_value = self.digest1 # noinspection PyUnresolvedReferences with mock.patch.object(self.key2, 'get_digest') as mock_get_digest_2: # type: mock.MagicMock mock_get_digest_2.return_value = self.digest2 result = self.command(seed=seed, index=0, count=2, securityLevel=1) self.assertDictEqual(result, {'digests': [self.digest1, self.digest2]}) mock_get_private_keys.assert_called_once_with({ 'count': 2, 'index': 0, 'securityLevel': 1, 'seed': seed, })
def test_no_transactions(self): """ There are no transactions for the specified seed. """ # 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 [self.addy1][start::step]: yield addy self.adapter.seed_response( 'findTransactions', { 'duration': 1, 'hashes': [], }, ) with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', create_generator, ): response = self.command(seed=Seed.random()) self.assertDictEqual(response, {'bundles': []})
async def test_first_address_is_not_used(self): """ The very first address is not used. No address is returned. """ # Address 0 self.seed_unused_address() with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', self.mock_address_generator, ): self.assertEqual([], await self.get_all_used_addresses()) self.assertListEqual( self.adapter.requests, [ { 'command': 'findTransactions', 'addresses': [self.address0], }, { 'command': 'wereAddressesSpentFrom', 'addresses': [self.address0], }, ] )
async def test_transactions_are_considered_used(self): """ An address with a transaction is considered used. """ # Address 0 self.adapter.seed_response('findTransactions', { 'hashes': ['T' * 81], }) # Address 1 self.seed_unused_address() with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', self.mock_address_generator, ): self.assertEqual([self.address0], await self.get_all_used_addresses()) self.assertListEqual(self.adapter.requests, [ { 'command': 'findTransactions', 'addresses': [self.address0], }, { 'command': 'findTransactions', 'addresses': [self.address1], }, { 'command': 'wereAddressesSpentFrom', 'addresses': [self.address1], }, ])
async def test_generate_single_digest(self): """ Generating a single digest. """ seed = Seed.random() mock_get_private_keys = mock.Mock( return_value=async_return({'keys': [self.key1]})) with mock.patch( 'iota.multisig.commands.get_private_keys.GetPrivateKeysCommand._execute', mock_get_private_keys): with mock.patch.object( self.key1, 'get_digest') as mock_get_digest_1: # type: mock.MagicMock mock_get_digest_1.return_value = self.digest1 result = await self.command(seed=seed, index=0, count=1, securityLevel=1) self.assertDictEqual(result, {'digests': [self.digest1]}) mock_get_private_keys.assert_called_once_with({ 'count': 1, 'index': 0, 'securityLevel': 1, 'seed': seed, })
def test_stop_threshold_zero(self): """ ``stop`` provided, ``threshold`` is 0. """ # Note that the first address has a zero balance. self.adapter.seed_response('getBalances', { 'balances': [0, 1], }) # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. mock_address_generator = mock.Mock(return_value=[self.addy0, self.addy1]) with mock.patch( 'iota.crypto.addresses.AddressGenerator.get_addresses', mock_address_generator, ): response = self.command( seed = Seed.random(), stop = 2, threshold = 0, ) self.assertEqual(response['totalBalance'], 1) self.assertEqual(len(response['inputs']), 1) # Address 0 was skipped because it has a zero balance. input0 = response['inputs'][0] self.assertIsInstance(input0, Address) self.assertEqual(input0, self.addy1) self.assertEqual(input0.balance, 1) self.assertEqual(input0.key_index, 1)
def test_happy_path(self): """ Loading account data for an account. """ # noinspection PyUnusedLocal def mock_iter_used_addresses(adapter, seed, start): """ Mocks the ``iter_used_addresses`` function, so that we can simulate its functionality without actually connecting to the Tangle. References: - :py:func:`iota.commands.extended.utils.iter_used_addresses` """ yield self.addy1, [self.hash1] yield self.addy2, [self.hash2] mock_get_balances = mock.Mock(return_value={'balances': [42, 0]}) # Not particularly realistic, but good enough to prove that the # mocked function was invoked correctly. bundles = [Bundle(), Bundle()] mock_get_bundles_from_transaction_hashes = mock.Mock(return_value=bundles) with mock.patch( 'iota.commands.extended.get_account_data.iter_used_addresses', mock_iter_used_addresses, ): with mock.patch( 'iota.commands.extended.get_account_data.get_bundles_from_transaction_hashes', mock_get_bundles_from_transaction_hashes, ): with mock.patch( 'iota.commands.core.get_balances.GetBalancesCommand._execute', mock_get_balances, ): response = self.command(seed=Seed.random()) self.assertDictEqual( response, { 'addresses': [self.addy1, self.addy2], 'balance': 42, 'bundles': bundles, }, )
def test_start(self): """ Using ``start`` to offset the key range. """ # ``getInputs`` uses ``findTransactions`` and # ``wereAddressesSpentFrom`` to identify unused addresses. # noinspection SpellCheckingInspection self.adapter.seed_response( 'findTransactions', { 'hashes': [ TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION99999YFXGOD' b'GISBJAX9PDJIRDMDV9DCRDCAEG9FN9KECCBDDFZ9H'), ], }) self.adapter.seed_response('findTransactions', { 'hashes': [], }) self.adapter.seed_response('wereAddressesSpentFrom', { 'states': [False], }) self.adapter.seed_response('getBalances', { 'balances': [86], }) # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. # noinspection PyUnusedLocal def mock_address_generator(ag, start, step=1): # If ``start`` has the wrong value, return garbage to make the # test asplode. for addy in [None, self.addy1, self.addy2][start::step]: yield addy # When ``stop`` is None, the command uses a generator internally. with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', mock_address_generator, ): response = self.command( seed=Seed.random(), start=1, ) self.assertEqual(response['totalBalance'], 86) self.assertEqual(len(response['inputs']), 1) input0 = response['inputs'][0] self.assertIsInstance(input0, Address) self.assertEqual(input0, self.addy1) self.assertEqual(input0.balance, 86) self.assertEqual(input0.key_index, 1)
async def test_multiple_addresses_return(self): """ A larger test that combines multiple cases and more than one address should be returned. Address 0: Was spent from Address 1: Has a transaction Address 2: Is not used. Should not be returned """ # Address 0 self.adapter.seed_response('findTransactions', { 'hashes': [], }) self.adapter.seed_response('wereAddressesSpentFrom', { 'states': [True], }) # Address 1 self.adapter.seed_response('findTransactions', { 'hashes': ['T' * 81], }) # Address 2 self.seed_unused_address() with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', self.mock_address_generator, ): self.assertEqual([self.address0, self.address1], await self.get_all_used_addresses()) self.assertListEqual( self.adapter.requests, [ { 'command': 'findTransactions', 'addresses': [self.address0], }, { 'command': 'wereAddressesSpentFrom', 'addresses': [self.address0], }, { 'command': 'findTransactions', 'addresses': [self.address1], }, { 'command': 'findTransactions', 'addresses': [self.address2], }, { 'command': 'wereAddressesSpentFrom', 'addresses': [self.address2], }, ] )
def test_stdin_success(self): with self._capture_output_fixture() as stdout: with mock.patch( "sys.stdin", mock.Mock(read=mock.Mock(return_value="hello world ${x}")), ): cmdline(["--var", "x=5", "-"]) eq_(stdout.write.mock_calls[0][1][0], "hello world 5")
def test_stdin_rt_err(self): with mock.patch("sys.stdin", mock.Mock(read=mock.Mock(return_value="${q}"))): with self._capture_output_fixture("stderr") as stderr: with raises(SystemExit): cmdline(["--var", "x=5", "-"]) assert "NameError: Undefined" in stderr.write.mock_calls[0][1][0] assert "Traceback" in stderr.write.mock_calls[0][1][0]
def test_stdin_rt_err(self): with mock.patch("sys.stdin", mock.Mock( read=mock.Mock(return_value="${q}"))): with self._capture_output_fixture("stderr") as stderr: with raises(SystemExit): cmdline(["--var", "x=5", "-"]) assert "NameError: Undefined" in stderr.write.mock_calls[0][1][0] assert "Traceback" in stderr.write.mock_calls[0][1][0]
def test_stdin_syntax_err(self): with mock.patch("sys.stdin", mock.Mock( read=mock.Mock(return_value="${x"))): with self._capture_output_fixture("stderr") as stderr: with raises(SystemExit): cmdline(["--var", "x=5", "-"]) assert "SyntaxException: Expected" in \ stderr.write.mock_calls[0][1][0] assert "Traceback" in stderr.write.mock_calls[0][1][0]
def test_stdin_syntax_err(self): with mock.patch("sys.stdin", mock.Mock(read=mock.Mock(return_value="${x"))): with self._capture_output_fixture("stderr") as stderr: with raises(SystemExit): cmdline(["--var", "x=5", "-"]) assert "SyntaxException: Expected" in \ stderr.write.mock_calls[0][1][0] assert "Traceback" in stderr.write.mock_calls[0][1][0]
async def test_happy_path_no_inclusion(self): """ A bundle is successfully fetched without inclusion states. """ self.adapter.seed_response( 'getTrytes', { 'trytes': self.single_bundle.as_tryte_strings() } ) with mock.patch( 'iota.commands.core.get_inclusion_states.GetInclusionStatesCommand.__call__', MagicMock(return_value=async_return({'states': { self.single_bundle.tail_transaction.hash: True }})) ) as mocked_glis: with mock.patch( 'iota.commands.extended.get_bundles.GetBundlesCommand.__call__', MagicMock(return_value=async_return({'bundles': [self.single_bundle]})) ) as mocked_get_bundles: response = await get_bundles_from_transaction_hashes( adapter=self.adapter, transaction_hashes=[self.single_bundle.tail_transaction.hash], inclusion_states=False, ) self.assertListEqual( response, [self.single_bundle], ) self.assertFalse( mocked_glis.called ) mocked_get_bundles.assert_called_once_with( transactions=[self.single_bundle.tail_transaction.hash] ) self.assertFalse( response[0].is_confirmed )
def setUp(self): """Create mock objects for HTTP Handler.""" self._post = rpc.Handler.do_POST patcher = mock.patch('anaconda_mode.rpc.Handler', autospec=True) self.addCleanup(patcher.stop) self._handler = patcher.start() self._handler.rfile = mock.Mock() self._handler.wfile = mock.Mock()
def test_start(self): """ Using ``start`` to offset the key range. """ self.adapter.seed_response('getBalances', { 'balances': [86], }) # ``getInputs`` uses ``findTransactions`` to identify unused # addresses. # noinspection SpellCheckingInspection self.adapter.seed_response('findTransactions', { 'hashes': [ TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION99999YFXGOD' b'GISBJAX9PDJIRDMDV9DCRDCAEG9FN9KECCBDDFZ9H' ), ], }) self.adapter.seed_response('findTransactions', { 'hashes': [], }) # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. # noinspection PyUnusedLocal def mock_address_generator(ag, start, step=1): # If ``start`` has the wrong value, return garbage to make the # test asplode. for addy in [None, self.addy1, self.addy2][start::step]: yield addy # When ``stop`` is None, the command uses a generator internally. with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', mock_address_generator, ): response = self.command( seed = Seed.random(), start = 1, ) self.assertEqual(response['totalBalance'], 86) self.assertEqual(len(response['inputs']), 1) input0 = response['inputs'][0] self.assertIsInstance(input0, Address) self.assertEqual(input0, self.addy1) self.assertEqual(input0.balance, 86) self.assertEqual(input0.key_index, 1)
async def test_instance_attribute_timeout(self): # mock for returning dummy response mocked_request = mock.Mock(return_value=async_return( mock.Mock(text='{ "dummy": "payload"}', status_code=200))) # create adapter mock_payload = {'dummy': 'payload'} adapter = HttpAdapter('http://localhost:14265') # test with explicit attribute adapter.timeout = 77 with mock.patch('iota.adapter.AsyncClient.request', mocked_request): await adapter.send_request(payload=mock_payload) _, kwargs = mocked_request.call_args self.assertEqual(kwargs['timeout'], 77)
async def test_argument_overriding_init_timeout(self): # mock for returning dummy response mocked_request = mock.Mock(return_value=async_return( mock.Mock(text='{ "dummy": "payload"}', status_code=200))) # create adapter mock_payload = {'dummy': 'payload'} adapter = HttpAdapter('http://localhost:14265') # test with timeout at adapter creation adapter = HttpAdapter('http://localhost:14265', timeout=99) with mock.patch('iota.adapter.AsyncClient.request', mocked_request): await adapter.send_request(payload=mock_payload) _, kwargs = mocked_request.call_args self.assertEqual(kwargs['timeout'], 99)
def test_generate_single_key(self): """ Generating a single key. """ keys = [PrivateKey(self.trytes1, 0)] mock_get_keys = mock.Mock(return_value=keys) with mock.patch('iota.crypto.signing.KeyGenerator.get_keys', mock_get_keys): result = self.command(seed=Seed.random(), securityLevel=2) self.assertDictEqual(result, {'keys': keys}) mock_get_keys.assert_called_once_with( count=1, iterations=2, start=0, )
async def test_default_timeout(self): # create adapter mock_payload = {'dummy': 'payload'} adapter = HttpAdapter('http://localhost:14265') # mock for returning dummy response mocked_request = mock.Mock(return_value=async_return( mock.Mock(text='{ "dummy": "payload"}', status_code=200))) with mock.patch('iota.adapter.AsyncClient.request', mocked_request): # test with default timeout await adapter.send_request(payload=mock_payload) # Was the default timeout correctly injected into the request? _, kwargs = mocked_request.call_args self.assertEqual(kwargs['timeout'], socket.getdefaulttimeout())
def test_no_transactions_fround(self): """ No transaction is found with the inputs. An empty list is returned """ with mock.patch( 'iota.commands.core.get_trytes.GetTrytesCommand._execute', mock.Mock(return_value={'trytes': []}), ): response = self.command(hashes=[self.transaction_hash]) self.assertDictEqual( response, { 'transactions': [], }, )
def test_transaction_found(self): """ A transaction is found with the inputs. A transaction object is returned """ with mock.patch( 'iota.commands.core.get_trytes.GetTrytesCommand._execute', mock.Mock(return_value={'trytes': [ self.trytes, ]}), ): response = self.command(hashes=[self.transaction_hash]) self.assertEqual(len(response['transactions']), 1) transaction = response['transactions'][0] self.assertIsInstance(transaction, Transaction) self.assertEqual(transaction.hash, self.transaction_hash)
def test_no_transactions_fround(self): """ No transaction is found with the inputs. An empty list is returned """ with mock.patch( 'iota.commands.core.find_transactions.FindTransactionsCommand.' '_execute', mock.Mock(return_value={'hashes': []}), ): response = self.command(addresses=[self.address]) self.assertDictEqual( response, { 'transactions': [], }, )
def test_start_stop(self): """ Using ``start`` and ``stop`` at once. Checking if correct number of addresses is returned. Must be stop - start """ # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. # noinspection PyUnusedLocal def mock_address_generator(ag, start, step=1): # returning up to 3 addresses, depending on stop value for addy in [self.addy0, self.addy1, self.addy2][start::step]: yield addy self.adapter.seed_response('getBalances', { 'balances': [11, 11], }) with mock.patch( 'iota_async.crypto.addresses.AddressGenerator.create_iterator', mock_address_generator, ): response = self.command( seed=Seed.random(), start=1, stop=3, ) self.assertEqual(len(response['inputs']), 2) # 3 - 1 = 2 addresses expected self.assertEqual(response['totalBalance'], 22) input0 = response['inputs'][0] self.assertIsInstance(input0, Address) self.assertEqual(input0, self.addy1) self.assertEqual(input0.balance, 11) self.assertEqual(input0.key_index, 1) input1 = response['inputs'][1] self.assertIsInstance(input1, Address) self.assertEqual(input1, self.addy2) self.assertEqual(input1.balance, 11) self.assertEqual(input1.key_index, 2)
def test_happy_path(self): """ Successfully checking promotability. """ self.adapter.seed_response('checkConsistency', { 'state': True, }) self.adapter.seed_response('getTrytes', {'trytes': [self.trytes1, self.trytes2]}) with mock.patch('iota.commands.extended.is_promotable.get_current_ms', mock.MagicMock(return_value=self.valid_now)): response = self.command(tails=[self.hash1, self.hash2]) self.assertDictEqual(response, { 'promotable': True, })
def test_no_transactions(self): """ Loading account data for a seed that hasn't been used yet. """ with mock.patch( 'iota.commands.extended.get_account_data.iter_used_addresses', mock.Mock(return_value=[]), ): response = self.command(seed=Seed.random()) self.assertDictEqual( response, { 'addresses': [], 'balance': 0, 'bundles': [], }, )
def test_stop_no_threshold(self): """ ``stop`` provided, no ``threshold``. """ self.adapter.seed_response('getBalances', { 'balances': [42, 29], }) # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. mock_address_generator = mock.Mock( return_value=[self.addy0, self.addy1]) with mock.patch( 'iota.crypto.addresses.AddressGenerator.get_addresses', mock_address_generator, ): response = self.command( seed=Seed.random(), start=0, stop=2, ) self.assertEqual(response['totalBalance'], 71) self.assertEqual(len(response['inputs']), 2) input0 = response['inputs'][0] self.assertIsInstance(input0, Address) self.assertEqual(input0, self.addy0) self.assertEqual(input0.balance, 42) self.assertEqual(input0.key_index, 0) input1 = response['inputs'][1] self.assertIsInstance(input1, Address) self.assertEqual(input1, self.addy1) self.assertEqual(input1.balance, 29) self.assertEqual(input1.key_index, 1)
def test_stop_no_threshold(self): """ ``stop`` provided, no ``threshold``. """ self.adapter.seed_response('getBalances', { 'balances': [42, 29], }) # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. mock_address_generator = mock.Mock(return_value=[self.addy0, self.addy1]) with mock.patch( 'iota.crypto.addresses.AddressGenerator.get_addresses', mock_address_generator, ): response = self.command( seed = Seed.random(), start = 0, stop = 2, ) self.assertEqual(response['totalBalance'], 71) self.assertEqual(len(response['inputs']), 2) input0 = response['inputs'][0] self.assertIsInstance(input0, Address) self.assertEqual(input0, self.addy0) self.assertEqual(input0.balance, 42) self.assertEqual(input0.key_index, 0) input1 = response['inputs'][1] self.assertIsInstance(input1, Address) self.assertEqual(input1, self.addy1) self.assertEqual(input1.balance, 29) self.assertEqual(input1.key_index, 1)
def test_generate_multiple_keys(self): """ Generating multiple keys. """ keys = [PrivateKey(self.trytes1, 0), PrivateKey(self.trytes2, 1)] mock_get_keys = mock.Mock(return_value=keys) with mock.patch('iota_async.crypto.signing.KeyGenerator.get_keys', mock_get_keys): result =\ self.command( count = 2, index = 0, securityLevel = 1, seed = Seed.random(), ) self.assertDictEqual(result, {'keys': keys}) mock_get_keys.assert_called_once_with( count = 2, iterations = 1, start = 0, )
def test_stop_threshold_not_met(self): """ ``stop`` provided, balance does not meet ``threshold``. """ self.adapter.seed_response('getBalances', { 'balances': [42, 29], }) # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. mock_address_generator = mock.Mock(return_value=[self.addy0, self.addy1]) with mock.patch( 'iota.crypto.addresses.AddressGenerator.get_addresses', mock_address_generator, ): with self.assertRaises(BadApiResponse): self.command( seed = Seed.random(), stop = 2, threshold = 72, )
def test(self, date, timezone, sunday_offset, expected_result): self.set_timezone(timezone) with mock.patch("github_board.sunday_offset", mock.Mock(return_value=sunday_offset)): self.assertEqual(expected_result, board_origin(date))
def test_no_stop_no_threshold(self): """ No ``stop`` provided, no ``threshold``. """ self.adapter.seed_response('getBalances', { 'balances': [42, 29], }) # ``getInputs`` uses ``findTransactions`` to identify unused # addresses. # noinspection SpellCheckingInspection self.adapter.seed_response('findTransactions', { 'hashes': [ TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION99999WBL9KD' b'EIZDMEDFPEYDIIA9LEMEUCC9MFPBY9TEVCUGSEGGN' ), ], }) # noinspection SpellCheckingInspection self.adapter.seed_response('findTransactions', { 'hashes': [ TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION99999YFXGOD' b'GISBJAX9PDJIRDMDV9DCRDCAEG9FN9KECCBDDFZ9H' ), ], }) self.adapter.seed_response('findTransactions', { 'hashes': [], }) # To keep the unit test nice and speedy, we will mock the address # generator. We already have plenty of unit tests for that # functionality, so we can get away with mocking it here. # noinspection PyUnusedLocal def mock_address_generator(ag, start, step=1): for addy in [self.addy0, self.addy1, self.addy2][start::step]: yield addy # When ``stop`` is None, the command uses a generator internally. with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', mock_address_generator, ): response = self.command( seed = Seed.random(), ) self.assertEqual(response['totalBalance'], 71) self.assertEqual(len(response['inputs']), 2) input0 = response['inputs'][0] self.assertIsInstance(input0, Address) self.assertEqual(input0, self.addy0) self.assertEqual(input0.balance, 42) self.assertEqual(input0.key_index, 0) input1 = response['inputs'][1] self.assertIsInstance(input1, Address) self.assertEqual(input1, self.addy1) self.assertEqual(input1.balance, 29) self.assertEqual(input1.key_index, 1)
def test(self, template): with mock.patch("github_board.open", mock.mock_open(read_data=template), create=True): with mock.patch("github_board.pygit2.Repository.create_commit", mock.Mock()) as m: main("test@test", self.repo.path, template, None) self.assertEquals(sum([int(i) for i in template if i.isdigit()]), len(m.mock_calls))
def test(self, data, expected_result): with mock.patch("github_board.url_request.urlopen", mock.Mock(return_value=BytesIO(data))): self.assertSequenceEqual(expected_result, min_max_for_user("some_github_user"))
def test_get_inclusion_states(self): """ Fetching inclusion states with transactions. """ # noinspection PyUnusedLocal def create_generator(ag, start, step=1): for addy in [self.addy1][start::step]: yield addy # The first address received IOTA. self.adapter.seed_response( 'findTransactions', { 'duration': 42, 'hashes': [ 'TESTVALUEFIVE9DONTUSEINPRODUCTION99999VH' 'YHRHJETGYCAFZGABTEUBWCWAS9WF99UHBHRHLIOFJ', ], }, ) # For this test, we have to generate a real TryteString. transaction_trytes =\ TryteString( b'KMYUMNEUAYODAQSNGWTAERRRHNZBZCOLMVVOBTVWLOFYCJKYMGRAMH9RQ9MTZOSZMH' b'QNZFHFEJEDFQ99HSUNVOTULDJGXEDULS9ZHABVDZODJUMCNWVCPNSCUVKVYWCEXBHW' b'RBZBSWFPQLWZWMUPGQIGAEGOVE9DDXBVCIPKQYCFZFBELTSMVFSIXLPTACTKAFMCTK' b'CPYD9BWDJMLKWAOBDSJNQYAHS9GFIQKZCROLFZJVUEIVXVNBRRLEIWTYVHURUXHSCG' b'DKEIEGPOCXKCYWIBUG9ABYCALYJVFLBNGMS9ARHGTQXBZFLENXCJVKHPVKD9KSAEOL' b'FFVAJCNKLDVHOCDARWUNKARDYMVKFKRSMUTYOUXSBFFYTKRREBDJZTLVUROQFCBXQN' b'SXDDYTZTEBRSXOBMLXHJKSJAVOOVCXATOWNQDWHT9CCUAAJUJKDOQLMAEZACSNFKXZ' b'IGWDQEUEFRZYAOSDNVMSXWYLVDAUXZSHNHAIBEMNPFUGORYUETNJK9UCEMSUJYBBDK' b'BHIPKEINQCGOVYCPKUPJMUCUVZOJSIWYRFMFXYUVSMOUALAQBWIMXBUBXSAETGKJRP' b'AHVAXHQJDMEVSRFYEXUSIEBKMGYCUKFD9JPGUV9AIYUVCRUURKMYUHMVE9OJCYYWTQ' b'WUWFMTBZYFXASHHVCMSWXKBRQFHHQVEQMEULJRWZKLWFFSGGKEHUZZFNDNITSRAUH9' b'PQK9OGLYMVBSHXQLLZHOBBIM9KVUWDLHZRDKQQVLQXGWYXEEVQPDZUO9PVXMALOMRQ' b'VCTHGIZLILSCFKTBRESYZGBZKHXEODNDJZ9GK9ROWYXNGFHZCCBHHZEYEOGWXRGSUD' b'SUZFUAUBXVXZHCUVJSYBWTCYCEDYKZNGWFZYKSQLW9FUYMWDVXKZEWT9SCVMQCODZK' b'DRNKTINTPNOJOLGQJDAJMFWRFSWZJLYZGSTSIDSXLUJBZRZNLEDNBKAUNGTCYUPDRW' b'JOCEBQ9YG9IZLLRMJITISJOTLQMOGXVQIZXHMTJVMMWM9FOIOT9KFZMANEPOEOV9HX' b'JNEGURUKRWDGYNPVGAWMWQVABIJNL9MDXKONEPMYACOZ9BE9UZMAFTKYWPFWIQWAPK' b'GUXQTOQVWYYVZYGQDLBIQDVOZIWGOMGOBAUARICQZVNXD9UVEFBBAJKQBHRHXTBUOW' b'VBFKYQWZWTMMXVKZRIZUBVPQ9XHLJHFHWFZUIZVSNAKBDHDFGJCYQETOMEDTOXIUT9' b'OAJVIHWAGTCNPEZTERMMN9EZEWSJHKQAUMXPBZTNQOEQCVXIMAAYO9NIUFLTCFIMK9' b'9AFAGWJFA9VOFPUDJLRAMORGSUDBLWWKXEDZ9XPQUZSGANGESHKKGGQSGSYDCRLHZD' b'PKA9HKYBKLKKCXYRQQIPXCFETJJDZYPCLUNHGBKEJDRCIHEXKCQQNOV9QFHLGFXOCR' b'HPAFCUTPMY9NOZVQHROYJSCMGRSVMOBWADAZNFIAHWGIQUUZBOVODSFAUNRTXSDU9W' b'EIRBXQNRSJXFRAQGHA9DYOQJGLVZUJKAQ9CTUOTT9ZKQOQNNLJDUPDXZJYPRCVLRZT' b'UCZPNBREYCCKHK9FUWGITAJATFPUOFLZDHPNJYUTXFGNYJOBRD9BVHKZENFXIUYDTL' b'CE9JYIIYMXMCXMWTHOLTQFKFHDLVPGMQNITEUXSYLAQULCZOJVBIPYP9M9X9QCNKBX' b'W9DVJEQFFY9KQVMKNVTAHQVRXUKEM9FZOJLHAGEECZBUHOQFZOSPRXKZOCCKAOHMSV' b'QCFG9CWAHKVWNA9QTLYQI9NKOSHWJCNGPJBLEQPUIWJBIOAWKLBXUCERTSL9FVCLYN' b'ADPYTPKJOIEMAQGWBVGSRCZINXEJODUDCT9FHOUMQM9ZHRMBJYSOMPNMEAJGEHICJI' b'PVXRKCYX9RZVT9TDZIMXGZJAIYJRGIVMSOICSUINRBQILMJOUQYXCYNJ9WGGJFHYTU' b'LWOIPUXXFNTIFNOJRZFSQQNAWBQZOLHHLVGHEPWTKKQEVIPVWZUN9ZBICZ9DZZBVII' b'BF9EPHARZJUFJGBQXQFQIBUECAWRSEKYJNYKNSVBCOWTFBZ9NAHFSAMRBPEYGPRGKW' b'WTWACZOAPEOECUO9OTMGABJVAIICIPXGSXACVINSYEQFTRCQPCEJXZCY9XZWVWVJRZ' b'CYEYNFUUBKPWCHICGJZXKE9GSUDXZYUAPLHAKAHYHDXNPHENTERYMMBQOPSQIDENXK' b'LKCEYCPVTZQLEEJVYJZV9BWU999999999999999999999999999FFL999999999999' b'9999999999999RJQGVD99999999999A99999999USGBXHGJUEWAUAKNPPRHJXDDMQV' b'YDSYZJSDWFYLOQVFGBOSLE9KHFDLDYHUYTXVSFAFCOCLQUHJXTEIQRNBTLHEGJFGVF' b'DJCE9IKAOCSYHLCLWPVVNWNESKLYAJG9FGGZOFXCEYOTWLVIJUHGY9QCU9FMZJY999' b'9999HYBUYQKKRNAVDPVGYBTVDZ9SVQBLCCVLJTPEQWWOIG9CQZIFQKCROH9YHUCNJT' b'SYPBVZVBNESX999999D9TARGPQTNIYRZURQGVHCAWEDRBJIIEJIUZYENVE9LLJQMXH' b'GSUUYUCPSOWBCXVFDCHHAZUDC9LUODYWO' ) self.adapter.seed_response( 'getTrytes', { 'duration': 99, 'trytes': [binary_type(transaction_trytes)], }, ) transaction = Transaction.from_tryte_string(transaction_trytes) mock_get_bundles = mock.Mock(return_value={ 'bundles': [Bundle([transaction])], }) mock_get_latest_inclusion = mock.Mock(return_value={ 'states': { transaction.hash: True, }, }) with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', create_generator, ): with mock.patch( 'iota.commands.extended.get_bundles.GetBundlesCommand._execute', mock_get_bundles, ): with mock.patch( 'iota.commands.extended.get_latest_inclusion.GetLatestInclusionCommand._execute', mock_get_latest_inclusion, ): response = self.command( seed = Seed.random(), inclusionStates = True, # To keep the test focused, only retrieve a single # transaction. start = 0, stop = 1, ) bundle = response['bundles'][0] # type: Bundle self.assertTrue(bundle[0].is_confirmed)
def test_stop(self): """ Scanning the Tangle for all transfers, with stop index. """ # noinspection PyUnusedLocal def create_generator(ag, start, step=1): # Inject an invalid value into the generator, to ensure it is # skipped. for addy in [self.addy1, None][start::step]: yield addy # The first address received IOTA. self.adapter.seed_response( 'findTransactions', { 'duration': 42, 'hashes': [ 'TESTVALUEFIVE9DONTUSEINPRODUCTION99999VH' 'YHRHJETGYCAFZGABTEUBWCWAS9WF99UHBHRHLIOFJ', ], }, ) self.adapter.seed_response( 'getTrytes', { 'duration': 99, 'trytes': [''], }, ) bundle = Bundle([ Transaction( address = self.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, attachment_timestamp = 1483033814, attachment_timestamp_lower_bound = 12, attachment_timestamp_upper_bound = 0, nonce = None, ) ]) mock_get_bundles = mock.Mock(return_value={ 'bundles': [bundle], }) with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', create_generator, ): with mock.patch( 'iota.commands.extended.get_bundles.GetBundlesCommand._execute', mock_get_bundles, ): response = self.command(seed=Seed.random(), stop=1) self.assertDictEqual( response, { 'bundles': [bundle], }, )
def test_happy_path(self): """ Sending a transfer successfully. """ # noinspection SpellCheckingInspection transaction1 =\ TransactionTrytes( b'GYPRVHBEZOOFXSHQBLCYW9ICTCISLHDBNMMVYD9JJHQMPQCTIQAQTJNNNJ9IDXLRCC' b'OYOXYPCLR9PBEY9ORZIEPPDNTI9CQWYZUOTAVBXPSBOFEQAPFLWXSWUIUSJMSJIIIZ' b'WIKIRH9GCOEVZFKNXEVCUCIIWZQCQEUVRZOCMEL9AMGXJNMLJCIA9UWGRPPHCEOPTS' b'VPKPPPCMQXYBHMSODTWUOABPKWFFFQJHCBVYXLHEWPD9YUDFTGNCYAKQKVEZYRBQRB' b'XIAUX9SVEDUKGMTWQIYXRGSWYRK9SRONVGTW9YGHSZRIXWGPCCUCDRMAXBPDFVHSRY' b'WHGB9DQSQFQKSNICGPIPTRZINYRXQAFSWSEWIFRMSBMGTNYPRWFSOIIWWT9IDSELM9' b'JUOOWFNCCSHUSMGNROBFJX9JQ9XT9PKEGQYQAWAFPRVRRVQPUQBHLSNTEFCDKBWRCD' b'X9EYOBB9KPMTLNNQLADBDLZPRVBCKVCYQEOLARJYAGTBFR9QLPKZBOYWZQOVKCVYRG' b'YI9ZEFIQRKYXLJBZJDBJDJVQZCGYQMROVHNDBLGNLQODPUXFNTADDVYNZJUVPGB9LV' b'PJIYLAPBOEHPMRWUIAJXVQOEM9ROEYUOTNLXVVQEYRQWDTQGDLEYFIYNDPRAIXOZEB' b'CS9P99AZTQQLKEILEVXMSHBIDHLXKUOMMNFKPYHONKEYDCHMUNTTNRYVMMEYHPGASP' b'ZXASKRUPWQSHDMU9VPS99ZZ9SJJYFUJFFMFORBYDILBXCAVJDPDFHTTTIYOVGLRDYR' b'TKHXJORJVYRPTDH9ZCPZ9ZADXZFRSFPIQKWLBRNTWJHXTOAUOL9FVGTUMMPYGYICJD' b'XMOESEVDJWLMCVTJLPIEKBE9JTHDQWV9MRMEWFLPWGJFLUXI9BXPSVWCMUWLZSEWHB' b'DZKXOLYNOZAPOYLQVZAQMOHGTTQEUAOVKVRRGAHNGPUEKHFVPVCOYSJAWHZU9DRROH' b'BETBAFTATVAUGOEGCAYUXACLSSHHVYDHMDGJP9AUCLWLNTFEVGQGHQXSKEMVOVSKQE' b'EWHWZUDTYOBGCURRZSJZLFVQQAAYQO9TRLFFN9HTDQXBSPPJYXMNGLLBHOMNVXNOWE' b'IDMJVCLLDFHBDONQJCJVLBLCSMDOUQCKKCQJMGTSTHBXPXAMLMSXRIPUBMBAWBFNLH' b'LUJTRJLDERLZFUBUSMF999XNHLEEXEENQJNOFFPNPQ9PQICHSATPLZVMVIWLRTKYPI' b'XNFGYWOJSQDAXGFHKZPFLPXQEHCYEAGTIWIJEZTAVLNUMAFWGGLXMBNUQTOFCNLJTC' b'DMWVVZGVBSEBCPFSM99FLOIDTCLUGPSEDLOKZUAEVBLWNMODGZBWOVQT9DPFOTSKRA' b'BQAVOQ9RXWBMAKFYNDCZOJGTCIDMQSQQSODKDXTPFLNOKSIZEOY9HFUTLQRXQMEPGO' b'XQGLLPNSXAUCYPGZMNWMQWSWCKAQYKXJTWINSGPPZG9HLDLEAWUWEVCTVRCBDFOXKU' b'ROXH9HXXAXVPEJFRSLOGRVGYZASTEBAQNXJJROCYRTDPYFUIQJVDHAKEG9YACV9HCP' b'JUEUKOYFNWDXCCJBIFQKYOXGRDHVTHEQUMHO999999999999999999999999999999' b'999999999999999999999999999999999999999999999999999999999999999999' b'999999999999999999999999999999999999999999999999999999999999999999' b'999999999999999999999999999999999999999999999999999999999999999999' b'999999999999999999999999999999999999999999999999999999999999999999' b'999999999999999999999999999999999999999999999999999999999999999999' b'999999999999999999999999999999999999999999999999999999999999999999' b'999999999999999999999999999999999999999999999999999999999999999999' b'999999999999999999999999999999999999999999999999999999999999999999' b'999999999999999999999999999999999999999999999999999999999999999999' b'999999999999999999999999999999999999999999999999999999999999999999' b'999999999999RKWEEVD99A99999999A99999999NFDPEEZCWVYLKZGSLCQNOFUSENI' b'XRHWWTZFBXMPSQHEDFWZULBZFEOMNLRNIDQKDNNIELAOXOVMYEI9PGTKORV9IKTJZQ' b'UBQAWTKBKZ9NEZHBFIMCLV9TTNJNQZUIJDFPTTCTKBJRHAITVSKUCUEMD9M9SQJ999' b'999TKORV9IKTJZQUBQAWTKBKZ9NEZHBFIMCLV9TTNJNQZUIJDFPTTCTKBJRHAITVSK' b'UCUEMD9M9SQJ999999999999999999999999999999999999999999999999999999' b'999999999999999999999999999999999' ) mock_prepare_transfer =\ mock.Mock(return_value={ 'trytes': [transaction1], }) mock_send_trytes =\ mock.Mock(return_value={ 'trytes': [transaction1], }) with mock.patch( 'iota.commands.extended.prepare_transfer.PrepareTransferCommand._execute', mock_prepare_transfer, ): with mock.patch( 'iota.commands.extended.send_trytes.SendTrytesCommand._execute', mock_send_trytes, ): response = self.command( depth = 100, minWeightMagnitude = 18, seed = Seed.random(), transfers = [ ProposedTransaction( address = Address( b'9999999999999999999999999999999999999999' b'99999999999999999999999999999999999999999' ), value = 0, ), ], ) bundle = response['bundle'] # type: Bundle self.assertEqual(len(bundle), 1) self.assertEqual(bundle[0].as_tryte_string(), transaction1)
def test_full_scan(self): """ Scanning the Tangle for all transfers. """ # 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 [self.addy1, self.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 = self.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, attachment_timestamp = 1483033814, attachment_timestamp_lower_bound = 12, attachment_timestamp_upper_bound = 0, nonce = None, ) ]) mock_get_bundles =\ mock.Mock(return_value={ 'bundles': [bundle], }) with mock.patch( 'iota.crypto.addresses.AddressGenerator.create_iterator', create_generator, ): with mock.patch( 'iota.commands.extended.get_bundles.GetBundlesCommand._execute', mock_get_bundles, ): response = self.command(seed=Seed.random()) self.assertDictEqual( response, { 'bundles': [bundle], }, )
def _capture_output_fixture(self, stream="stdout"): with mock.patch("sys.%s" % stream) as stdout: yield stdout