Refactor cache and add tests for it.

No longer inheirts from dict, that was kinda whack.

Author: Crozzers

screen_brightness_control/helpers.py

@@ -11,7 +11,7 @@
 from abc import ABC, abstractclassmethod
 from dataclasses import dataclass, field
 from functools import lru_cache
-from typing import Callable, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from .exceptions import (EDIDParseError, MaxRetriesExceededError,  # noqa:F401
                          ScreenBrightnessError, format_exc)
@@ -185,46 +185,45 @@ def _gdi(cls) -> List[dict]:
         ...
 
 
-class __Cache(dict):
+class __Cache:
     '''class to cache data with a short shelf life'''
 
     def __init__(self):
+        self.logger = logger.getChild(f'{self.__class__.__name__}_{id(self)}')
         self.enabled = True
-        super().__init__()
+        self._store: Dict[str, Tuple[Any, float]] = {}
 
-    def get(self, key, *args, **kwargs):
+    def get(self, key):
         if not self.enabled:
             return None
 
         try:
-            value, expires, orig_args, orig_kwargs = self[key]
+            value, expires = self._store[key]
             if time.time() < expires:
-                if orig_args == args and orig_kwargs == kwargs:
-                    logger.debug(f'cache get {repr(key)}')
-                    return value
-            else:
-                logger.debug(f'cache get {repr(key)} = [expired]')
-                del self[key]
+                self.logger.debug(f'cache get {repr(key)}')
+                return value
+            self.logger.debug(f'cache get {repr(key)} = [expired]')
+            del self._store[key]
         except KeyError:
-            logger.debug(f'cache get {repr(key)} = [KeyError]')
-            pass
+            self.logger.debug(f'cache get {repr(key)} = [KeyError]')
+        return None
 
-    def store(self, key, value, *args, expires=1, **kwargs):
-        self[key] = (value, expires + time.time(), args, kwargs)
-        logger.debug(f'cache set {repr(key)}, expires={expires}')
+    def store(self, key, value, expires=1):
+        self.logger.debug(f'cache set {repr(key)}, expires={expires}')
+        self._store[key] = (value, expires + time.time())
 
     def expire(self, key=None, startswith=None):
         if key is not None:
             try:
-                del self[key]
-                logger.debug(f'cache expire key {repr(key)}')
+                del self._store[key]
+                self.logger.debug(f'cache expire key {repr(key)}')
             except KeyError:
                 pass
         elif startswith is not None:
-            for i in tuple(self.keys()):
+            for i in tuple(self._store.keys()):
                 if i.startswith(startswith):
-                    del self[i]
-                    logger.debug(f'cache expire key {repr(i)}')
+                    del self._store[i]
+                    self.logger.debug(f'cache expire key {repr(i)}')
 
 
 @dataclass

tests/test_helpers.py

@@ -4,6 +4,7 @@
 '''
 import os
 import sys
+import time
 import unittest
 from timeit import timeit
 
@@ -12,6 +13,58 @@
 
 sys.path.insert(0, os.path.abspath('./'))
 import screen_brightness_control as sbc  # noqa: E402
+# for the cache tests. Refs to __Cache get scrambled within classes
+from screen_brightness_control.helpers import __Cache as _Cache
+
+
+class TestCache(unittest.TestCase):
+    cache: _Cache
+
+    def setUp(self):
+        super().setUp()
+        self.cache = _Cache()
+
+    def test_get(self):
+        c_time = time.time()
+        self.cache._store.update({
+            'a': (123, c_time + 1),
+            'b': (456, c_time - 1)
+        })
+
+        self.assertEqual(self.cache.get('a'), 123)
+        self.assertIn('a', self.cache._store)
+        self.assertEqual(self.cache.get('b'), None)
+        # key should have been deleted as expired
+        self.assertNotIn('b', self.cache._store)
+
+    def test_store(self, expires=1):
+        c_time = time.time()
+        self.cache.store('abc', 123, expires=expires)
+        self.assertIn('abc', self.cache._store)
+        item = self.cache._store['abc']
+        self.assertEqual(item[0], 123)
+        self.assertLess((c_time + expires) - item[1], 0.1)
+
+    def test_store_expires(self):
+        self.test_store(3)
+        self.test_store(5)
+        self.test_store(-1)
+
+    def test_expire(self):
+        self.cache._store.update({
+            'a': (123, 0),
+            'b': (123, 0),
+            'bc': (123, 0),
+            'def': (123, 0)
+        })
+        self.cache.expire('a')
+        self.assertNotIn('a', self.cache._store)
+        self.cache.expire(startswith='b')
+        self.assertNotIn('b', self.cache._store)
+        self.assertNotIn('bc', self.cache._store)
+
+        self.assertIn('def', self.cache._store)
+
 
 
 class TestDisplay(TestCase):