Redis INCR DECR Counter Mock in Python

Simulate Redis INCR and DECR commands with a Python class to test counter logic without a live Redis server.

Easy Python 3.9+ Aug 9, 2026 Caching & Redis 16 views 0 copies

Python code

37 lines
Python 3.9+
class RedisCounter:
    def __init__(self):
        self._store = {}

    def incr(self, key: str, amount: int = 1) -> int:
        if key not in self._store:
            self._store[key] = 0
        self._store[key] += amount
        return self._store[key]

    def decr(self, key: str, amount: int = 1) -> int:
        if key not in self._store:
            self._store[key] = 0
        self._store[key] -= amount
        return self._store[key]

    def get(self, key: str) -> int:
        return self._store.get(key, 0)

    def delete(self, key: str) -> bool:
        if key in self._store:
            del self._store[key]
            return True
        return False


if __name__ == "__main__":
    redis_mock = RedisCounter()

    print("Initial get('visits'):", redis_mock.get("visits"))
    print("INCR visits:", redis_mock.incr("visits"))
    print("INCR visits by 5:", redis_mock.incr("visits", 5))
    print("DECR visits:", redis_mock.decr("visits"))
    print("DECR likes:", redis_mock.decr("likes", 3))
    print("Final get('visits'):", redis_mock.get("visits"))
    print("Delete visits:", redis_mock.delete("visits"))
    print("Get visits after delete:", redis_mock.get("visits"))

Output

stdout
Initial get('visits'): 0
INCR visits: 1
INCR visits by 5: 6
DECR visits: 5
DECR likes: -3
Final get('visits'): 5
Delete visits: True
Get visits after delete: 0

How it works

The mock class stores counters in a plain dictionary, mapping string keys to integer values. Atomicity is simulated by the fact that Python operations are synchronous, but real Redis guarantees atomicity at the server level. Using get with a default of 0 ensures missing keys behave like Redis counters, starting at zero. The delete method mirrors Redis's DEL command, returning True when the key existed. In production, replace this with a real Redis client to gain persistence and concurrency safety.

Common mistakes

  • Assuming the mock is thread-safe; use a lock or real Redis for concurrent access.
  • Forgetting to initialize a key to 0 before incrementing, though the mock handles it automatically.
  • Returning None for missing counters instead of 0 as Redis does.

Variations

  1. Use `collections.Counter` as a base and override methods for Redis-like behavior.
  2. Implement a context manager to auto-close a real Redis connection after use.

Real-world use cases

  • Testing rate-limiting logic that uses INCR and EXPIRE without setting up a local Redis instance.
  • Developing and unit-testing analytics dashboards that track page view counts in a CI environment.
  • Prototyping a leaderboard or ranking feature locally before hooking it to a managed Redis service.

Sponsored

Run this sample

Open the browser IDE to tweak the example and see results without installing anything.

Open editor

More from Caching & Redis

Related tutorials and quizzes for this topic.