Add tests for detecting race conditions

.github/workflows/workflow-ci.yml

@@ -101,7 +101,7 @@ jobs:
       packages: write
     strategy:
       matrix:
-        pypy-version: [ '3.10']
+        pypy-version: ['3.10']
 
     steps:
       - uses: actions/checkout@v4
@@ -138,9 +138,53 @@ jobs:
           && .venv/bin/pytest
           "
 
+  free-threading-test:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        image-name: ['quay.io/pypa/manylinux_2_28_x86_64']
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Prepare Docker
+        run: |
+          docker login "$CACHE_REGISTRY" -u "$CACHE_REGISTRY_USERNAME" --password="${CACHE_REGISTRY_TOKEN}"
+          docker buildx create --use --driver=docker-container
+          docker --version && docker compose --version
+
+      - name: Load cached venv
+        id: cached-venv
+        uses: actions/cache@v4
+        with:
+          path: |
+            .venv
+          key: free-threading${{ matrix.image-name }}-${{ hashFiles('./poetry.lock') }}
+
+      - name: Pull docker image
+        run: |
+          docker pull ${{ matrix.image-name }}
+          docker tag ${{ matrix.image-name }} free-threading-image
+
+      - name: Run checks
+        run: >
+          docker run -e VIRTUAL_ENV=/opt/code/.venv --rm -v $(pwd):/opt/code -w /opt/code
+          free-threading-image bash -c "
+          if [ ! -d .venv ]; then
+            python3.13t -m venv .venv;
+          fi
+          && .venv/bin/pip install pytest pytest-asyncio pytest-cov pytest-randomly pytest-race pytest-repeat
+          && .venv/bin/pip install --no-deps -e .
+          && .venv/bin/python -VV
+          && .venv/bin/pytest --ignore=tests/test_integrations
+          "
+
   release-package:
     runs-on: ubuntu-latest
-    needs: [ check-code ]
+    needs: [check-code, pypy-test, free-threading-test]
 
     steps:
       - uses: actions/checkout@v4

CHANGELOG.md

@@ -6,6 +6,8 @@ We follow [Semantic Versions](https://semver.org/).
 
 - Removed dead code
 - Added `init_dependencies` marker for pytest
+- Added tests for detecting race conditions
+- Added Python 3.13-free-threading to CI
 
 ## Version 0.27.0
 

picodi/_picodi.py

@@ -89,10 +89,9 @@ def add(
                 )
 
     def get(self, dependency: DependencyCallable) -> Provider:
-        with self._storage.lock:
-            dependency = self.get_dep_or_override(dependency)
-            self._storage.touched_dependencies.add(dependency)
-            return self._storage.deps[dependency]
+        dependency = self.get_dep_or_override(dependency)
+        self._storage.touched_dependencies.add(dependency)
+        return self._storage.deps[dependency]
 
     def get_dep_or_override(self, dependency: DependencyCallable) -> DependencyCallable:
         return self._storage.overrides.get(dependency, dependency)
@@ -210,27 +209,24 @@ def clear_overrides(self) -> None:
         """
         Clear all overrides. It will remove all overrides, but keep the dependencies.
         """
-        with self._storage.lock:
-            self._storage.overrides.clear()
+        self._storage.overrides.clear()
 
     def clear_touched(self) -> None:
         """
         Clear the touched dependencies.
         It will remove all dependencies resolved during the picodi lifecycle.
         """
-        with self._storage.lock:
-            self._storage.touched_dependencies.clear()
+        self._storage.touched_dependencies.clear()
 
     def clear(self) -> None:
         """
         Clear the registry. It will remove all dependencies and overrides.
         This method will not close any dependencies. So you need to manually call
         :func:`shutdown_dependencies` before this method.
         """
-        with self._storage.lock:
-            self._storage.deps.clear()
-            self._storage.overrides.clear()
-            self._storage.touched_dependencies.clear()
+        self._storage.deps.clear()
+        self._storage.overrides.clear()
+        self._storage.touched_dependencies.clear()
 
 
 _registry_storage = RegistryStorage()
@@ -241,7 +237,6 @@ def clear(self) -> None:
     SingletonScope: SingletonScope(),
     ContextVarScope: ContextVarScope(),
 }
-_lock = threading.RLock()
 
 
 def Provide(dependency: DependencyCallable, /) -> Any:  # noqa: N802
@@ -727,6 +722,9 @@ def _extract_and_register_dependency_from_parameter(
     return None
 
 
+_lock = threading.RLock()
+
+
 class LazyResolver:
     def __init__(
         self,

pyproject.toml

@@ -42,6 +42,8 @@ httpx = "^0.27.0"
 pytest-markdown-docs = "^0.5.1"
 sphinx = ">=7.3.7,<9.0.0"
 furo = "^2024.5.6"
+pytest-race = "0.2.0"
+pytest-repeat = "^0.9.3"
 
 [tool.isort]
 # isort configuration:

tests/test_race.py

@@ -0,0 +1,49 @@
+import asyncio
+from random import randint
+
+import pytest
+
+from picodi import Provide, SingletonScope, dependency, inject
+
+
+@pytest.mark.repeat(5)
+def test_scope_resolving_races(start_race):
+    @dependency(scope_class=SingletonScope)
+    def get_random_int():
+        return randint(1, 10000)
+
+    @inject
+    def service(num: int = Provide(get_random_int)):
+        return num
+
+    results = []
+
+    def actual_test():
+        results.append(service())
+
+    start_race(threads_num=8, target=actual_test)
+
+    assert len(set(results)) == 1, results
+
+
+@pytest.mark.repeat(5)
+def test_scope_resolving_races_async(start_race):
+    @dependency(scope_class=SingletonScope)
+    async def get_random_int():
+        return randint(1, 10000)
+
+    @inject
+    async def service(num: int = Provide(get_random_int)):
+        return num
+
+    results = []
+
+    async def main():
+        results.append(await service())
+
+    def actual_test():
+        asyncio.run(main())
+
+    start_race(threads_num=8, target=actual_test)
+
+    assert len(set(results)) == 1, results