electrum

Electrum Bitcoin wallet
git clone https://git.parazyd.org/electrum
Log | Files | Refs | Submodules

test_util.py (12638B)

      1 from decimal import Decimal
      2 
      3 from electrum.util import (format_satoshis, format_fee_satoshis, parse_URI,
      4                            is_hash256_str, chunks, is_ip_address, list_enabled_bits,
      5                            format_satoshis_plain, is_private_netaddress, is_hex_str,
      6                            is_integer, is_non_negative_integer, is_int_or_float,
      7                            is_non_negative_int_or_float)
      8 
      9 from . import ElectrumTestCase
     10 
     11 
     12 class TestUtil(ElectrumTestCase):
     13 
     14     def test_format_satoshis(self):
     15         self.assertEqual("0.00001234", format_satoshis(1234))
     16 
     17     def test_format_satoshis_negative(self):
     18         self.assertEqual("-0.00001234", format_satoshis(-1234))
     19 
     20     def test_format_satoshis_to_mbtc(self):
     21         self.assertEqual("0.01234", format_satoshis(1234, decimal_point=5))
     22 
     23     def test_format_satoshis_decimal(self):
     24         self.assertEqual("0.00001234", format_satoshis(Decimal(1234)))
     25 
     26     def test_format_fee_float(self):
     27         self.assertEqual("1.7", format_fee_satoshis(1700/1000))
     28 
     29     def test_format_fee_decimal(self):
     30         self.assertEqual("1.7", format_fee_satoshis(Decimal("1.7")))
     31 
     32     def test_format_fee_precision(self):
     33         self.assertEqual("1.666",
     34                          format_fee_satoshis(1666/1000, precision=6))
     35         self.assertEqual("1.7",
     36                          format_fee_satoshis(1666/1000, precision=1))
     37 
     38     def test_format_satoshis_whitespaces(self):
     39         self.assertEqual("     0.0001234 ",
     40                          format_satoshis(12340, whitespaces=True))
     41         self.assertEqual("     0.00001234",
     42                          format_satoshis(1234, whitespaces=True))
     43 
     44     def test_format_satoshis_whitespaces_negative(self):
     45         self.assertEqual("    -0.0001234 ",
     46                          format_satoshis(-12340, whitespaces=True))
     47         self.assertEqual("    -0.00001234",
     48                          format_satoshis(-1234, whitespaces=True))
     49 
     50     def test_format_satoshis_diff_positive(self):
     51         self.assertEqual("+0.00001234",
     52                          format_satoshis(1234, is_diff=True))
     53 
     54     def test_format_satoshis_diff_negative(self):
     55         self.assertEqual("-0.00001234", format_satoshis(-1234, is_diff=True))
     56 
     57     def test_format_satoshis_plain(self):
     58         self.assertEqual("0.00001234", format_satoshis_plain(1234))
     59 
     60     def test_format_satoshis_plain_decimal(self):
     61         self.assertEqual("0.00001234", format_satoshis_plain(Decimal(1234)))
     62 
     63     def test_format_satoshis_plain_to_mbtc(self):
     64         self.assertEqual("0.01234", format_satoshis_plain(1234, decimal_point=5))
     65 
     66     def _do_test_parse_URI(self, uri, expected):
     67         result = parse_URI(uri)
     68         self.assertEqual(expected, result)
     69 
     70     def test_parse_URI_address(self):
     71         self._do_test_parse_URI('bitcoin:15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma',
     72                                 {'address': '15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma'})
     73 
     74     def test_parse_URI_only_address(self):
     75         self._do_test_parse_URI('15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma',
     76                                 {'address': '15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma'})
     77 
     78 
     79     def test_parse_URI_address_label(self):
     80         self._do_test_parse_URI('bitcoin:15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma?label=electrum%20test',
     81                                 {'address': '15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma', 'label': 'electrum test'})
     82 
     83     def test_parse_URI_address_message(self):
     84         self._do_test_parse_URI('bitcoin:15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma?message=electrum%20test',
     85                                 {'address': '15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma', 'message': 'electrum test', 'memo': 'electrum test'})
     86 
     87     def test_parse_URI_address_amount(self):
     88         self._do_test_parse_URI('bitcoin:15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma?amount=0.0003',
     89                                 {'address': '15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma', 'amount': 30000})
     90 
     91     def test_parse_URI_address_request_url(self):
     92         self._do_test_parse_URI('bitcoin:15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma?r=http://domain.tld/page?h%3D2a8628fc2fbe',
     93                                 {'address': '15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma', 'r': 'http://domain.tld/page?h=2a8628fc2fbe'})
     94 
     95     def test_parse_URI_ignore_args(self):
     96         self._do_test_parse_URI('bitcoin:15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma?test=test',
     97                                 {'address': '15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma', 'test': 'test'})
     98 
     99     def test_parse_URI_multiple_args(self):
    100         self._do_test_parse_URI('bitcoin:15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma?amount=0.00004&label=electrum-test&message=electrum%20test&test=none&r=http://domain.tld/page',
    101                                 {'address': '15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma', 'amount': 4000, 'label': 'electrum-test', 'message': u'electrum test', 'memo': u'electrum test', 'r': 'http://domain.tld/page', 'test': 'none'})
    102 
    103     def test_parse_URI_no_address_request_url(self):
    104         self._do_test_parse_URI('bitcoin:?r=http://domain.tld/page?h%3D2a8628fc2fbe',
    105                                 {'r': 'http://domain.tld/page?h=2a8628fc2fbe'})
    106 
    107     def test_parse_URI_invalid_address(self):
    108         self.assertRaises(BaseException, parse_URI, 'bitcoin:invalidaddress')
    109 
    110     def test_parse_URI_invalid(self):
    111         self.assertRaises(BaseException, parse_URI, 'notbitcoin:15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma')
    112 
    113     def test_parse_URI_parameter_polution(self):
    114         self.assertRaises(Exception, parse_URI, 'bitcoin:15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma?amount=0.0003&label=test&amount=30.0')
    115 
    116     def test_is_hash256_str(self):
    117         self.assertTrue(is_hash256_str('09a4c03e3bdf83bbe3955f907ee52da4fc12f4813d459bc75228b64ad08617c7'))
    118         self.assertTrue(is_hash256_str('2A5C3F4062E4F2FCCE7A1C7B4310CB647B327409F580F4ED72CB8FC0B1804DFA'))
    119         self.assertTrue(is_hash256_str('00' * 32))
    120 
    121         self.assertFalse(is_hash256_str('00' * 33))
    122         self.assertFalse(is_hash256_str('qweqwe'))
    123         self.assertFalse(is_hash256_str(None))
    124         self.assertFalse(is_hash256_str(7))
    125 
    126     def test_is_hex_str(self):
    127         self.assertTrue(is_hex_str('09a4'))
    128         self.assertTrue(is_hex_str('abCD'))
    129         self.assertTrue(is_hex_str('2A5C3F4062E4F2FCCE7A1C7B4310CB647B327409F580F4ED72CB8FC0B1804DFA'))
    130         self.assertTrue(is_hex_str('00' * 33))
    131 
    132         self.assertFalse(is_hex_str('0x09a4'))
    133         self.assertFalse(is_hex_str('2A 5C3F'))
    134         self.assertFalse(is_hex_str(' 2A5C3F'))
    135         self.assertFalse(is_hex_str('2A5C3F '))
    136         self.assertFalse(is_hex_str('000'))
    137         self.assertFalse(is_hex_str('123'))
    138         self.assertFalse(is_hex_str('0x123'))
    139         self.assertFalse(is_hex_str('qweqwe'))
    140         self.assertFalse(is_hex_str(b'09a4'))
    141         self.assertFalse(is_hex_str(b'\x09\xa4'))
    142         self.assertFalse(is_hex_str(None))
    143         self.assertFalse(is_hex_str(7))
    144         self.assertFalse(is_hex_str(7.2))
    145 
    146     def test_is_integer(self):
    147         self.assertTrue(is_integer(7))
    148         self.assertTrue(is_integer(0))
    149         self.assertTrue(is_integer(-1))
    150         self.assertTrue(is_integer(-7))
    151 
    152         self.assertFalse(is_integer(Decimal("2.0")))
    153         self.assertFalse(is_integer(Decimal(2.0)))
    154         self.assertFalse(is_integer(Decimal(2)))
    155         self.assertFalse(is_integer(0.72))
    156         self.assertFalse(is_integer(2.0))
    157         self.assertFalse(is_integer(-2.0))
    158         self.assertFalse(is_integer('09a4'))
    159         self.assertFalse(is_integer('2A5C3F4062E4F2FCCE7A1C7B4310CB647B327409F580F4ED72CB8FC0B1804DFA'))
    160         self.assertFalse(is_integer('000'))
    161         self.assertFalse(is_integer('qweqwe'))
    162         self.assertFalse(is_integer(None))
    163 
    164     def test_is_non_negative_integer(self):
    165         self.assertTrue(is_non_negative_integer(7))
    166         self.assertTrue(is_non_negative_integer(0))
    167 
    168         self.assertFalse(is_non_negative_integer(Decimal("2.0")))
    169         self.assertFalse(is_non_negative_integer(Decimal(2.0)))
    170         self.assertFalse(is_non_negative_integer(Decimal(2)))
    171         self.assertFalse(is_non_negative_integer(0.72))
    172         self.assertFalse(is_non_negative_integer(2.0))
    173         self.assertFalse(is_non_negative_integer(-2.0))
    174         self.assertFalse(is_non_negative_integer(-1))
    175         self.assertFalse(is_non_negative_integer(-7))
    176         self.assertFalse(is_non_negative_integer('09a4'))
    177         self.assertFalse(is_non_negative_integer('2A5C3F4062E4F2FCCE7A1C7B4310CB647B327409F580F4ED72CB8FC0B1804DFA'))
    178         self.assertFalse(is_non_negative_integer('000'))
    179         self.assertFalse(is_non_negative_integer('qweqwe'))
    180         self.assertFalse(is_non_negative_integer(None))
    181 
    182     def test_is_int_or_float(self):
    183         self.assertTrue(is_int_or_float(7))
    184         self.assertTrue(is_int_or_float(0))
    185         self.assertTrue(is_int_or_float(-1))
    186         self.assertTrue(is_int_or_float(-7))
    187         self.assertTrue(is_int_or_float(0.72))
    188         self.assertTrue(is_int_or_float(2.0))
    189         self.assertTrue(is_int_or_float(-2.0))
    190 
    191         self.assertFalse(is_int_or_float(Decimal("2.0")))
    192         self.assertFalse(is_int_or_float(Decimal(2.0)))
    193         self.assertFalse(is_int_or_float(Decimal(2)))
    194         self.assertFalse(is_int_or_float('09a4'))
    195         self.assertFalse(is_int_or_float('2A5C3F4062E4F2FCCE7A1C7B4310CB647B327409F580F4ED72CB8FC0B1804DFA'))
    196         self.assertFalse(is_int_or_float('000'))
    197         self.assertFalse(is_int_or_float('qweqwe'))
    198         self.assertFalse(is_int_or_float(None))
    199 
    200     def test_is_non_negative_int_or_float(self):
    201         self.assertTrue(is_non_negative_int_or_float(7))
    202         self.assertTrue(is_non_negative_int_or_float(0))
    203         self.assertTrue(is_non_negative_int_or_float(0.0))
    204         self.assertTrue(is_non_negative_int_or_float(0.72))
    205         self.assertTrue(is_non_negative_int_or_float(2.0))
    206 
    207         self.assertFalse(is_non_negative_int_or_float(-1))
    208         self.assertFalse(is_non_negative_int_or_float(-7))
    209         self.assertFalse(is_non_negative_int_or_float(-2.0))
    210         self.assertFalse(is_non_negative_int_or_float(Decimal("2.0")))
    211         self.assertFalse(is_non_negative_int_or_float(Decimal(2.0)))
    212         self.assertFalse(is_non_negative_int_or_float(Decimal(2)))
    213         self.assertFalse(is_non_negative_int_or_float('09a4'))
    214         self.assertFalse(is_non_negative_int_or_float('2A5C3F4062E4F2FCCE7A1C7B4310CB647B327409F580F4ED72CB8FC0B1804DFA'))
    215         self.assertFalse(is_non_negative_int_or_float('000'))
    216         self.assertFalse(is_non_negative_int_or_float('qweqwe'))
    217         self.assertFalse(is_non_negative_int_or_float(None))
    218 
    219     def test_chunks(self):
    220         self.assertEqual([[1, 2], [3, 4], [5]],
    221                          list(chunks([1, 2, 3, 4, 5], 2)))
    222         self.assertEqual([], list(chunks(b'', 64)))
    223         self.assertEqual([b'12', b'34', b'56'],
    224                          list(chunks(b'123456', 2)))
    225         with self.assertRaises(ValueError):
    226             list(chunks([1, 2, 3], 0))
    227 
    228     def test_list_enabled_bits(self):
    229         self.assertEqual((0, 2, 3, 6), list_enabled_bits(77))
    230         self.assertEqual((), list_enabled_bits(0))
    231 
    232     def test_is_ip_address(self):
    233         self.assertTrue(is_ip_address("127.0.0.1"))
    234         self.assertTrue(is_ip_address("127.000.000.1"))
    235         self.assertTrue(is_ip_address("255.255.255.255"))
    236         self.assertFalse(is_ip_address("255.255.256.255"))
    237         self.assertFalse(is_ip_address("123.456.789.000"))
    238         self.assertTrue(is_ip_address("2001:0db8:0000:0000:0000:ff00:0042:8329"))
    239         self.assertTrue(is_ip_address("2001:db8:0:0:0:ff00:42:8329"))
    240         self.assertTrue(is_ip_address("2001:db8::ff00:42:8329"))
    241         self.assertFalse(is_ip_address("2001:::db8::ff00:42:8329"))
    242         self.assertTrue(is_ip_address("::1"))
    243         self.assertFalse(is_ip_address("2001:db8:0:0:g:ff00:42:8329"))
    244         self.assertFalse(is_ip_address("lol"))
    245         self.assertFalse(is_ip_address(":@ASD:@AS\x77\x22\xff¬!"))
    246 
    247     def test_is_private_netaddress(self):
    248         self.assertTrue(is_private_netaddress("127.0.0.1"))
    249         self.assertTrue(is_private_netaddress("127.5.6.7"))
    250         self.assertTrue(is_private_netaddress("::1"))
    251         self.assertTrue(is_private_netaddress("[::1]"))
    252         self.assertTrue(is_private_netaddress("localhost"))
    253         self.assertTrue(is_private_netaddress("localhost."))
    254         self.assertFalse(is_private_netaddress("[::2]"))
    255         self.assertFalse(is_private_netaddress("2a00:1450:400e:80d::200e"))
    256         self.assertFalse(is_private_netaddress("[2a00:1450:400e:80d::200e]"))
    257         self.assertFalse(is_private_netaddress("8.8.8.8"))
    258         self.assertFalse(is_private_netaddress("example.com"))