def test_single_transaction(self): """ Getting a bundle that contains a single transaction. """ transaction = \ Transaction( current_index=0, last_index=0, tag=Tag(b''), timestamp=1484960990, value=0, attachment_timestamp=1484960990, attachment_timestamp_lower_bound=12, attachment_timestamp_upper_bound=0, # These values are not relevant for 0-value transactions. nonce=Nonce(b''), signature_message_fragment=Fragment(b''), # This value is computed automatically, so it has to be real. hash_=TransactionHash( b'XPJIYZWPF9LBCYZPNBFARDRCSUGJGF9TWZT9K9PX' b'VYDFPZOZBGXUCKLTJEUCFBEKQQ9VCSQVQDMMJQAY9', ), address=Address( b'TESTVALUE9DONTUSEINPRODUCTION99999OCSGVF' b'IBQA99KGTCPCZ9NHR9VGLGADDDIEGGPCGBDEDDTBC', ), bundle_hash=BundleHash( b'TESTVALUE9DONTUSEINPRODUCTION99999DIOAZD' b'M9AIUHXGVGBC9EMGI9SBVBAIXCBFJ9EELCPDRAD9U', ), branch_transaction_hash=TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION99999BBCEDI' b'ZHUDWBYDJEXHHAKDOCKEKDFIMB9AMCLFW9NBDEOFV', ), trunk_transaction_hash=TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION999999ARAYA' b'MHCB9DCFEIWEWDLBCDN9LCCBQBKGDDAECFIAAGDAS', ), ) self.adapter.seed_response('getTrytes', { 'trytes': [transaction.as_tryte_string()], }) response = self.command(transaction=transaction.hash) bundle = response['bundles'][0] # type: Bundle self.assertEqual(len(bundle), 1) self.maxDiff = None self.assertDictEqual( bundle[0].as_json_compatible(), transaction.as_json_compatible(), )
def setUp(self): super(CheckConsistencyCommandTestCase, self).setUp() self.adapter = MockAdapter() self.command = CheckConsistencyCommand(self.adapter) # Define some tryte sequences that we can re-use across tests. self.milestone =\ TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION99999W9KDIH' b'BALAYAFCADIDU9HCXDKIXEYDNFRAKHN9IEIDZFWGJ' ) print_var_type_n_val( var001=self.milestone, pointer="#SDFGhgfd1234598764444") #SDFGhgfd1234598764444 # Value: TESTVALUE9DONTUSEINPRODUCTION99999W9KDIHBALAYAFCADIDU9HCXDKIXEYDNFRAKHN9IEIDZFWGJ # Type: <class 'iota.transaction.types.TransactionHash'> self.hash1 =\ TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION99999TBPDM9' b'ADFAWCKCSFUALFGETFIFG9UHIEFE9AYESEHDUBDDF' ) self.hash2 =\ TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION99999CIGCCF' b'KIUFZF9EP9YEYGQAIEXDTEAAUGAEWBBASHYCWBHDX' ) print_var_type_n_val( var001=self.hash2, pointer="#SDFGDFERTRTRnnnnbc1111") #SDFGDFERTRTRnnnnbc1111
def test_search_results(self): """ The incoming response contains lots of hashes. """ filter_ = self._filter({ 'hashes': [ 'RVORZ9SIIP9RCYMREUIXXVPQIPHVCNPQ9HZWYKFW' 'YWZRE9JQKG9REPKIASHUUECPSQO9JT9XNMVKWYGVA', 'ZJVYUGTDRPDYFGFXMKOTV9ZWSGFK9CFPXTITQLQN' 'LPPG9YNAARMKNKYQO9GSCSBIOTGMLJUFLZWSY9999', ], }) self.assertFilterPasses(filter_) self.assertDictEqual( filter_.cleaned_data, { 'hashes': [ TransactionHash( b'RVORZ9SIIP9RCYMREUIXXVPQIPHVCNPQ9HZWYKFW' b'YWZRE9JQKG9REPKIASHUUECPSQO9JT9XNMVKWYGVA', ), TransactionHash( b'ZJVYUGTDRPDYFGFXMKOTV9ZWSGFK9CFPXTITQLQN' b'LPPG9YNAARMKNKYQO9GSCSBIOTGMLJUFLZWSY9999', ), ], }, )
def test_get_approvee(self): key = iota.TransactionHash( b'UNUK99RCIWLUQ9WMUT9MPQSZCHTUMGN9IWOCOXWMNPICCCQKLLNIIE9UIFGKZLHRI9QAOEQXQJLL99999' ) value = list(self.provider.get(key, 'approvee')) expect = [ TransactionHash( b'YUPJOZMOSVIEQZXSVTLSYMIGMLFGDBPSZUTRAML9MIQNCLCMPOGFRAYLSFJUDBJBFDGESTIAFGZR99999' ), TransactionHash( b'ELIWEYAYXYEFOWBHJMELTKVERQWTJF9RXRLISNNQQVWGS9EMYYBVWRJYVJUYAPBGDQNYQEZOPBXWA9999' ), ] self.assertEqual(Counter(value), Counter(expect)) # Bad self.assertFalse( list( self.provider.get( iota.TryteString('9' * (iota.Hash.LEN - 1) + 'A'), 'approvee'))) self.assertFalse( list(self.provider.get(iota.TransactionHash('FOOBAR'), 'approvee'))) with self.assertRaises(ValueError): self.assertIsNone( self.provider.get(iota.TryteString('FOOBAR'), 'approvee')) with self.assertRaises(TypeError): self.provider.get('', 'approvee')
def test_get_bundle(self): key = iota.BundleHash( b'9ZMDWNXOJUEQQGBFHFPLIXLFBVFP9QIEJQGCD9B9NOAWBHHTCUDECJ9LSDUVP9YBIZGAKHANXBYQTADEZ' ) value = list(self.provider.get(key, 'bundle')) expect = [ TransactionHash( b'9KTTGBWZWKMGY9OTVFCRKUJTMOSRPNDDYKSWJENSH9MBQU9VKLVCWQPPULJHAYYM9JEMTYDTNTI9Z9999' ), TransactionHash( b'HDLRDWIYLHDEOXEMCIVQOOLOGFEBUDHTRRDRLLDIYQUFPSNCUYRQBRUPB9DWLQWCBYVXTBFYFPYGZ9999' ), TransactionHash( b'INLMRLGUURIAVIKCBUCBNEALFLVHFRGWPKUBBEFKOMFRROCSDGXSTWXRBHOXERJKDCURA9LJUHIN99999' ) ] self.assertEqual(Counter(value), Counter(expect)) # Bad self.assertFalse( list( self.provider.get( iota.TryteString('9' * (iota.Hash.LEN - 1) + 'A'), 'bundle'))) self.assertFalse( list(self.provider.get(iota.BundleHash('FOOBAR'), 'bundle'))) with self.assertRaises(ValueError): self.assertIsNone( self.provider.get(iota.TryteString('FOOBAR'), 'bundle')) with self.assertRaises(TypeError): self.provider.get('', 'bundle')
def test_pass_happy_path(self): """ Typical ``getTransactionsToApprove`` response. """ response = { 'trunkTransaction': 'TKGDZ9GEI9CPNQGHEATIISAKYPPPSXVCXBSR9EIW' 'CTHHSSEQCD9YLDPEXYERCNJVASRGWMAVKFQTC9999', 'branchTransaction': 'TKGDZ9GEI9CPNQGHEATIISAKYPPPSXVCXBSR9EIW' 'CTHHSSEQCD9YLDPEXYERCNJVASRGWMAVKFQTC9999', 'duration': 936, } filter_ = self._filter(response) self.assertFilterPasses(filter_) self.assertDictEqual( filter_.cleaned_data, { 'trunkTransaction': TransactionHash(b'TKGDZ9GEI9CPNQGHEATIISAKYPPPSXVCXBSR9EIW' b'CTHHSSEQCD9YLDPEXYERCNJVASRGWMAVKFQTC9999'), 'branchTransaction': TransactionHash(b'TKGDZ9GEI9CPNQGHEATIISAKYPPPSXVCXBSR9EIW' b'CTHHSSEQCD9YLDPEXYERCNJVASRGWMAVKFQTC9999'), 'duration': 936, }, )
def test_pass_compatible_types(self): """ The request contains values that can be converted to expected types. """ filter_ = self._filter({ 'transactions': [ binary_type(self.trytes1), bytearray(self.trytes2), ], 'tips': [ binary_type(self.trytes1), bytearray(self.trytes2), ], }) self.assertFilterPasses(filter_) self.assertDictEqual( filter_.cleaned_data, { 'transactions': [ TransactionHash(self.trytes1), TransactionHash(self.trytes2), ], 'tips': [ TransactionHash(self.trytes1), TransactionHash(self.trytes2), ], }, )
def test_fail_unexpected_parameters(self): """ The incoming request contains unexpected parameters. """ print_var_type_n_val(var001 = f.FilterMapper, pointer = "#SDFGbvc1234gd78")#SDFGbvc1234gd78 # Value: # # <class 'filters.complex.FilterMapper'> # Type: <class 'filters.base.FilterMeta'> print_var_type_n_val(var001 = f.FilterMapper.CODE_EXTRA_KEY, pointer = "#SDF345fds2345fd")#SDF345fds2345fd # Value: unexpected # Type: <class 'str'> self.assertFilterErrors( { 'branchTransaction': TransactionHash(self.txn_id), 'minWeightMagnitude': 20, 'trunkTransaction': TransactionHash(self.txn_id), 'trytes': [TryteString(self.trytes1)], # Hey, how'd that get in there? 'foo': 'bar', }, { 'foo': [f.FilterMapper.CODE_EXTRA_KEY], }, )
def test_pass_all_parameters(self): """ The request contains valid values for all parameters. """ request = { 'bundles': [ TransactionHash(self.trytes1), TransactionHash(self.trytes2), ], 'addresses': [ Address(self.trytes1), Address(self.trytes2), ], 'tags': [ Tag(self.trytes1), Tag(self.trytes3), ], 'approvees': [ TransactionHash(self.trytes1), TransactionHash(self.trytes3), ], } filter_ = self._filter(request) self.assertFilterPasses(filter_) self.assertDictEqual(filter_.cleaned_data, request)
def test_pass_approvees_only(self): """ The request only includes approvees. """ request = { 'approvees': [ TransactionHash(self.trytes1), TransactionHash(self.trytes3), ], } filter_ = self._filter(request) self.assertFilterPasses(filter_) self.assertDictEqual( filter_.cleaned_data, { 'approvees': [ text_type(TransactionHash(self.trytes1)), text_type(TransactionHash(self.trytes3)), ], 'addresses': [], 'bundles': [], 'tags': [], }, )
def test_fail_trunk_transaction_wrong_type(self): """ ``trunkTransaction`` can't be converted to a TryteString. """ print_var_type_n_val(var001 = TransactionHash(self.txn_id), pointer = "#23456gfdWXCVBnnnnn12555")#23456gfdWXCVBnnnnn12555 # Value: JVMTDGDPDFYHMZPMWEKKANBQSLSDTIIHAYQUMZOKHXXXGJHJDQPOMDOMNRDKYCZRUFZROZDADTHZC9999 # Type: <class 'iota.transaction.types.TransactionHash'> print_var_type_n_val(var001 = self.txn_id, pointer = "#XCRDF23454bbbfgg")#XCRDF23454bbbfgg # Value: JVMTDGDPDFYHMZPMWEKKANBQSLSDTIIHAYQUMZOKHXXXGJHJDQPOMDOMNRDKYCZRUFZROZDADTHZC9999 # Type: <class 'str'> self.assertFilterErrors( { # What do you get when you multiply 0-+ by 00+? 'trunkTransaction': 42, 'branchTransaction': TransactionHash(self.txn_id), 'minWeightMagnitude': 13, 'trytes': [TryteString(self.trytes1)], }, { 'trunkTransaction': [f.Type.CODE_WRONG_TYPE], }, )
def test_pass_approvees_only(self): """ The request only includes approvees. """ request = { 'approvees': [ TransactionHash(self.trytes1), TransactionHash(self.trytes3), ], } filter_ = self._filter(request) self.assertFilterPasses(filter_) self.assertDictEqual( filter_.cleaned_data, { 'approvees': [ text_type(TransactionHash(self.trytes1)), text_type(TransactionHash(self.trytes3)), ], # Null criteria are not included in the request. # https://github.com/iotaledger/iota.lib.py/issues/96 # 'addresses': [], # 'bundles': [], # 'tags': [], }, )
def test_pass_all_parameters(self): """ The request contains valid values for all parameters. """ # Raw trytes are extracted to match the IRI's JSON protocol. request = { 'bundles': [ text_type(BundleHash(self.trytes1)), text_type(BundleHash(self.trytes2)), ], 'addresses': [ text_type(Address(self.trytes1)), text_type(Address(self.trytes2)), ], 'tags': [ text_type(Tag(self.trytes1)), text_type(Tag(self.trytes3)), ], 'approvees': [ text_type(TransactionHash(self.trytes1)), text_type(TransactionHash(self.trytes3)), ], } filter_ = self._filter(request) self.assertFilterPasses(filter_) self.assertDictEqual(filter_.cleaned_data, request)
def test_get_transaction_metadata(self): key = iota.TransactionHash('PZYRMRVTSPQXNEQIQEBAGINMDAKOHPOLNH9LR9DTFWMWFQICXL9BJCWBUPMKZERKYKBDRIBYEJYH99999') value = self.provider.get(key, 'transaction_metadata') expect = {'address': iota.Address(b'9TPHVCFLAZTZSDUWFBLCJOZICJKKPVDMAASWJZNFFBKRDDTEOUJHR9JVGTJNI9IYNVISZVXARWJFKUZWC'), 'bundle_hash': iota.BundleHash(b'VLQUIJHXNWAINTXQNEQHNIASGSPYPOTNMQCM9RJPETERGLWIIKRLBZSCGPDYSFNZQ9FT9ZMQXZXNITRAC'), 'trunk_transaction_hash': TransactionHash(b'KTTHXMASNRQOSGZOW9ODAOBQFXKMPKNKWLIWDBVWJGMKQUBBPX9WHCYXCWEAHVTNZHPDKUWHOWN9Z9999'), 'branch_transaction_hash': TransactionHash(b'J9ZMRIJXZOZRNDHKOUBQGHPAPHQ9QOXFEEVQMJBMBOHKEVNUHJTEMRD9W9UDYMTGQ9ENQKDTJMJN99999'), 'legacy_tag': iota.Hash(b'EXAMPLEPYTHONLIB99999999999999999999999999999999999999999999999999999999999999999'), 'value': 0, 'current_index': 0, 'last_index': 0, 'timestamp': 1508993982, 'tag': iota.Hash(b'EXAMPLEPYTHONLIB99999999999999999999999999999999999999999999999999999999999999999'), 'attachment_timestamp': 1508993991533, 'attachment_timestamp_lower_bound': 0, 'attachment_timestamp_upper_bound': 12, 'validity': 1, 'type': -1, 'height': 0, 'solid': True} self.assertIsInstance(value, dict) self.assertEqual(value['solid'], True) for k in expect: self.assertEqual(value[k], expect[k], '"%s" different' % k)
def setUp(self): super(GetAccountDataCommandTestCase, self).setUp() self.adapter = MockAdapter() self.command = GetAccountDataCommand(self.adapter) # Define some tryte sequences we can re-use between tests. self.addy1 = \ Address( b'TESTVALUEONE9DONTUSEINPRODUCTION99999YDZ' b'E9TAFAJGJA9CECKDAEPHBICDR9LHFCOFRBQDHC9IG', key_index=0, ) self.addy2 = \ Address( b'TESTVALUETWO9DONTUSEINPRODUCTION99999TES' b'GINEIDLEEHRAOGEBMDLENFDAFCHEIHZ9EBZDD9YHL', key_index=1, ) self.hash1 = \ TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION99999O99IDB' b'MBPAPDXBSDWAMHV9DASEGCOGHBV9VAF9UGRHFDPFJ' ) self.hash2 = \ TransactionHash( b'TESTVALUE9DONTUSEINPRODUCTION99999OCNCHC' b'TEPBHEPBJEWFXERHSCQCH9TAAANDBBCCHCIDEAVBV' )
def test_fail_trytes_contents_invalid(self): """ ``trytes`` is an array, but it contains invalid values. """ self.assertFilterErrors( { 'trytes': [ b'', True, None, b'not valid trytes', # This is actually valid; I just added it to make sure the # filter isn't cheating! TryteString(self.trytes2), 2130706433, b'9' * (TransactionTrytes.LEN + 1), ], 'branchTransaction': TransactionHash(self.txn_id), 'minWeightMagnitude': 13, 'trunkTransaction': TransactionHash(self.txn_id), }, { 'trytes.0': [f.NotEmpty.CODE_EMPTY], 'trytes.1': [f.Type.CODE_WRONG_TYPE], 'trytes.2': [f.Required.CODE_EMPTY], 'trytes.3': [Trytes.CODE_NOT_TRYTES], 'trytes.5': [f.Type.CODE_WRONG_TYPE], 'trytes.6': [Trytes.CODE_WRONG_FORMAT], }, )
def test_pass_compatible_types(self): """ The request contains values that can be converted to the expected types. """ filter_ = self._filter({ 'bundles': [ self.trytes1.encode('ascii'), BundleHash(self.trytes2), ], 'addresses': [ self.trytes1.encode('ascii'), Address(self.trytes2), ], 'tags': [ self.trytes1.encode('ascii'), Tag(self.trytes3), ], 'approvees': [ self.trytes1.encode('ascii'), TransactionHash(self.trytes3), ], }) self.assertFilterPasses(filter_) self.assertDictEqual( filter_.cleaned_data, { # Raw trytes are extracted to match the IRI's JSON protocol. 'bundles': [ text_type(BundleHash(self.trytes1)), text_type(BundleHash(self.trytes2)), ], 'addresses': [ text_type(Address(self.trytes1)), text_type(Address(self.trytes2)), ], 'tags': [ text_type(Tag(self.trytes1)), text_type(Tag(self.trytes3)), ], 'approvees': [ text_type(TransactionHash(self.trytes1)), text_type(TransactionHash(self.trytes3)), ], }, )
def test_pass_compatible_types(self): """ The request contains values that can be converted to the expected types. """ filter_ = self._filter({ 'bundles': [ binary_type(self.trytes1), bytearray(self.trytes2), ], 'addresses': [ binary_type(self.trytes1), bytearray(self.trytes2), ], 'tags': [ binary_type(self.trytes1), bytearray(self.trytes3), ], 'approvees': [ binary_type(self.trytes1), bytearray(self.trytes3), ], }) self.assertFilterPasses(filter_) self.assertDictEqual( filter_.cleaned_data, { 'bundles': [ TransactionHash(self.trytes1), TransactionHash(self.trytes2), ], 'addresses': [ Address(self.trytes1), Address(self.trytes2), ], 'tags': [ Tag(self.trytes1), Tag(self.trytes3), ], 'approvees': [ TransactionHash(self.trytes1), TransactionHash(self.trytes3), ], }, )
def test_pass_compatible_types(self): """ Incoming values can be converted into the expected types. """ filter_ = self._filter({ # Any value that can be converted into an ASCII representation of # a TransactionHash is valid here. 'trunkTransaction': TransactionHash(self.txn_id), 'branchTransaction': bytearray(self.txn_id.encode('ascii')), 'trytes': [ # ``trytes`` can contain any value that can be converted into a # TryteString. binary_type(TransactionTrytes(self.trytes1)), # This is probably wrong (s/b :py:class:`TransactionTrytes`), # but technically it's valid. TransactionHash( b'CCPCBDVC9DTCEAKDXC9D9DEARCWCPCBDVCTCEAHDWCTCEAKDCDFD9DSCSA', ), ], # This still has to be an int, however. 'minWeightMagnitude': 30, }) print_var_type_n_val(var001 = TransactionTrytes(self.trytes1), pointer = "#WXCVgfds1234iuytrghrdfredfr")#WXCVgfds1234iuytrghrdfredfr # Value: RBTC9D9DCDQAEASBYBCCKBFA999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 # Type: <class 'iota.transaction.types.TransactionTrytes'> self.assertFilterPasses(filter_) self.assertDictEqual( filter_.cleaned_data, # After running through the filter, all of the values have been # converted to the correct types. { 'trunkTransaction': self.txn_id, 'branchTransaction': self.txn_id, 'minWeightMagnitude': 30, 'trytes': [ text_type(TransactionTrytes(self.trytes1)), text_type(TransactionTrytes( b'CCPCBDVC9DTCEAKDXC9D9DEARCWCPCBDVCTCEAHD' b'WCTCEAKDCDFD9DSCSA99999999999999999999999', )), ], } )
def test_fail_tips_wrong_type(self): """ ``tips`` is not an array. """ self.assertFilterErrors( { 'tips': TransactionHash(self.trytes2), 'transactions': [TransactionHash(self.trytes1)], }, { 'tips': [f.Type.CODE_WRONG_TYPE], }, )
def test_pass_happy_path(self): """ Request is valid. """ request = { 'hashes': [TransactionHash(self.hash1), TransactionHash(self.hash2)], } filter_ = self._filter(request) self.assertFilterPasses(filter_) self.assertDictEqual(filter_.cleaned_data, request)
def test_pass_compatible_types(self): """ Incoming values can be converted into the expected types. """ filter_ = self._filter({ # Any value that can be converted into an ASCII representation of # a TransactionHash is valid here. 'trunkTransaction': TransactionHash(self.txn_id), 'branchTransaction': bytearray(self.txn_id.encode('ascii')), 'trytes': [ # ``trytes`` can contain any value that can be converted into a # TryteString. bytes(TransactionTrytes(self.trytes1)), # This is probably wrong (s/b :py:class:`TransactionTrytes`), # but technically it's valid. TransactionHash( b'CCPCBDVC9DTCEAKDXC9D9DEARCWCPCBDVCTCEAHDWCTCEAKDCDFD9DSCSA', ), ], # This still has to be an int, however. 'minWeightMagnitude': 30, }) self.assertFilterPasses(filter_) self.assertDictEqual( filter_.cleaned_data, # After running through the filter, all of the values have been # converted to the correct types. { 'trunkTransaction': self.txn_id, 'branchTransaction': self.txn_id, 'minWeightMagnitude': 30, 'trytes': [ str(TransactionTrytes(self.trytes1)), str( TransactionTrytes( b'CCPCBDVC9DTCEAKDXC9D9DEARCWCPCBDVCTCEAHD' b'WCTCEAKDCDFD9DSCSA99999999999999999999999', )), ], })
def test_fail_min_weight_magnitude_null(self): """ ``minWeightMagnitude`` is null. """ self.assertFilterErrors( { 'minWeightMagnitude': None, 'branchTransaction': TransactionHash(self.txn_id), 'trunkTransaction': TransactionHash(self.txn_id), 'trytes': [TryteString(self.trytes1)], }, { 'minWeightMagnitude': [f.Required.CODE_EMPTY], }, )
def test_fail_min_weight_magnitude_too_small(self): """ ``minWeightMagnitude`` is less than 1. """ self.assertFilterErrors( { 'minWeightMagnitude': 0, 'branchTransaction': TransactionHash(self.txn_id), 'trunkTransaction': TransactionHash(self.txn_id), 'trytes': [TryteString(self.trytes1)], }, { 'minWeightMagnitude': [f.Min.CODE_TOO_SMALL], }, )
def test_fail_trytes_null(self): """ ``trytes`` is null. """ self.assertFilterErrors( { 'trytes': None, 'branchTransaction': TransactionHash(self.txn_id), 'minWeightMagnitude': 13, 'trunkTransaction': TransactionHash(self.txn_id), }, { 'trytes': [f.Required.CODE_EMPTY], }, )
def test_fail_min_weight_magnitude_float(self): """ ``minWeightMagnitude`` is a float. """ self.assertFilterErrors( { # I don't care if the fpart is empty; it's still not an int! 'minWeightMagnitude': 20.0, 'branchTransaction': TransactionHash(self.txn_id), 'trunkTransaction': TransactionHash(self.txn_id), 'trytes': [TryteString(self.trytes1)], }, { 'minWeightMagnitude': [f.Type.CODE_WRONG_TYPE], }, )
def test_fail_min_weight_magnitude_string(self): """ ``minWeightMagnitude`` is a string. """ self.assertFilterErrors( { # For want of an int cast, the transaction was lost. 'minWeightMagnitude': '20', 'branchTransaction': TransactionHash(self.txn_id), 'trunkTransaction': TransactionHash(self.txn_id), 'trytes': [TryteString(self.trytes1)], }, { 'minWeightMagnitude': [f.Type.CODE_WRONG_TYPE], }, )
def test_fail_branch_transaction_null(self): """ ``branchTransaction`` is null. """ print_var_type_n_val(var001 = f.Required, pointer = "#RT43EREvcdfSDRERE")#RT43EREvcdfSDRERE # Value: # # <class 'filters.simple.Required'> # Type: <class 'filters.base.FilterMeta'> print_var_type_n_val(var001 = f.Required.CODE_EMPTY, pointer = "#2345gfdscredrZERIUYT")#2345gfdscredrZERIUYT # Value: empty # Type: <class 'str'> self.assertFilterErrors( { 'branchTransaction': None, 'minWeightMagnitude': 13, 'trunkTransaction': TransactionHash(self.txn_id), 'trytes': [TryteString(self.trytes1)], }, { 'branchTransaction': [f.Required.CODE_EMPTY], }, )
def test_fail_tips_contents_invalid(self): """ ``tips`` contains invalid values. """ self.assertFilterErrors( { 'tips': [ b'', True, None, b'not valid trytes', # This is actually valid; I just added it to make sure the # filter isn't cheating! TryteString(self.trytes1), 2130706433, b'9' * 82, ], 'transactions': [TransactionHash(self.trytes1)], }, { 'tips.0': [f.Required.CODE_EMPTY], 'tips.1': [f.Type.CODE_WRONG_TYPE], 'tips.2': [f.Required.CODE_EMPTY], 'tips.3': [Trytes.CODE_NOT_TRYTES], 'tips.5': [f.Type.CODE_WRONG_TYPE], 'tips.6': [Trytes.CODE_WRONG_FORMAT], }, )
def test_fail_transactions_contents_invalid(self): """ ``transactions`` is a non-empty array, but it contains invlaid values. """ self.assertFilterErrors( { 'transactions': [ b'', True, None, b'not valid transaction hash', # A valid tx hash, this should not produce error TransactionHash(self.transactions[0]), 65498731, b'9' * (TransactionHash.LEN +1), ], }, { 'transactions.0': [f.Required.CODE_EMPTY], 'transactions.1': [f.Type.CODE_WRONG_TYPE], 'transactions.2': [f.Required.CODE_EMPTY], 'transactions.3': [Trytes.CODE_NOT_TRYTES], 'transactions.5': [f.Type.CODE_WRONG_TYPE], 'transactions.6': [Trytes.CODE_WRONG_FORMAT], }, )