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],
},
)
