Add more tests

- Also do some clean up of the iterators with recursion

tests/core/filtering/conftest.py

@@ -7,6 +7,33 @@
     event_signature_to_log_topic,
 )
 
+from web3 import Web3
+from web3.providers.eth_tester import EthereumTesterProvider
+
+from web3.middleware import (
+    filter_middleware,
+)
+
+
+@pytest.fixture(params=[True, False], ids=['middleware_filter', 'node_filter'])
+def web3(request):
+    provider = EthereumTesterProvider()
+    w3 = Web3(provider)
+
+    # Delete this whole block after eth-account has passed security audit
+    try:
+        w3.eth.account
+    except AttributeError:
+        pass
+    else:
+        raise AssertionError("Unaudited features must be disabled by default")
+    w3.eth.enable_unaudited_features()
+
+    if request.param:
+        w3.middleware_stack.add(filter_middleware)
+
+    return w3
+
 
 @pytest.fixture(autouse=True)
 def wait_for_mining_start(web3, wait_for_block):

tests/core/middleware/test_filter_middleware.py

@@ -8,8 +8,9 @@
 from web3.providers.base import (
     BaseProvider,
 )
-from web3.providers.eth_tester import (
-    EthereumTesterProvider,
+from web3.middleware.filter import (
+    range_counter,
+    iter_latest_block_ranges,
 )
 
 
@@ -21,56 +22,109 @@ def make_request(self, method, params):
         ))
 
 
-@pytest.fixture(scope='session')
-def result_generator_middleware():
+@pytest.fixture(scope='module')
+def iter_block_number(start=0):
+    def iterator():
+        block_number = start
+        while True:
+            sent_value = (yield block_number)
+            if sent_value is not None:
+                block_number = sent_value
+    return iterator()
+
+
+@pytest.fixture(scope='module')
+def result_generator_middleware(iter_block_number):
     return construct_result_generator_middleware({
-        'eth_getLogs': lambda *args: args,
+        'eth_getLogs': lambda *args: [],
         'net_version': lambda *_: 1,
+        'eth_blockNumber': lambda *_: next(iter_block_number),
     })
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope='module')
 def w3_base():
     return Web3(providers=[DummyProvider()], middlewares=[])
 
 
-@pytest.fixture(scope='session')
-def w3():
-    w3 = Web3(EthereumTesterProvider())
-    w3.middleware_stack.add(filter_middleware)
-    return w3
-
-
-@pytest.fixture(scope='session')
-def w3_dummy(w3_base, result_generator_middleware):
+@pytest.fixture(scope='module')
+def w3(w3_base, result_generator_middleware):
     w3_base.middleware_stack.add(result_generator_middleware)
     w3_base.middleware_stack.add(filter_middleware)
+    w3_base.eth.filter(filter_params={'fromBlock': 'latest'})
     return w3_base
 
 
-def test_filter_middleware_in_stack(w3_dummy):
-    assert filter_middleware in tuple(w3_dummy.middleware_stack)
-
-
-@pytest.fixture(scope='function')
-def new_filter(web3):
-    _filter = web3.eth.filter(filter_params={'fromBlock': 'latest'})
-    return _filter
-
-
-def test_eth_create_new_filter(
-        web3,
-        new_filter,
-        emitter,
-        Emitter,
-        emitter_event_ids,
-        wait_for_transaction):
-
-    txn_hash = emitter.functions.logNoArgs(emitter_event_ids.LogNoArguments).transact()
-    wait_for_transaction(web3, txn_hash)
-    assert len(new_filter.get_new_entries()) == 1
-    txn_hash = emitter.functions.logNoArgs(emitter_event_ids.LogNoArguments).transact()
-    wait_for_transaction(web3, txn_hash)
-    txn_hash = emitter.functions.logNoArgs(emitter_event_ids.LogNoArguments).transact()
-    wait_for_transaction(web3, txn_hash)
-    assert len(new_filter.get_new_entries()) == 2
+@pytest.mark.parametrize("start, stop, expected", [
+    (0, 12, [
+        (0, 4),
+        (5, 9),
+        (10, 12)
+    ]),
+    (0, 15, [
+        (0, 4),
+        (5, 9),
+        (10, 14),
+        (15, 15)
+    ]),
+    (0, 0, [
+        (0, 0),
+    ]),
+    (1, 1, [
+        (1, 1),
+    ]),
+    (5, 0, TypeError),
+])
+def test_range_counter(start, stop, expected):
+    if isinstance(expected, type) and issubclass(expected, Exception):
+        with pytest.raises(expected):
+            range_counter(start, stop)
+    else:
+        for actual, expected in zip(range_counter(start, stop), expected):
+            assert actual == expected
+
+
+@pytest.mark.parametrize("from_block,to_block,current_block,expected", [
+    (0, 10, [10], [
+        (0, 10),
+    ]),
+    (0, 55, [0, 19, 55], [
+        (0, 0),
+        (1, 19),
+        (20, 55),
+    ]),
+])
+def test_iter_latest_block_ranges(
+        w3,
+        iter_block_number,
+        from_block,
+        to_block,
+        current_block,
+        expected):
+    latest_block_ranges = iter_latest_block_ranges(w3, from_block, to_block)
+    next(iter_block_number)
+    for index, block in enumerate(current_block):
+        iter_block_number.send(block)
+        expected_tuple = expected[index]
+        try:
+            actual_tuple = next(latest_block_ranges)
+        except StopIteration as e:
+            if e:
+                actual_tuple = e.value
+
+        assert actual_tuple == expected_tuple
+
+
+@pytest.mark.parametrize("method,args,expected", [
+    ('eth_newFilter', [{}], '0x1'),
+    ('eth_newPendingBlockFilter', [{}], NotImplementedError),
+    ('eth_newBlockFilter', [{}], NotImplementedError),
+    ('eth_getFilterChanges', ['0x0'], []),
+    ('eth_getLogChanges', ['0x0'], NotImplementedError),
+])
+def test_filter_middleware(w3, method, args, expected):
+    if isinstance(expected, type) and issubclass(expected, Exception):
+        with pytest.raises(expected):
+            w3.manager.request_blocking(method, args)
+    else:
+        assert w3.manager.request_blocking(method, args) == expected