test: use Lock instead of RLock for AsyncLRUCache

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -1026,32 +1026,30 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                     LOAD_LIBRARY_TIME_OUT,
                 )
 
-                if result.stdout:
-                    self._logger.warning(
-                        lambda: f"stdout captured at loading library {name}{repr(args)}:\n{result.stdout}"
-                    )
-                try:
-                    if meta is not None:
-                        meta_file = Path(self.lib_doc_cache_path, meta.filepath_base.with_suffix(".meta.json"))
-                        spec_file = Path(self.lib_doc_cache_path, meta.filepath_base.with_suffix(".spec.json"))
-                        spec_file.parent.mkdir(parents=True, exist_ok=True)
+            if result.stdout:
+                self._logger.warning(lambda: f"stdout captured at loading library {name}{repr(args)}:\n{result.stdout}")
+            try:
+                if meta is not None:
+                    meta_file = Path(self.lib_doc_cache_path, meta.filepath_base.with_suffix(".meta.json"))
+                    spec_file = Path(self.lib_doc_cache_path, meta.filepath_base.with_suffix(".spec.json"))
+                    spec_file.parent.mkdir(parents=True, exist_ok=True)
 
-                        try:
-                            spec_file.write_text(as_json(result), "utf-8")
-                        except (SystemExit, KeyboardInterrupt):
-                            raise
-                        except BaseException as e:
-                            raise RuntimeError(f"Cannot write spec file for library '{name}' to '{spec_file}'") from e
+                    try:
+                        spec_file.write_text(as_json(result), "utf-8")
+                    except (SystemExit, KeyboardInterrupt):
+                        raise
+                    except BaseException as e:
+                        raise RuntimeError(f"Cannot write spec file for library '{name}' to '{spec_file}'") from e
 
-                        meta_file.write_text(as_json(meta), "utf-8")
-                    else:
-                        self._logger.debug(lambda: f"Skip caching library {name}{repr(args)}")
-                except (SystemExit, KeyboardInterrupt):
-                    raise
-                except BaseException as e:
-                    self._logger.exception(e)
+                    meta_file.write_text(as_json(meta), "utf-8")
+                else:
+                    self._logger.debug(lambda: f"Skip caching library {name}{repr(args)}")
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except BaseException as e:
+                self._logger.exception(e)
 
-                return result
+            return result
 
         resolved_args = resolve_args(
             args,

robotcode/utils/async_cache.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Tuple, TypeVar, cast
 
-from .async_tools import RLock
+from .async_tools import Lock
 
 _T = TypeVar("_T")
 
@@ -16,7 +16,7 @@ class CacheEntry:
     def __init__(self) -> None:
         self.data: Any = None
         self.has_data: bool = False
-        self.lock = RLock()
+        self.lock = Lock()
 
 
 class AsyncSimpleLRUCache:
@@ -27,7 +27,7 @@ def __init__(self, max_items: Optional[int] = 128) -> None:
         self._order: Optional[List[Tuple[Any, ...]]] = None
         if self.max_items:
             self._order = []
-        self._lock = RLock()
+        self._lock = Lock()
 
     async def has(self, *args: Any, **kwargs: Any) -> bool:
         key = self._make_key(*args, **kwargs)