async def test_should_increase_request_cache_count( self, async_cache, request_cache_key, should_not_open_rule ): await async_cache.set(request_cache_key, 0) async with CircuitBreaker( rule=should_not_open_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError,), ): await success_function() with pytest.raises(ValueError): async with CircuitBreaker( rule=should_not_open_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError,), ): await fail_function() assert await async_cache.get(request_cache_key) == 2
async def test_should_delete_count_key_when_circuit_is_open( self, async_cache, should_open_rule, failure_cache_key, request_cache_key ): await asyncio.gather( async_cache.set(failure_cache_key, 2), async_cache.set(request_cache_key, 5) ) with pytest.raises(MyException): async with CircuitBreaker( rule=should_open_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError,), ) as cb: await fail_function() assert await cb.is_circuit_open() assert await async_cache.get(failure_cache_key) is None assert await async_cache.get(request_cache_key) is None
async def test_should_not_increment_request_when_circuit_is_open( self, async_cache, should_open_rule, failure_cache_key, request_cache_key ): """ It should not increment request count over the max failures limit, when circuit breaker is open after a successful enter. """ await asyncio.gather( async_cache.set(failure_cache_key, 2), async_cache.set(request_cache_key, 5) ) with pytest.raises(MyException): async with CircuitBreaker( rule=should_open_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError,), ): await fail_function() assert (await async_cache.get(request_cache_key)) is None
async def test_should_exec_func_with_success(self, async_cache, should_not_open_rule): async with CircuitBreaker(rule=should_not_open_rule, cache=async_cache, failure_exception=ValueError, catch_exceptions=[]): await success_function()
async def test_should_raise_error(self, async_cache, should_open_rule): with pytest.raises(MyException): async with CircuitBreaker( rule=should_open_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError,), ): await fail_function()
async def test_should_raise_exception_when_circuit_is_open( self, async_cache, should_open_rule, failure_cache_key): circuit_cache_key = f'circuit_{failure_cache_key}' await async_cache.set(circuit_cache_key, 1) with pytest.raises(MyException): async with CircuitBreaker( rule=should_open_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError, ), ) as cb: await success_function() assert await cb.is_circuit_open()
async def test_should_not_increment_failure_when_rule_is_false( self, async_cache, should_not_increase_failure_rule, failure_cache_key): await async_cache.set(failure_cache_key, 5) with pytest.raises(ValueError): async with CircuitBreaker( rule=should_not_increase_failure_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError, ), ): await fail_function() assert await async_cache.get(failure_cache_key) == 5
async def test_should_create_failure_cache_when_increase_request_count( self, async_cache, should_not_open_rule, failure_cache_key, request_cache_key, ): assert await async_cache.get(failure_cache_key) is None async with CircuitBreaker( rule=should_not_open_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError,), ): await success_function() assert await async_cache.get(failure_cache_key) == 0
async def test_should_open_circuit_when_failures_exceeds( self, async_cache, should_open_rule, failure_cache_key, ): await async_cache.set(failure_cache_key, 3) with pytest.raises(MyException): async with CircuitBreaker( rule=should_open_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError,), ) as cb: await fail_function() assert await cb.is_circuit_open()
async def test_should_not_call_exit_when_circuit_is_open( self, async_cache, should_open_rule, failure_cache_key): circuit_cache_key = f'circuit_{failure_cache_key}' await async_cache.set(circuit_cache_key, 1) with pytest.raises(MyException): with mock.patch( 'lasier.circuit_breaker.asyncio.CircuitBreaker.__aexit__' ) as exit_method: async with CircuitBreaker( rule=should_open_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError, ), ): await success_function() assert not exit_method.called
async def test_should_create_failure_cache_when_no_request_cache_key( self, async_cache, should_not_open_rule_without_request_cache_key, failure_cache_key, request_cache_key, ): assert await async_cache.get(failure_cache_key) is None with pytest.raises(ValueError): async with CircuitBreaker( rule=should_not_open_rule_without_request_cache_key, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError, ), ): await fail_function() assert await async_cache.get(failure_cache_key) == 1
async def test_should_call_expire_if_incr_returns_one( self, async_cache, should_not_open_rule): future = asyncio.Future() future.set_result(None) with mock.patch.object(async_cache, 'expire', return_value=future, autospec=True) as mock_expire: for _ in range(5): with pytest.raises(ValueError): async with CircuitBreaker( rule=should_not_open_rule, cache=async_cache, failure_exception=MyException, catch_exceptions=(ValueError, ), ): await fail_function() # for request and fail count assert mock_expire.call_count == 2