From 543899d319c92af412b4ca09588f8d1298a69ccb Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Tue, 7 Aug 2018 13:50:31 -0700 Subject: [PATCH 01/12] Add dynamic and array event args to Emitter contract --- .../contracts/contract_sources/Emitter.sol | 55 ++++++++++++------- tests/core/filtering/conftest.py | 53 +++++++++++++----- 2 files changed, 73 insertions(+), 35 deletions(-) diff --git a/tests/core/contracts/contract_sources/Emitter.sol b/tests/core/contracts/contract_sources/Emitter.sol index 6c15f90ddc..022978118b 100644 --- a/tests/core/contracts/contract_sources/Emitter.sol +++ b/tests/core/contracts/contract_sources/Emitter.sol @@ -1,4 +1,4 @@ -pragma solidity ^0.4.0; +pragma solidity ^0.4.21; contract Emitter { @@ -19,6 +19,9 @@ contract Emitter { event LogTripleWithIndex(uint arg0, uint indexed arg1, uint indexed arg2); event LogQuadrupleWithIndex(uint arg0, uint arg1, uint indexed arg2, uint indexed arg3); event LogDynamicArgs(string indexed arg0, string arg1); + event LogListArgs(bytes2[] indexed arg0, bytes2[] arg1); + event LogAddressIndexed(address indexed arg0, address arg1); + event LogAddressNotIndexed(address arg0, address arg1); enum WhichEvent { LogAnonymous, @@ -35,41 +38,53 @@ contract Emitter { LogQuadrupleWithIndex, LogBytes, LogString, - LogDynamicArgs + LogDynamicArgs, + LogListArgs, + LogAddressIndexed, + LogAddressNotIndexed } function logNoArgs(WhichEvent which) public { - if (which == WhichEvent.LogNoArguments) LogNoArguments(); - else if (which == WhichEvent.LogAnonymous) LogAnonymous(); - else throw; + if (which == WhichEvent.LogNoArguments) emit LogNoArguments(); + else if (which == WhichEvent.LogAnonymous) emit LogAnonymous(); + else revert("Didn't match any allowable event index"); } function logSingle(WhichEvent which, uint arg0) public { - if (which == WhichEvent.LogSingleArg) LogSingleArg(arg0); - else if (which == WhichEvent.LogSingleWithIndex) LogSingleWithIndex(arg0); - else if (which == WhichEvent.LogSingleAnonymous) LogSingleAnonymous(arg0); - else throw; + if (which == WhichEvent.LogSingleArg) emit LogSingleArg(arg0); + else if (which == WhichEvent.LogSingleWithIndex) emit LogSingleWithIndex(arg0); + else if (which == WhichEvent.LogSingleAnonymous) emit LogSingleAnonymous(arg0); + else revert("Didn't match any allowable event index"); } function logDouble(WhichEvent which, uint arg0, uint arg1) public { - if (which == WhichEvent.LogDoubleArg) LogDoubleArg(arg0, arg1); - else if (which == WhichEvent.LogDoubleWithIndex) LogDoubleWithIndex(arg0, arg1); - else if (which == WhichEvent.LogDoubleAnonymous) LogDoubleAnonymous(arg0, arg1); - else throw; + if (which == WhichEvent.LogDoubleArg) emit LogDoubleArg(arg0, arg1); + else if (which == WhichEvent.LogDoubleWithIndex) emit LogDoubleWithIndex(arg0, arg1); + else if (which == WhichEvent.LogDoubleAnonymous) emit LogDoubleAnonymous(arg0, arg1); + else revert("Didn't match any allowable event index"); } function logTriple(WhichEvent which, uint arg0, uint arg1, uint arg2) public { - if (which == WhichEvent.LogTripleArg) LogTripleArg(arg0, arg1, arg2); - else if (which == WhichEvent.LogTripleWithIndex) LogTripleWithIndex(arg0, arg1, arg2); - else throw; + if (which == WhichEvent.LogTripleArg) emit LogTripleArg(arg0, arg1, arg2); + else if (which == WhichEvent.LogTripleWithIndex) emit LogTripleWithIndex(arg0, arg1, arg2); + else revert("Didn't match any allowable event index"); } function logQuadruple(WhichEvent which, uint arg0, uint arg1, uint arg2, uint arg3) public { - if (which == WhichEvent.LogQuadrupleArg) LogQuadrupleArg(arg0, arg1, arg2, arg3); - else if (which == WhichEvent.LogQuadrupleWithIndex) LogQuadrupleWithIndex(arg0, arg1, arg2, arg3); - else throw; + if (which == WhichEvent.LogQuadrupleArg) emit LogQuadrupleArg(arg0, arg1, arg2, arg3); + else if (which == WhichEvent.LogQuadrupleWithIndex) emit LogQuadrupleWithIndex(arg0, arg1, arg2, arg3); + else revert("Didn't match any allowable event index"); } function logDynamicArgs(string arg0, string arg1) public { - LogDynamicArgs(arg0, arg1); + emit LogDynamicArgs(arg0, arg1); + } + function logListArgs(bytes2[] arg0, bytes2[] arg1) public { + emit LogListArgs(arg0, arg1); + } + function logAddressIndexedArgs(address arg0, address arg1) public { + emit LogAddressIndexed(arg0, arg1); + } + function logAddressNotIndexedArgs(address arg0, address arg1) public { + emit LogAddressNotIndexed(arg0, arg1); } } diff --git a/tests/core/filtering/conftest.py b/tests/core/filtering/conftest.py index 690018f2df..bd24c05d9d 100644 --- a/tests/core/filtering/conftest.py +++ b/tests/core/filtering/conftest.py @@ -8,17 +8,30 @@ event_signature_to_log_topic, ) +from web3 import Web3 +from web3.providers.eth_tester import ( + EthereumTesterProvider, +) + + +@pytest.fixture() +def web3(request): + provider = EthereumTesterProvider() + w3 = Web3(provider) + + return w3 + @pytest.fixture(autouse=True) def wait_for_mining_start(web3, wait_for_block): wait_for_block(web3) -CONTRACT_EMITTER_CODE = "0x60606040526104ae806100126000396000f3606060405236156100615760e060020a60003504630bb563d6811461006357806317c0c1801461013657806320f0256e1461017057806390b41d8b146101ca5780639c37705314610215578063aa6fd82214610267578063e17bf956146102a9575b005b60206004803580820135601f810184900490930260809081016040526060848152610061946024939192918401918190838280828437509496505050505050507fa95e6e2a182411e7a6f9ed114a85c3761d87f9b8f453d842c71235aa64fff99f8160405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101255780820380516001836020036101000a031916815260200191505b509250505060405180910390a15b50565b610061600435600181141561037a577f1e86022f78f8d04f8e3dfd13a2bdb280403e6632877c0dbee5e4eeb259908a5c60006060a1610133565b6100616004356024356044356064356084356005851415610392576060848152608084815260a084905260c08390527ff039d147f23fe975a4254bdf6b1502b8c79132ae1833986b7ccef2638e73fdf991a15b5050505050565b61006160043560243560443560038314156103d457606082815260808290527fdf0cb1dea99afceb3ea698d62e705b736f1345a7eee9eb07e63d1f8f556c1bc590604090a15b505050565b6100616004356024356044356064356004841415610428576060838152608083905260a08290527f4a25b279c7c585f25eda9788ac9420ebadae78ca6b206a0e6ab488fd81f550629080a15b50505050565b61006160043560243560028214156104655760608181527f56d2ef3c5228bf5d88573621e325a4672ab50e033749a601e4f4a5e1dce905d490602090a15b5050565b60206004803580820135601f810184900490930260809081016040526060848152610061946024939192918401918190838280828437509496505050505050507f532fd6ea96cfb78bb46e09279a26828b8b493de1a2b8b1ee1face527978a15a58160405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101255780820380516001836020036101000a03191681526020019150509250505060405180910390a150565b600081141561038d5760006060a0610133565b610002565b600b85141561038d5760608481526080849052819083907fa30ece802b64cd2b7e57dabf4010aabf5df26d1556977affb07b98a77ad955b590604090a36101c3565b600983141561040f57606082815281907f057bc32826fbe161da1c110afcdcae7c109a8b69149f727fc37a603c60ef94ca90602090a2610210565b600883141561038d5760608281528190602090a1610210565b600a84141561038d576060838152819083907ff16c999b533366ca5138d78e85da51611089cd05749f098d6c225d4cd42ee6ec90602090a3610261565b600782141561049a57807ff70fe689e290d8ce2b2a388ac28db36fbb0e16a6d89c6804c461f65a1b40bb1560006060a26102a5565b600682141561038d578060006060a16102a556" # noqa: E501 +CONTRACT_EMITTER_CODE = "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" # noqa: E501 -CONTRACT_EMITTER_RUNTIME = "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" # noqa: E501 +CONTRACT_EMITTER_RUNTIME = "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" # noqa: E501 -CONTRACT_EMITTER_ABI = json.loads('[{"constant":false,"inputs":[{"name":"v","type":"string"}],"name":"logString","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"which","type":"uint8"}],"name":"logNoArgs","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"which","type":"uint8"},{"name":"arg0","type":"uint256"},{"name":"arg1","type":"uint256"},{"name":"arg2","type":"uint256"},{"name":"arg3","type":"uint256"}],"name":"logQuadruple","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"which","type":"uint8"},{"name":"arg0","type":"uint256"},{"name":"arg1","type":"uint256"}],"name":"logDouble","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"which","type":"uint8"},{"name":"arg0","type":"uint256"},{"name":"arg1","type":"uint256"},{"name":"arg2","type":"uint256"}],"name":"logTriple","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"which","type":"uint8"},{"name":"arg0","type":"uint256"}],"name":"logSingle","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"v","type":"bytes"}],"name":"logBytes","outputs":[],"type":"function"},{"anonymous":true,"inputs":[],"name":"LogAnonymous","type":"event"},{"anonymous":false,"inputs":[],"name":"LogNoArguments","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"}],"name":"LogSingleArg","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":false,"name":"arg1","type":"uint256"}],"name":"LogDoubleArg","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":false,"name":"arg1","type":"uint256"},{"indexed":false,"name":"arg2","type":"uint256"}],"name":"LogTripleArg","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":false,"name":"arg1","type":"uint256"},{"indexed":false,"name":"arg2","type":"uint256"},{"indexed":false,"name":"arg3","type":"uint256"}],"name":"LogQuadrupleArg","type":"event"},{"anonymous":true,"inputs":[{"indexed":true,"name":"arg0","type":"uint256"}],"name":"LogSingleAnonymous","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"arg0","type":"uint256"}],"name":"LogSingleWithIndex","type":"event"},{"anonymous":true,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":true,"name":"arg1","type":"uint256"}],"name":"LogDoubleAnonymous","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":true,"name":"arg1","type":"uint256"}],"name":"LogDoubleWithIndex","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":true,"name":"arg1","type":"uint256"},{"indexed":true,"name":"arg2","type":"uint256"}],"name":"LogTripleWithIndex","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":false,"name":"arg1","type":"uint256"},{"indexed":true,"name":"arg2","type":"uint256"},{"indexed":true,"name":"arg3","type":"uint256"}],"name":"LogQuadrupleWithIndex","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"v","type":"bytes"}],"name":"LogBytes","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"v","type":"string"}],"name":"LogString","type":"event"}]') # noqa: E501 +CONTRACT_EMITTER_ABI = json.loads('[{"constant":false,"inputs":[{"name":"which","type":"uint8"}],"name":"logNoArgs","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"which","type":"uint8"},{"name":"arg0","type":"uint256"},{"name":"arg1","type":"uint256"},{"name":"arg2","type":"uint256"},{"name":"arg3","type":"uint256"}],"name":"logQuadruple","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"which","type":"uint8"},{"name":"arg0","type":"uint256"},{"name":"arg1","type":"uint256"}],"name":"logDouble","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"arg0","type":"bytes2[]"},{"name":"arg1","type":"bytes2[]"}],"name":"logListArgs","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"which","type":"uint8"},{"name":"arg0","type":"uint256"},{"name":"arg1","type":"uint256"},{"name":"arg2","type":"uint256"}],"name":"logTriple","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"which","type":"uint8"},{"name":"arg0","type":"uint256"}],"name":"logSingle","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"arg0","type":"string"},{"name":"arg1","type":"string"}],"name":"logDynamicArgs","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"arg0","type":"address"},{"name":"arg1","type":"address"}],"name":"logAddressIndexedArgs","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"arg0","type":"address"},{"name":"arg1","type":"address"}],"name":"logAddressNotIndexedArgs","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"anonymous":true,"inputs":[],"name":"LogAnonymous","type":"event"},{"anonymous":false,"inputs":[],"name":"LogNoArguments","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"}],"name":"LogSingleArg","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":false,"name":"arg1","type":"uint256"}],"name":"LogDoubleArg","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":false,"name":"arg1","type":"uint256"},{"indexed":false,"name":"arg2","type":"uint256"}],"name":"LogTripleArg","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":false,"name":"arg1","type":"uint256"},{"indexed":false,"name":"arg2","type":"uint256"},{"indexed":false,"name":"arg3","type":"uint256"}],"name":"LogQuadrupleArg","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"v","type":"string"}],"name":"LogString","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"v","type":"bytes"}],"name":"LogBytes","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"arg0","type":"uint256"}],"name":"LogSingleWithIndex","type":"event"},{"anonymous":true,"inputs":[{"indexed":true,"name":"arg0","type":"uint256"}],"name":"LogSingleAnonymous","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":true,"name":"arg1","type":"uint256"}],"name":"LogDoubleWithIndex","type":"event"},{"anonymous":true,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":true,"name":"arg1","type":"uint256"}],"name":"LogDoubleAnonymous","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":true,"name":"arg1","type":"uint256"},{"indexed":true,"name":"arg2","type":"uint256"}],"name":"LogTripleWithIndex","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"uint256"},{"indexed":false,"name":"arg1","type":"uint256"},{"indexed":true,"name":"arg2","type":"uint256"},{"indexed":true,"name":"arg3","type":"uint256"}],"name":"LogQuadrupleWithIndex","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"arg0","type":"string"},{"indexed":false,"name":"arg1","type":"string"}],"name":"LogDynamicArgs","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"arg0","type":"bytes2[]"},{"indexed":false,"name":"arg1","type":"bytes2[]"}],"name":"LogListArgs","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"arg0","type":"address"},{"indexed":false,"name":"arg1","type":"address"}],"name":"LogAddressIndexed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"arg0","type":"address"},{"indexed":false,"name":"arg1","type":"address"}],"name":"LogAddressNotIndexed","type":"event"}]') # noqa: E501 @pytest.fixture() @@ -67,18 +80,24 @@ def emitter(web3, Emitter, wait_for_transaction, wait_for_block, address_convers class LogFunctions: - LogAnonymous = 0 - LogNoArguments = 1 - LogSingleArg = 2 - LogDoubleArg = 3 - LogTripleArg = 4 - LogQuadrupleArg = 5 - LogSingleAnonymous = 6 - LogSingleWithIndex = 7 - LogDoubleAnonymous = 8 - LogDoubleWithIndex = 9 - LogTripleWithIndex = 10 - LogQuadrupleWithIndex = 11 + LogAnonymous=0 + LogNoArguments=1 + LogSingleArg=2 + LogDoubleArg=3 + LogTripleArg=4 + LogQuadrupleArg=5 + LogSingleAnonymous=6 + LogSingleWithIndex=7 + LogDoubleAnonymous=8 + LogDoubleWithIndex=9 + LogTripleWithIndex=10 + LogQuadrupleWithIndex=11 + LogBytes=12 + LogString=13 + LogDynamicArgs=14 + LogListArgs=15 + LogAddressIndexed=16 + LogAddressNotIndexed=17 @pytest.fixture() @@ -101,6 +120,10 @@ class LogTopics: LogQuadrupleWithIndex = encode_hex(event_signature_to_log_topic("LogQuadrupleWithIndex(uint256,uint256,uint256,uint256)")) # noqa: E501 LogBytes = encode_hex(event_signature_to_log_topic("LogBytes(bytes)")) LogString = encode_hex(event_signature_to_log_topic("LogString(string)")) + LogDynamicArgs = encode_hex(event_signature_to_log_topic("LogDynamicArgs(string,string)")) + LogListArgs = encode_hex(event_signature_to_log_topic("LogListArgs(bytes2[],bytes2[])")) + LogAddressIndexed = encode_hex(event_signature_to_log_topic("LogAddressIndexed(address,address)")) + LogAddressNotIndexed = encode_hex(event_signature_to_log_topic("LogAddressNotIndexed(address,address)")) @pytest.fixture() From 4f96710a3edf552bfc3225e9d839de5f75544232 Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Thu, 9 Aug 2018 16:07:42 -0700 Subject: [PATCH 02/12] Add argument filter tests --- .../filtering/test_contract_data_filters.py | 185 ++++++++++++++++++ 1 file changed, 185 insertions(+) create mode 100644 tests/core/filtering/test_contract_data_filters.py diff --git a/tests/core/filtering/test_contract_data_filters.py b/tests/core/filtering/test_contract_data_filters.py new file mode 100644 index 0000000000..783aa30859 --- /dev/null +++ b/tests/core/filtering/test_contract_data_filters.py @@ -0,0 +1,185 @@ +import pytest +from hypothesis import ( + strategies as st, + given, +) + + +@st.composite +def dynamic_values(draw): + matching_value=draw(st.text().filter(lambda x: x != '')) + exclusions = (matching_value, '') + non_matching_1=draw(st.text().filter(lambda x: x not in exclusions)) + non_matching_2=draw(st.text().filter(lambda x: x not in exclusions)) + non_matching_3=draw(st.text().filter(lambda x: x not in exclusions)) + non_matching_4=draw(st.text().filter(lambda x: x not in exclusions)) + return ( + matching_value, + non_matching_1, + non_matching_2, + non_matching_3, + non_matching_4, + ) + + +@st.composite +def fixed_values(draw): + matching_values=draw(st.lists(elements=st.integers(min_value=0), min_size=4, max_size=4)) + non_matching_1=draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + non_matching_2=draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + non_matching_3=draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + non_matching_4=draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + return ( + matching_values, + non_matching_1, + non_matching_2, + non_matching_3, + non_matching_4, + ) + + +@st.composite +def array_values(draw): + matching=draw(st.lists(elements=st.binary(min_size=2, max_size=2))) + non_matching=draw(st.lists(elements=st.binary(min_size=2, max_size=2)).filter(lambda x: x != matching)) + return (matching, non_matching) + + +@pytest.mark.xfail(reason="The regex based data filters do not work with dynamic sized types") +@pytest.mark.parametrize('call_as_instance', (True, False)) +@given(vals=dynamic_values()) +def test_data_filters_with_dynamic_arguments( + web3, + emitter, + Emitter, + wait_for_transaction, + emitter_event_ids, + call_as_instance, + create_filter, + vals): + + if call_as_instance: + event_filter = create_filter(emitter, [ + 'LogDynamicArgs', { + 'filter': { + 'arg1': vals[0]}}]) + else: + event_filter = create_filter(Emitter, [ + 'LogDynamicArgs', { + 'filter': { + 'arg1': vals[0]}}]) + + txn_hashes = [] + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[0], arg1=vals[0]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[1], arg1=vals[1]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[2], arg1=vals[2]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[3], arg1=vals[3]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[4], arg1=vals[4]).transact()) + + for txn_hash in txn_hashes: + wait_for_transaction(web3, txn_hash) + + log_entries = event_filter.get_new_entries() + assert len(log_entries) == 1 + assert log_entries[0]['transactionHash'] == txn_hashes[0] + + +@pytest.mark.parametrize('call_as_instance', (True, False)) +@given(vals=fixed_values()) +def test_data_filters_with_fixed_arguments( + web3, + emitter, + Emitter, + wait_for_transaction, + emitter_event_ids, + call_as_instance, + create_filter, + vals): + + + if call_as_instance: + event_filter = create_filter(emitter, [ + 'LogQuadrupleArg', { + 'filter': { + 'arg0': vals[0][0], + 'arg1': vals[0][1], + 'arg2': vals[0][2], + 'arg3': vals[0][3]}}]) + else: + event_filter = create_filter(Emitter, [ + 'LogQuadrupleArg', { + 'filter': { + 'arg0': vals[0][0], + 'arg1': vals[0][1], + 'arg2': vals[0][2], + 'arg3': vals[0][3]}}]) + + txn_hashes = [] + txn_hashes.append(emitter.functions.logQuadruple( + which=5, + arg0=vals[0][0], + arg1=vals[0][1], + arg2=vals[0][2], + arg3=vals[0][3]).transact()) + txn_hashes.append(emitter.functions.logQuadruple( + which=5, + arg0=vals[1], + arg1=vals[2], + arg2=vals[3], + arg3=vals[4]).transact()) + + for txn_hash in txn_hashes: + wait_for_transaction(web3, txn_hash) + + log_entries = event_filter.get_new_entries() + assert len(log_entries) == 1 + assert log_entries[0]['transactionHash'] == txn_hashes[0] + + + +@pytest.mark.xfail(reason="The regex based data filters do not work with dynamic sized types") +@pytest.mark.parametrize('call_as_instance', (True, False)) +@given(vals=array_values()) +def test_data_filters_with_list_arguments( + web3, + emitter, + Emitter, + wait_for_transaction, + emitter_event_ids, + call_as_instance, + create_filter, + vals): + + + matching, non_matching = vals + + if call_as_instance: + event_filter = create_filter(emitter, [ + 'LogListArgs', { + 'filter': { "arg0": matching }}]) + else: + event_filter = create_filter(Emitter, [ + 'LogListArgs', { + 'filter': { "arg0": matching }}]) + + txn_hashes = [] + txn_hashes.append(emitter.functions.logDynamicArgs( + arg0=matching, + arg1=matching).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs( + arg0=non_matching, + arg1=non_matching).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs( + arg0=non_matching, + arg1=matching).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs( + arg0=matching, + arg1=non_matching).transact()) + + for txn_hash in txn_hashes: + wait_for_transaction(web3, txn_hash) + + log_entries = event_filter.get_new_entries() + assert len(log_entries) == 2 + assert log_entries[0]['transactionHash'] == txn_hashes[0] + assert log_entries[1]['transactionHash'] == txn_hashes[3] From 8e898b7f85412597acb4823ce1d8a0df4e36723f Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Mon, 13 Aug 2018 12:47:51 -0700 Subject: [PATCH 03/12] Add topic filter tests --- .../filtering/test_contract_data_filters.py | 32 ++- .../filtering/test_contract_topic_filters.py | 183 ++++++++++++++++++ 2 files changed, 198 insertions(+), 17 deletions(-) create mode 100644 tests/core/filtering/test_contract_topic_filters.py diff --git a/tests/core/filtering/test_contract_data_filters.py b/tests/core/filtering/test_contract_data_filters.py index 783aa30859..b53a2b149c 100644 --- a/tests/core/filtering/test_contract_data_filters.py +++ b/tests/core/filtering/test_contract_data_filters.py @@ -7,12 +7,12 @@ @st.composite def dynamic_values(draw): - matching_value=draw(st.text().filter(lambda x: x != '')) + matching_value = draw(st.text().filter(lambda x: x != '')) exclusions = (matching_value, '') - non_matching_1=draw(st.text().filter(lambda x: x not in exclusions)) - non_matching_2=draw(st.text().filter(lambda x: x not in exclusions)) - non_matching_3=draw(st.text().filter(lambda x: x not in exclusions)) - non_matching_4=draw(st.text().filter(lambda x: x not in exclusions)) + non_matching_1 = draw(st.text().filter(lambda x: x not in exclusions)) + non_matching_2 = draw(st.text().filter(lambda x: x not in exclusions)) + non_matching_3 = draw(st.text().filter(lambda x: x not in exclusions)) + non_matching_4 = draw(st.text().filter(lambda x: x not in exclusions)) return ( matching_value, non_matching_1, @@ -24,11 +24,11 @@ def dynamic_values(draw): @st.composite def fixed_values(draw): - matching_values=draw(st.lists(elements=st.integers(min_value=0), min_size=4, max_size=4)) - non_matching_1=draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) - non_matching_2=draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) - non_matching_3=draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) - non_matching_4=draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + matching_values = draw(st.lists(elements=st.integers(min_value=0), min_size=4, max_size=4)) + non_matching_1 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + non_matching_2 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + non_matching_3 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + non_matching_4 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) return ( matching_values, non_matching_1, @@ -40,8 +40,9 @@ def fixed_values(draw): @st.composite def array_values(draw): - matching=draw(st.lists(elements=st.binary(min_size=2, max_size=2))) - non_matching=draw(st.lists(elements=st.binary(min_size=2, max_size=2)).filter(lambda x: x != matching)) + matching = draw(st.lists(elements=st.binary(min_size=2, max_size=2))) + non_matching = draw( + st.lists(elements=st.binary(min_size=2, max_size=2)).filter(lambda x: x != matching)) return (matching, non_matching) @@ -96,7 +97,6 @@ def test_data_filters_with_fixed_arguments( create_filter, vals): - if call_as_instance: event_filter = create_filter(emitter, [ 'LogQuadrupleArg', { @@ -136,7 +136,6 @@ def test_data_filters_with_fixed_arguments( assert log_entries[0]['transactionHash'] == txn_hashes[0] - @pytest.mark.xfail(reason="The regex based data filters do not work with dynamic sized types") @pytest.mark.parametrize('call_as_instance', (True, False)) @given(vals=array_values()) @@ -150,17 +149,16 @@ def test_data_filters_with_list_arguments( create_filter, vals): - matching, non_matching = vals if call_as_instance: event_filter = create_filter(emitter, [ 'LogListArgs', { - 'filter': { "arg0": matching }}]) + 'filter': {"arg1": matching}}]) else: event_filter = create_filter(Emitter, [ 'LogListArgs', { - 'filter': { "arg0": matching }}]) + 'filter': {"arg1": matching}}]) txn_hashes = [] txn_hashes.append(emitter.functions.logDynamicArgs( diff --git a/tests/core/filtering/test_contract_topic_filters.py b/tests/core/filtering/test_contract_topic_filters.py new file mode 100644 index 0000000000..8c7c8f293d --- /dev/null +++ b/tests/core/filtering/test_contract_topic_filters.py @@ -0,0 +1,183 @@ +import pytest +from hypothesis import ( + strategies as st, + given, +) + + +@st.composite +def dynamic_values(draw): + matching_value = draw(st.text().filter(lambda x: x != '')) + exclusions = (matching_value, '') + non_matching_1 = draw(st.text().filter(lambda x: x not in exclusions)) + non_matching_2 = draw(st.text().filter(lambda x: x not in exclusions)) + non_matching_3 = draw(st.text().filter(lambda x: x not in exclusions)) + non_matching_4 = draw(st.text().filter(lambda x: x not in exclusions)) + return ( + matching_value, + non_matching_1, + non_matching_2, + non_matching_3, + non_matching_4, + ) + + +@st.composite +def fixed_values(draw): + matching_values = draw(st.lists(elements=st.integers(min_value=0), min_size=4, max_size=4)) + non_matching_1 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + non_matching_2 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + non_matching_3 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + non_matching_4 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) + return ( + matching_values, + non_matching_1, + non_matching_2, + non_matching_3, + non_matching_4, + ) + + +@st.composite +def array_values(draw): + matching = draw(st.lists(elements=st.binary(min_size=2, max_size=2))) + non_matching = draw( + st.lists(elements=st.binary(min_size=2, max_size=2)).filter(lambda x: x != matching)) + return (matching, non_matching) + + +@pytest.mark.xfail(reason="Topic filters do not work with dynamic sized types") +@pytest.mark.parametrize('call_as_instance', (True, False)) +@given(vals=dynamic_values()) +def test_topic_filters_with_dynamic_arguments( + web3, + emitter, + Emitter, + wait_for_transaction, + emitter_event_ids, + call_as_instance, + create_filter, + vals): + + if call_as_instance: + event_filter = create_filter(emitter, [ + 'LogDynamicArgs', { + 'filter': { + 'arg0': vals[0]}}]) + else: + event_filter = create_filter(Emitter, [ + 'LogDynamicArgs', { + 'filter': { + 'arg0': vals[0]}}]) + + txn_hashes = [] + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[0], arg1=vals[0]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[1], arg1=vals[1]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[2], arg1=vals[2]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[3], arg1=vals[3]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[4], arg1=vals[4]).transact()) + + for txn_hash in txn_hashes: + wait_for_transaction(web3, txn_hash) + + log_entries = event_filter.get_new_entries() + assert len(log_entries) == 1 + assert log_entries[0]['transactionHash'] == txn_hashes[0] + + +@pytest.mark.parametrize('call_as_instance', (True, False)) +@given(vals=fixed_values()) +def test_topic_filters_with_fixed_arguments( + web3, + emitter, + Emitter, + wait_for_transaction, + emitter_event_ids, + call_as_instance, + create_filter, + vals): + + if call_as_instance: + event_filter = create_filter(emitter, [ + 'LogQuadrupleWithIndex', { + 'filter': { + 'arg0': vals[0][0], + 'arg1': vals[0][1], + 'arg2': vals[0][2], + 'arg3': vals[0][3]}}]) + else: + event_filter = create_filter(Emitter, [ + 'LogQuadrupleWithIndex', { + 'filter': { + 'arg0': vals[0][0], + 'arg1': vals[0][1], + 'arg2': vals[0][2], + 'arg3': vals[0][3]}}]) + + txn_hashes = [] + txn_hashes.append(emitter.functions.logQuadruple( + which=11, + arg0=vals[0][0], + arg1=vals[0][1], + arg2=vals[0][2], + arg3=vals[0][3]).transact()) + txn_hashes.append(emitter.functions.logQuadruple( + which=11, + arg0=vals[1], + arg1=vals[2], + arg2=vals[3], + arg3=vals[4]).transact()) + + for txn_hash in txn_hashes: + wait_for_transaction(web3, txn_hash) + + log_entries = event_filter.get_new_entries() + assert len(log_entries) == 1 + assert log_entries[0]['transactionHash'] == txn_hashes[0] + + +@pytest.mark.xfail(reason="Topic filters do not work with dynamic sized types") +@pytest.mark.parametrize('call_as_instance', (True, False)) +@given(vals=array_values()) +def test_topic_filters_with_list_arguments( + web3, + emitter, + Emitter, + wait_for_transaction, + emitter_event_ids, + call_as_instance, + create_filter, + vals): + + matching, non_matching = vals + + if call_as_instance: + event_filter = create_filter(emitter, [ + 'LogListArgs', { + 'filter': {"arg0": matching}}]) + else: + event_filter = create_filter(Emitter, [ + 'LogListArgs', { + 'filter': {"arg0": matching}}]) + + txn_hashes = [] + txn_hashes.append(emitter.functions.logDynamicArgs( + arg0=matching, + arg1=matching).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs( + arg0=non_matching, + arg1=non_matching).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs( + arg0=non_matching, + arg1=matching).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs( + arg0=matching, + arg1=non_matching).transact()) + + for txn_hash in txn_hashes: + wait_for_transaction(web3, txn_hash) + + log_entries = event_filter.get_new_entries() + assert len(log_entries) == 2 + assert log_entries[0]['transactionHash'] == txn_hashes[0] + assert log_entries[1]['transactionHash'] == txn_hashes[3] From 1a8dab64967182fcc850c1ba42a9b1642451f2ff Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Mon, 13 Aug 2018 14:34:16 -0700 Subject: [PATCH 04/12] Add filter tests with +50 blocks --- .../test_filters_against_many_blocks.py | 120 ++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 tests/core/filtering/test_filters_against_many_blocks.py diff --git a/tests/core/filtering/test_filters_against_many_blocks.py b/tests/core/filtering/test_filters_against_many_blocks.py new file mode 100644 index 0000000000..611072ff94 --- /dev/null +++ b/tests/core/filtering/test_filters_against_many_blocks.py @@ -0,0 +1,120 @@ +from hypothesis import ( + strategies as st, + given, +) +import random + + +def pad_with_transactions(w3): + accounts = w3.eth.accounts + while True: + transact = yield + tx_hash = transact() + for tx_count in range(random.randint(0, 10)): + _from = accounts[random.randint(0, len(accounts) - 1)] + _to = accounts[random.randint(0, len(accounts) - 1)] + value = 50 + tx_count + w3.eth.sendTransaction({'from': _from, 'to': _to, 'value': value}) + yield tx_hash + + +def single_transaction(w3): + accounts = w3.eth.accounts + while True: + _from = accounts[random.randint(0, len(accounts) - 1)] + _to = accounts[random.randint(0, len(accounts) - 1)] + value = 50 + tx_hash = w3.eth.sendTransaction({'from': _from, 'to': _to, 'value': value}) + yield tx_hash + + +@given(seed=st.integers()) +def test_event_filter_new_events( + web3, + emitter, + Emitter, + wait_for_transaction, + emitter_event_ids, + create_filter, + seed): + + random.seed(seed) + + matching_transact = emitter.functions.logNoArgs( + which=1).transact + non_matching_transact = emitter.functions.logNoArgs( + which=0).transact + + event_filter = emitter.events.LogNoArguments().createFilter(fromBlock='latest') + + expected_match_counter = 0 + + tx_padder = pad_with_transactions(web3) + tx_padder.send(None) + while web3.eth.blockNumber < 50: + is_match = bool(random.randint(0, 1)) + if is_match: + expected_match_counter += 1 + tx_padder.send(matching_transact) + next(tx_padder) + continue + tx_padder.send(non_matching_transact) + next(tx_padder) + + assert len(event_filter.get_new_entries()) == expected_match_counter + + +@given( + target_block_count=st.integers(min_value=1, max_value=100), + seed=st.integers()) +def test_block_filter( + web3, + target_block_count, + seed): + + random.seed(seed) + block_filter = web3.eth.filter("latest") + + target_block = random.randint(30, 55) + tx_padder = pad_with_transactions(web3) + tx_padder.send(None) + while web3.eth.blockNumber < target_block: + tx_padder.send(lambda: "ok") + next(tx_padder) + + assert len(block_filter.get_new_entries()) == web3.eth.blockNumber + + +@given(target_tx_count=st.integers(min_value=1, max_value=100)) +def test_transaction_filter_with_mining( + web3, + target_tx_count): + + transaction_filter = web3.eth.filter("pending") + + transaction_counter = 0 + + transact_once = single_transaction(web3) + while transaction_counter < target_tx_count: + next(transact_once) + transaction_counter += 1 + + assert len(transaction_filter.get_new_entries()) == transaction_counter + + +@given(target_tx_count=st.integers(min_value=1, max_value=100)) +def test_transaction_filter_without_mining( + web3, + target_tx_count): + + web3.providers[0].ethereum_tester.auto_mine_transactions = False + transaction_filter = web3.eth.filter("pending") + + transaction_counter = 0 + + transact_once = single_transaction(web3) + while transaction_counter < target_tx_count: + next(transact_once) + transaction_counter += 1 + + assert len(transaction_filter.get_new_entries()) == transaction_counter From 423d1da80ddc94b6c2fdbf483bf8caa336fb4e4b Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Mon, 13 Aug 2018 15:00:57 -0700 Subject: [PATCH 05/12] Add filtering test with many deployed contracts --- .../test_filters_against_many_blocks.py | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/tests/core/filtering/test_filters_against_many_blocks.py b/tests/core/filtering/test_filters_against_many_blocks.py index 611072ff94..7ece2e2b60 100644 --- a/tests/core/filtering/test_filters_against_many_blocks.py +++ b/tests/core/filtering/test_filters_against_many_blocks.py @@ -1,9 +1,23 @@ +import pytest from hypothesis import ( strategies as st, given, ) import random +from eth_utils import ( + to_tuple, +) + + +@pytest.fixture +@to_tuple +def deployed_contract_addresses(web3, Emitter): + contract_addresses = [] + for i in range(25): + tx_hash = Emitter.constructor().transact() + yield web3.eth.getTransactionReceipt(tx_hash)['contractAddress'] + def pad_with_transactions(w3): accounts = w3.eth.accounts @@ -64,6 +78,7 @@ def test_event_filter_new_events( assert len(event_filter.get_new_entries()) == expected_match_counter +@pytest.mark.xfail @given( target_block_count=st.integers(min_value=1, max_value=100), seed=st.integers()) @@ -102,6 +117,7 @@ def test_transaction_filter_with_mining( assert len(transaction_filter.get_new_entries()) == transaction_counter +@pytest.mark.xfail @given(target_tx_count=st.integers(min_value=1, max_value=100)) def test_transaction_filter_without_mining( web3, @@ -118,3 +134,47 @@ def test_transaction_filter_without_mining( transaction_counter += 1 assert len(transaction_filter.get_new_entries()) == transaction_counter + + +@given(seed=st.integers()) +def test_event_filter_new_events_many_deployed_contracts( + web3, + emitter, + Emitter, + wait_for_transaction, + emitter_event_ids, + create_filter, + seed, + deployed_contract_addresses): + + random.seed(seed) + + matching_transact = emitter.functions.logNoArgs( + which=1).transact + + def gen_non_matching_transact(): + while True: + contract_address = deployed_contract_addresses[ + random.randint(0, len(deployed_contract_addresses))] + yield web3.eth.contract( + address=contract_address, abi=Emitter.abi).functions.logNoArgs(which=1).transact + + non_matching_transact = gen_non_matching_transact() + + event_filter = emitter.events.LogNoArguments().createFilter(fromBlock='latest') + + expected_match_counter = 0 + + tx_padder = pad_with_transactions(web3) + tx_padder.send(None) + while web3.eth.blockNumber < 50: + is_match = bool(random.randint(0, 1)) + if is_match: + expected_match_counter += 1 + tx_padder.send(matching_transact) + next(tx_padder) + continue + tx_padder.send(next(non_matching_transact)) + next(tx_padder) + + assert len(event_filter.get_new_entries()) == expected_match_counter From ead5b0718b9515394ef1aff4b51b5aab26f52d99 Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Mon, 13 Aug 2018 15:10:07 -0700 Subject: [PATCH 06/12] fix lint errors --- tests/core/filtering/conftest.py | 42 ++++++++++--------- .../filtering/test_contract_data_filters.py | 3 +- .../filtering/test_contract_topic_filters.py | 3 +- .../test_filters_against_many_blocks.py | 11 +++-- 4 files changed, 31 insertions(+), 28 deletions(-) diff --git a/tests/core/filtering/conftest.py b/tests/core/filtering/conftest.py index bd24c05d9d..f68372de67 100644 --- a/tests/core/filtering/conftest.py +++ b/tests/core/filtering/conftest.py @@ -80,24 +80,24 @@ def emitter(web3, Emitter, wait_for_transaction, wait_for_block, address_convers class LogFunctions: - LogAnonymous=0 - LogNoArguments=1 - LogSingleArg=2 - LogDoubleArg=3 - LogTripleArg=4 - LogQuadrupleArg=5 - LogSingleAnonymous=6 - LogSingleWithIndex=7 - LogDoubleAnonymous=8 - LogDoubleWithIndex=9 - LogTripleWithIndex=10 - LogQuadrupleWithIndex=11 - LogBytes=12 - LogString=13 - LogDynamicArgs=14 - LogListArgs=15 - LogAddressIndexed=16 - LogAddressNotIndexed=17 + LogAnonymous = 0 + LogNoArguments = 1 + LogSingleArg = 2 + LogDoubleArg = 3 + LogTripleArg = 4 + LogQuadrupleArg = 5 + LogSingleAnonymous = 6 + LogSingleWithIndex = 7 + LogDoubleAnonymous = 8 + LogDoubleWithIndex = 9 + LogTripleWithIndex = 10 + LogQuadrupleWithIndex = 11 + LogBytes = 12 + LogString = 13 + LogDynamicArgs = 14 + LogListArgs = 15 + LogAddressIndexed = 16 + LogAddressNotIndexed = 17 @pytest.fixture() @@ -122,8 +122,10 @@ class LogTopics: LogString = encode_hex(event_signature_to_log_topic("LogString(string)")) LogDynamicArgs = encode_hex(event_signature_to_log_topic("LogDynamicArgs(string,string)")) LogListArgs = encode_hex(event_signature_to_log_topic("LogListArgs(bytes2[],bytes2[])")) - LogAddressIndexed = encode_hex(event_signature_to_log_topic("LogAddressIndexed(address,address)")) - LogAddressNotIndexed = encode_hex(event_signature_to_log_topic("LogAddressNotIndexed(address,address)")) + LogAddressIndexed = encode_hex(event_signature_to_log_topic( + "LogAddressIndexed(address,address)")) + LogAddressNotIndexed = encode_hex(event_signature_to_log_topic( + "LogAddressNotIndexed(address,address)")) @pytest.fixture() diff --git a/tests/core/filtering/test_contract_data_filters.py b/tests/core/filtering/test_contract_data_filters.py index b53a2b149c..a8d4f6a445 100644 --- a/tests/core/filtering/test_contract_data_filters.py +++ b/tests/core/filtering/test_contract_data_filters.py @@ -1,7 +1,8 @@ import pytest + from hypothesis import ( - strategies as st, given, + strategies as st, ) diff --git a/tests/core/filtering/test_contract_topic_filters.py b/tests/core/filtering/test_contract_topic_filters.py index 8c7c8f293d..b436e26f3d 100644 --- a/tests/core/filtering/test_contract_topic_filters.py +++ b/tests/core/filtering/test_contract_topic_filters.py @@ -1,7 +1,8 @@ import pytest + from hypothesis import ( - strategies as st, given, + strategies as st, ) diff --git a/tests/core/filtering/test_filters_against_many_blocks.py b/tests/core/filtering/test_filters_against_many_blocks.py index 7ece2e2b60..288c79edf0 100644 --- a/tests/core/filtering/test_filters_against_many_blocks.py +++ b/tests/core/filtering/test_filters_against_many_blocks.py @@ -1,19 +1,18 @@ import pytest -from hypothesis import ( - strategies as st, - given, -) import random from eth_utils import ( to_tuple, ) +from hypothesis import ( + given, + strategies as st, +) @pytest.fixture @to_tuple def deployed_contract_addresses(web3, Emitter): - contract_addresses = [] for i in range(25): tx_hash = Emitter.constructor().transact() yield web3.eth.getTransactionReceipt(tx_hash)['contractAddress'] @@ -157,7 +156,7 @@ def gen_non_matching_transact(): contract_address = deployed_contract_addresses[ random.randint(0, len(deployed_contract_addresses))] yield web3.eth.contract( - address=contract_address, abi=Emitter.abi).functions.logNoArgs(which=1).transact + address=contract_address, abi=Emitter.abi).functions.logNoArgs(which=1).transact non_matching_transact = gen_non_matching_transact() From 060f73b111185d758a619dda0b7ba1746fefd87f Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Mon, 13 Aug 2018 18:26:48 -0700 Subject: [PATCH 07/12] Add wait to test contract deployment --- tests/core/filtering/test_filters_against_many_blocks.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/core/filtering/test_filters_against_many_blocks.py b/tests/core/filtering/test_filters_against_many_blocks.py index 288c79edf0..61dfa09162 100644 --- a/tests/core/filtering/test_filters_against_many_blocks.py +++ b/tests/core/filtering/test_filters_against_many_blocks.py @@ -12,9 +12,10 @@ @pytest.fixture @to_tuple -def deployed_contract_addresses(web3, Emitter): +def deployed_contract_addresses(web3, Emitter, wait_for_transaction): for i in range(25): tx_hash = Emitter.constructor().transact() + wait_for_transaction(web3, tx_hash) yield web3.eth.getTransactionReceipt(tx_hash)['contractAddress'] From 5cfc783a9f98928241aa8ba18f8f84be4b921e48 Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Tue, 14 Aug 2018 12:23:08 -0700 Subject: [PATCH 08/12] Remove hypothesis from slow filtering tests --- .../test_filters_against_many_blocks.py | 55 ++++++------------- 1 file changed, 17 insertions(+), 38 deletions(-) diff --git a/tests/core/filtering/test_filters_against_many_blocks.py b/tests/core/filtering/test_filters_against_many_blocks.py index 61dfa09162..7b5f0bae8f 100644 --- a/tests/core/filtering/test_filters_against_many_blocks.py +++ b/tests/core/filtering/test_filters_against_many_blocks.py @@ -4,17 +4,16 @@ from eth_utils import ( to_tuple, ) -from hypothesis import ( - given, - strategies as st, -) -@pytest.fixture +SEED = 50505050505 +random.seed(SEED) + + @to_tuple -def deployed_contract_addresses(web3, Emitter, wait_for_transaction): +def deploy_contracts(web3, contract, wait_for_transaction): for i in range(25): - tx_hash = Emitter.constructor().transact() + tx_hash = contract.constructor().transact() wait_for_transaction(web3, tx_hash) yield web3.eth.getTransactionReceipt(tx_hash)['contractAddress'] @@ -42,17 +41,13 @@ def single_transaction(w3): yield tx_hash -@given(seed=st.integers()) def test_event_filter_new_events( web3, emitter, Emitter, wait_for_transaction, emitter_event_ids, - create_filter, - seed): - - random.seed(seed) + create_filter): matching_transact = emitter.functions.logNoArgs( which=1).transact @@ -79,38 +74,27 @@ def test_event_filter_new_events( @pytest.mark.xfail -@given( - target_block_count=st.integers(min_value=1, max_value=100), - seed=st.integers()) -def test_block_filter( - web3, - target_block_count, - seed): - - random.seed(seed) +def test_block_filter(web3): block_filter = web3.eth.filter("latest") - target_block = random.randint(30, 55) tx_padder = pad_with_transactions(web3) tx_padder.send(None) - while web3.eth.blockNumber < target_block: + while web3.eth.blockNumber < 50: tx_padder.send(lambda: "ok") next(tx_padder) assert len(block_filter.get_new_entries()) == web3.eth.blockNumber -@given(target_tx_count=st.integers(min_value=1, max_value=100)) def test_transaction_filter_with_mining( - web3, - target_tx_count): + web3): transaction_filter = web3.eth.filter("pending") transaction_counter = 0 transact_once = single_transaction(web3) - while transaction_counter < target_tx_count: + while transaction_counter < 100: next(transact_once) transaction_counter += 1 @@ -118,10 +102,8 @@ def test_transaction_filter_with_mining( @pytest.mark.xfail -@given(target_tx_count=st.integers(min_value=1, max_value=100)) def test_transaction_filter_without_mining( - web3, - target_tx_count): + web3): web3.providers[0].ethereum_tester.auto_mine_transactions = False transaction_filter = web3.eth.filter("pending") @@ -129,33 +111,30 @@ def test_transaction_filter_without_mining( transaction_counter = 0 transact_once = single_transaction(web3) - while transaction_counter < target_tx_count: + while transaction_counter < 100: next(transact_once) transaction_counter += 1 assert len(transaction_filter.get_new_entries()) == transaction_counter -@given(seed=st.integers()) def test_event_filter_new_events_many_deployed_contracts( web3, emitter, Emitter, wait_for_transaction, emitter_event_ids, - create_filter, - seed, - deployed_contract_addresses): - - random.seed(seed) + create_filter): matching_transact = emitter.functions.logNoArgs( which=1).transact + deployed_contract_addresses = deploy_contracts(web3, Emitter, wait_for_transaction) + def gen_non_matching_transact(): while True: contract_address = deployed_contract_addresses[ - random.randint(0, len(deployed_contract_addresses))] + random.randint(0, len(deployed_contract_addresses) - 1)] yield web3.eth.contract( address=contract_address, abi=Emitter.abi).functions.logNoArgs(which=1).transact From e7402c05061af17728e66dc44f471dd3537cbb91 Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Tue, 14 Aug 2018 12:40:10 -0700 Subject: [PATCH 09/12] improve test arg readability --- .../filtering/test_contract_data_filters.py | 78 ++++++++++--------- .../filtering/test_contract_topic_filters.py | 78 ++++++++++--------- 2 files changed, 82 insertions(+), 74 deletions(-) diff --git a/tests/core/filtering/test_contract_data_filters.py b/tests/core/filtering/test_contract_data_filters.py index a8d4f6a445..6f0e60046f 100644 --- a/tests/core/filtering/test_contract_data_filters.py +++ b/tests/core/filtering/test_contract_data_filters.py @@ -14,13 +14,15 @@ def dynamic_values(draw): non_matching_2 = draw(st.text().filter(lambda x: x not in exclusions)) non_matching_3 = draw(st.text().filter(lambda x: x not in exclusions)) non_matching_4 = draw(st.text().filter(lambda x: x not in exclusions)) - return ( - matching_value, - non_matching_1, - non_matching_2, - non_matching_3, - non_matching_4, - ) + return { + "matching": matching_value, + "non_matching": [ + non_matching_1, + non_matching_2, + non_matching_3, + non_matching_4 + ] + } @st.composite @@ -30,13 +32,15 @@ def fixed_values(draw): non_matching_2 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) non_matching_3 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) non_matching_4 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) - return ( - matching_values, - non_matching_1, - non_matching_2, - non_matching_3, - non_matching_4, - ) + return { + "matching": matching_value, + "non_matching": [ + non_matching_1, + non_matching_2, + non_matching_3, + non_matching_4 + ] + } @st.composite @@ -64,19 +68,19 @@ def test_data_filters_with_dynamic_arguments( event_filter = create_filter(emitter, [ 'LogDynamicArgs', { 'filter': { - 'arg1': vals[0]}}]) + 'arg1': vals['matching']}}]) else: event_filter = create_filter(Emitter, [ 'LogDynamicArgs', { 'filter': { - 'arg1': vals[0]}}]) + 'arg1': vals['matching']}}]) txn_hashes = [] - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[0], arg1=vals[0]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[1], arg1=vals[1]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[2], arg1=vals[2]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[3], arg1=vals[3]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[4], arg1=vals[4]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['matching'], arg1=vals['matching']).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][0], arg1=vals['non_matching'][0]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][1], arg1=vals['non_matching'][1]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][2], arg1=vals['non_matching'][2]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][3], arg1=vals['non_matching'][3]).transact()) for txn_hash in txn_hashes: wait_for_transaction(web3, txn_hash) @@ -102,32 +106,32 @@ def test_data_filters_with_fixed_arguments( event_filter = create_filter(emitter, [ 'LogQuadrupleArg', { 'filter': { - 'arg0': vals[0][0], - 'arg1': vals[0][1], - 'arg2': vals[0][2], - 'arg3': vals[0][3]}}]) + 'arg0': vals['matching'][0], + 'arg1': vals['matching'][1], + 'arg2': vals['matching'][2], + 'arg3': vals['matching'][3]}}]) else: event_filter = create_filter(Emitter, [ 'LogQuadrupleArg', { 'filter': { - 'arg0': vals[0][0], - 'arg1': vals[0][1], - 'arg2': vals[0][2], - 'arg3': vals[0][3]}}]) + 'arg0': vals['matching'][0], + 'arg1': vals['matching'][1], + 'arg2': vals['matching'][2], + 'arg3': vals['matching'][3]}}]) txn_hashes = [] txn_hashes.append(emitter.functions.logQuadruple( which=5, - arg0=vals[0][0], - arg1=vals[0][1], - arg2=vals[0][2], - arg3=vals[0][3]).transact()) + arg0=vals['matching'][0], + arg1=vals['matching'][1], + arg2=vals['matching'][2], + arg3=vals['matching'][3]).transact()) txn_hashes.append(emitter.functions.logQuadruple( which=5, - arg0=vals[1], - arg1=vals[2], - arg2=vals[3], - arg3=vals[4]).transact()) + arg0=vals['non_matching'][0], + arg1=vals['non_matching'][1], + arg2=vals['non_matching'][2], + arg3=vals['non_matching'][3]).transact()) for txn_hash in txn_hashes: wait_for_transaction(web3, txn_hash) diff --git a/tests/core/filtering/test_contract_topic_filters.py b/tests/core/filtering/test_contract_topic_filters.py index b436e26f3d..1e00540a82 100644 --- a/tests/core/filtering/test_contract_topic_filters.py +++ b/tests/core/filtering/test_contract_topic_filters.py @@ -14,13 +14,15 @@ def dynamic_values(draw): non_matching_2 = draw(st.text().filter(lambda x: x not in exclusions)) non_matching_3 = draw(st.text().filter(lambda x: x not in exclusions)) non_matching_4 = draw(st.text().filter(lambda x: x not in exclusions)) - return ( - matching_value, - non_matching_1, - non_matching_2, - non_matching_3, - non_matching_4, - ) + return { + "matching": matching_value, + "non_matching": [ + non_matching_1, + non_matching_2, + non_matching_3, + non_matching_4 + ] + } @st.composite @@ -30,13 +32,15 @@ def fixed_values(draw): non_matching_2 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) non_matching_3 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) non_matching_4 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) - return ( - matching_values, - non_matching_1, - non_matching_2, - non_matching_3, - non_matching_4, - ) + return { + "matching": matching_value, + "non_matching": [ + non_matching_1, + non_matching_2, + non_matching_3, + non_matching_4 + ] + } @st.composite @@ -64,19 +68,19 @@ def test_topic_filters_with_dynamic_arguments( event_filter = create_filter(emitter, [ 'LogDynamicArgs', { 'filter': { - 'arg0': vals[0]}}]) + 'arg0': vals['matching']}}]) else: event_filter = create_filter(Emitter, [ 'LogDynamicArgs', { 'filter': { - 'arg0': vals[0]}}]) + 'arg0': vals['matching']}}]) txn_hashes = [] - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[0], arg1=vals[0]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[1], arg1=vals[1]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[2], arg1=vals[2]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[3], arg1=vals[3]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals[4], arg1=vals[4]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['matching'], arg1=vals['matching']).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][0], arg1=vals['non_matching'][0]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][1], arg1=vals['non_matching'][1]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][2], arg1=vals['non_matching'][2]).transact()) + txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][3], arg1=vals['non_matching'][3]).transact()) for txn_hash in txn_hashes: wait_for_transaction(web3, txn_hash) @@ -102,32 +106,32 @@ def test_topic_filters_with_fixed_arguments( event_filter = create_filter(emitter, [ 'LogQuadrupleWithIndex', { 'filter': { - 'arg0': vals[0][0], - 'arg1': vals[0][1], - 'arg2': vals[0][2], - 'arg3': vals[0][3]}}]) + 'arg0': vals['matching'][0], + 'arg1': vals['matching'][1], + 'arg2': vals['matching'][2], + 'arg3': vals['matching'][3]}}]) else: event_filter = create_filter(Emitter, [ 'LogQuadrupleWithIndex', { 'filter': { - 'arg0': vals[0][0], - 'arg1': vals[0][1], - 'arg2': vals[0][2], - 'arg3': vals[0][3]}}]) + 'arg0': vals['matching'][0], + 'arg1': vals['matching'][1], + 'arg2': vals['matching'][2], + 'arg3': vals['matching'][3]}}]) txn_hashes = [] txn_hashes.append(emitter.functions.logQuadruple( which=11, - arg0=vals[0][0], - arg1=vals[0][1], - arg2=vals[0][2], - arg3=vals[0][3]).transact()) + arg0=vals['matching'][0], + arg1=vals['matching'][1], + arg2=vals['matching'][2], + arg3=vals['matching'][3]).transact()) txn_hashes.append(emitter.functions.logQuadruple( which=11, - arg0=vals[1], - arg1=vals[2], - arg2=vals[3], - arg3=vals[4]).transact()) + arg0=vals['non_matching'][0], + arg1=vals['non_matching'][1], + arg2=vals['non_matching'][2], + arg3=vals['non_matching'][3]).transact()) for txn_hash in txn_hashes: wait_for_transaction(web3, txn_hash) From ddfab8378900046bcdf8ec7ba2c4269649cb09c6 Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Tue, 14 Aug 2018 13:04:03 -0700 Subject: [PATCH 10/12] Fix lint errors --- .../filtering/test_contract_data_filters.py | 24 +++++++++++++------ .../filtering/test_contract_topic_filters.py | 24 +++++++++++++------ .../test_filters_against_many_blocks.py | 1 - 3 files changed, 34 insertions(+), 15 deletions(-) diff --git a/tests/core/filtering/test_contract_data_filters.py b/tests/core/filtering/test_contract_data_filters.py index 6f0e60046f..5bac9d2b53 100644 --- a/tests/core/filtering/test_contract_data_filters.py +++ b/tests/core/filtering/test_contract_data_filters.py @@ -15,7 +15,7 @@ def dynamic_values(draw): non_matching_3 = draw(st.text().filter(lambda x: x not in exclusions)) non_matching_4 = draw(st.text().filter(lambda x: x not in exclusions)) return { - "matching": matching_value, + "matching": matching_value, "non_matching": [ non_matching_1, non_matching_2, @@ -33,7 +33,7 @@ def fixed_values(draw): non_matching_3 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) non_matching_4 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) return { - "matching": matching_value, + "matching": matching_values, "non_matching": [ non_matching_1, non_matching_2, @@ -76,11 +76,21 @@ def test_data_filters_with_dynamic_arguments( 'arg1': vals['matching']}}]) txn_hashes = [] - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['matching'], arg1=vals['matching']).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][0], arg1=vals['non_matching'][0]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][1], arg1=vals['non_matching'][1]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][2], arg1=vals['non_matching'][2]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][3], arg1=vals['non_matching'][3]).transact()) + txn_hashes.append( + emitter.functions.logDynamicArgs( + arg0=vals['matching'], arg1=vals['matching']).transact()) + txn_hashes.append( + emitter.functions.logDynamicArgs( + arg0=vals['non_matching'][0], arg1=vals['non_matching'][0]).transact()) + txn_hashes.append( + emitter.functions.logDynamicArgs( + arg0=vals['non_matching'][1], arg1=vals['non_matching'][1]).transact()) + txn_hashes.append( + emitter.functions.logDynamicArgs( + arg0=vals['non_matching'][2], arg1=vals['non_matching'][2]).transact()) + txn_hashes.append( + emitter.functions.logDynamicArgs( + arg0=vals['non_matching'][3], arg1=vals['non_matching'][3]).transact()) for txn_hash in txn_hashes: wait_for_transaction(web3, txn_hash) diff --git a/tests/core/filtering/test_contract_topic_filters.py b/tests/core/filtering/test_contract_topic_filters.py index 1e00540a82..c47f4d3433 100644 --- a/tests/core/filtering/test_contract_topic_filters.py +++ b/tests/core/filtering/test_contract_topic_filters.py @@ -15,7 +15,7 @@ def dynamic_values(draw): non_matching_3 = draw(st.text().filter(lambda x: x not in exclusions)) non_matching_4 = draw(st.text().filter(lambda x: x not in exclusions)) return { - "matching": matching_value, + "matching": matching_value, "non_matching": [ non_matching_1, non_matching_2, @@ -33,7 +33,7 @@ def fixed_values(draw): non_matching_3 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) non_matching_4 = draw(st.integers(min_value=0).filter(lambda x: x not in matching_values)) return { - "matching": matching_value, + "matching": matching_values, "non_matching": [ non_matching_1, non_matching_2, @@ -76,11 +76,21 @@ def test_topic_filters_with_dynamic_arguments( 'arg0': vals['matching']}}]) txn_hashes = [] - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['matching'], arg1=vals['matching']).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][0], arg1=vals['non_matching'][0]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][1], arg1=vals['non_matching'][1]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][2], arg1=vals['non_matching'][2]).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs(arg0=vals['non_matching'][3], arg1=vals['non_matching'][3]).transact()) + txn_hashes.append( + emitter.functions.logDynamicArgs( + arg0=vals['matching'], arg1=vals['matching']).transact()) + txn_hashes.append( + emitter.functions.logDynamicArgs( + arg0=vals['non_matching'][0], arg1=vals['non_matching'][0]).transact()) + txn_hashes.append( + emitter.functions.logDynamicArgs( + arg0=vals['non_matching'][1], arg1=vals['non_matching'][1]).transact()) + txn_hashes.append( + emitter.functions.logDynamicArgs( + arg0=vals['non_matching'][2], arg1=vals['non_matching'][2]).transact()) + txn_hashes.append( + emitter.functions.logDynamicArgs( + arg0=vals['non_matching'][3], arg1=vals['non_matching'][3]).transact()) for txn_hash in txn_hashes: wait_for_transaction(web3, txn_hash) diff --git a/tests/core/filtering/test_filters_against_many_blocks.py b/tests/core/filtering/test_filters_against_many_blocks.py index 7b5f0bae8f..715d5b7756 100644 --- a/tests/core/filtering/test_filters_against_many_blocks.py +++ b/tests/core/filtering/test_filters_against_many_blocks.py @@ -5,7 +5,6 @@ to_tuple, ) - SEED = 50505050505 random.seed(SEED) From fa39d7adc2759a81d6b60667bac0763ee42f2251 Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Tue, 14 Aug 2018 15:02:03 -0700 Subject: [PATCH 11/12] Fix emit functions for logListArgs --- tests/core/filtering/test_contract_data_filters.py | 8 ++++---- tests/core/filtering/test_contract_topic_filters.py | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/tests/core/filtering/test_contract_data_filters.py b/tests/core/filtering/test_contract_data_filters.py index 5bac9d2b53..7f94a10bd4 100644 --- a/tests/core/filtering/test_contract_data_filters.py +++ b/tests/core/filtering/test_contract_data_filters.py @@ -176,16 +176,16 @@ def test_data_filters_with_list_arguments( 'filter': {"arg1": matching}}]) txn_hashes = [] - txn_hashes.append(emitter.functions.logDynamicArgs( + txn_hashes.append(emitter.functions.logListArgs( arg0=matching, arg1=matching).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs( + txn_hashes.append(emitter.functions.logListArgs( arg0=non_matching, arg1=non_matching).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs( + txn_hashes.append(emitter.functions.logListArgs( arg0=non_matching, arg1=matching).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs( + txn_hashes.append(emitter.functions.logListArgs( arg0=matching, arg1=non_matching).transact()) diff --git a/tests/core/filtering/test_contract_topic_filters.py b/tests/core/filtering/test_contract_topic_filters.py index c47f4d3433..60f8db448e 100644 --- a/tests/core/filtering/test_contract_topic_filters.py +++ b/tests/core/filtering/test_contract_topic_filters.py @@ -176,16 +176,16 @@ def test_topic_filters_with_list_arguments( 'filter': {"arg0": matching}}]) txn_hashes = [] - txn_hashes.append(emitter.functions.logDynamicArgs( + txn_hashes.append(emitter.functions.logListArgs( arg0=matching, arg1=matching).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs( + txn_hashes.append(emitter.functions.logListArgs( arg0=non_matching, arg1=non_matching).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs( + txn_hashes.append(emitter.functions.logListArgs( arg0=non_matching, arg1=matching).transact()) - txn_hashes.append(emitter.functions.logDynamicArgs( + txn_hashes.append(emitter.functions.logListArgs( arg0=matching, arg1=non_matching).transact()) From 5caf0d9e35f05dad1aa8aeb6ecddec3b2f591963 Mon Sep 17 00:00:00 2001 From: Dylan Wilson Date: Wed, 15 Aug 2018 19:40:08 -0700 Subject: [PATCH 12/12] Remove unecessary generators --- .../test_filters_against_many_blocks.py | 60 +++++++------------ 1 file changed, 22 insertions(+), 38 deletions(-) diff --git a/tests/core/filtering/test_filters_against_many_blocks.py b/tests/core/filtering/test_filters_against_many_blocks.py index 715d5b7756..6653ad9be4 100644 --- a/tests/core/filtering/test_filters_against_many_blocks.py +++ b/tests/core/filtering/test_filters_against_many_blocks.py @@ -5,9 +5,6 @@ to_tuple, ) -SEED = 50505050505 -random.seed(SEED) - @to_tuple def deploy_contracts(web3, contract, wait_for_transaction): @@ -19,25 +16,20 @@ def deploy_contracts(web3, contract, wait_for_transaction): def pad_with_transactions(w3): accounts = w3.eth.accounts - while True: - transact = yield - tx_hash = transact() - for tx_count in range(random.randint(0, 10)): - _from = accounts[random.randint(0, len(accounts) - 1)] - _to = accounts[random.randint(0, len(accounts) - 1)] - value = 50 + tx_count - w3.eth.sendTransaction({'from': _from, 'to': _to, 'value': value}) - yield tx_hash + for tx_count in range(random.randint(0, 10)): + _from = accounts[random.randint(0, len(accounts) - 1)] + _to = accounts[random.randint(0, len(accounts) - 1)] + value = 50 + tx_count + w3.eth.sendTransaction({'from': _from, 'to': _to, 'value': value}) def single_transaction(w3): accounts = w3.eth.accounts - while True: - _from = accounts[random.randint(0, len(accounts) - 1)] - _to = accounts[random.randint(0, len(accounts) - 1)] - value = 50 - tx_hash = w3.eth.sendTransaction({'from': _from, 'to': _to, 'value': value}) - yield tx_hash + _from = accounts[random.randint(0, len(accounts) - 1)] + _to = accounts[random.randint(0, len(accounts) - 1)] + value = 50 + tx_hash = w3.eth.sendTransaction({'from': _from, 'to': _to, 'value': value}) + return tx_hash def test_event_filter_new_events( @@ -57,30 +49,25 @@ def test_event_filter_new_events( expected_match_counter = 0 - tx_padder = pad_with_transactions(web3) - tx_padder.send(None) while web3.eth.blockNumber < 50: is_match = bool(random.randint(0, 1)) if is_match: expected_match_counter += 1 - tx_padder.send(matching_transact) - next(tx_padder) + matching_transact() + pad_with_transactions(web3) continue - tx_padder.send(non_matching_transact) - next(tx_padder) + non_matching_transact() + pad_with_transactions(web3) assert len(event_filter.get_new_entries()) == expected_match_counter -@pytest.mark.xfail +@pytest.mark.xfail(reason="Suspected eth-tester bug") def test_block_filter(web3): block_filter = web3.eth.filter("latest") - tx_padder = pad_with_transactions(web3) - tx_padder.send(None) while web3.eth.blockNumber < 50: - tx_padder.send(lambda: "ok") - next(tx_padder) + pad_with_transactions(web3) assert len(block_filter.get_new_entries()) == web3.eth.blockNumber @@ -92,15 +79,14 @@ def test_transaction_filter_with_mining( transaction_counter = 0 - transact_once = single_transaction(web3) while transaction_counter < 100: - next(transact_once) + single_transaction(web3) transaction_counter += 1 assert len(transaction_filter.get_new_entries()) == transaction_counter -@pytest.mark.xfail +@pytest.mark.xfail(reason="Suspected eth-tester bug") def test_transaction_filter_without_mining( web3): @@ -143,16 +129,14 @@ def gen_non_matching_transact(): expected_match_counter = 0 - tx_padder = pad_with_transactions(web3) - tx_padder.send(None) while web3.eth.blockNumber < 50: is_match = bool(random.randint(0, 1)) if is_match: expected_match_counter += 1 - tx_padder.send(matching_transact) - next(tx_padder) + matching_transact() + pad_with_transactions(web3) continue - tx_padder.send(next(non_matching_transact)) - next(tx_padder) + next(non_matching_transact)() + pad_with_transactions(web3) assert len(event_filter.get_new_entries()) == expected_match_counter