improve types according to test/test_refdb_backend.py

also renamed testrepo to self in ProxyRefdbBackend class

Author: BenediktSeidl

pygit2/_pygit2.pyi

@@ -643,7 +643,9 @@ class Refdb:
 class RefdbBackend:
     def __init__(self, *args, **kwargs) -> None: ...
     def compress(self) -> None: ...
-    def delete(self, ref_name: str, old_id: _OidArg, old_target: str) -> None: ...
+    def delete(
+        self, ref_name: str, old_id: _OidArg, old_target: str | None
+    ) -> None: ...
     def ensure_log(self, ref_name: str) -> bool: ...
     def exists(self, refname: str) -> bool: ...
     def has_log(self, ref_name: str) -> bool: ...
@@ -657,9 +659,10 @@ class RefdbBackend:
         force: bool,
         who: Signature,
         message: str,
-        old: _OidArg,
-        old_target: str,
+        old: None | _OidArg,
+        old_target: None | str,
     ) -> None: ...
+    def __iter__(self) -> Iterator[Reference]: ...
 
 class RefdbFsBackend(RefdbBackend):
     def __init__(self, *args, **kwargs) -> None: ...
@@ -738,6 +741,7 @@ class Branches:
 class Repository:
     _pointer: GitRepositoryC
     _repo: GitRepositoryC
+    backend: RefdbBackend
     default_signature: Signature
     head: Reference
     head_is_detached: bool

test/test_refdb_backend.py

@@ -26,10 +26,12 @@
 """Tests for Refdb objects."""
 
 from pathlib import Path
+from typing import Generator, Iterator
 
 import pytest
 
 import pygit2
+from pygit2 import Commit, Oid, Reference, Repository, Signature
 
 
 # Note: the refdb abstraction from libgit2 is meant to provide information
@@ -38,90 +40,101 @@
 # incomplete, to avoid hitting the semi-valid states that refdbs produce by
 # design.
 class ProxyRefdbBackend(pygit2.RefdbBackend):
-    def __init__(testrepo, source):
-        testrepo.source = source
+    def __init__(self, source: pygit2.RefdbBackend) -> None:
+        self.source = source
 
-    def exists(testrepo, ref):
-        return testrepo.source.exists(ref)
+    def exists(self, ref: str) -> bool:
+        return self.source.exists(ref)
 
-    def lookup(testrepo, ref):
-        return testrepo.source.lookup(ref)
+    def lookup(self, ref: str) -> Reference:
+        return self.source.lookup(ref)
 
-    def write(testrepo, ref, force, who, message, old, old_target):
-        return testrepo.source.write(ref, force, who, message, old, old_target)
+    def write(
+        self,
+        ref: Reference,
+        force: bool,
+        who: Signature,
+        message: str,
+        old: None | str | Oid,
+        old_target: None | str,
+    ) -> None:
+        return self.source.write(ref, force, who, message, old, old_target)
 
-    def rename(testrepo, old_name, new_name, force, who, message):
-        return testrepo.source.rename(old_name, new_name, force, who, message)
+    def rename(
+        self, old_name: str, new_name: str, force: bool, who: Signature, message: str
+    ) -> Reference:
+        return self.source.rename(old_name, new_name, force, who, message)
 
-    def delete(testrepo, ref_name, old_id, old_target):
-        return testrepo.source.delete(ref_name, old_id, old_target)
+    def delete(self, ref_name: str, old_id: Oid | str, old_target: str | None) -> None:
+        return self.source.delete(ref_name, old_id, old_target)
 
-    def compress(testrepo):
-        return testrepo.source.compress()
+    def compress(self) -> None:
+        return self.source.compress()
 
-    def has_log(testrepo, ref_name):
-        return testrepo.source.has_log(ref_name)
+    def has_log(self, ref_name: str) -> bool:
+        return self.source.has_log(ref_name)
 
-    def ensure_log(testrepo, ref_name):
-        return testrepo.source.ensure_log(ref_name)
+    def ensure_log(self, ref_name: str) -> bool:
+        return self.source.ensure_log(ref_name)
 
-    def __iter__(testrepo):
-        return iter(testrepo.source)
+    def __iter__(self) -> Iterator[Reference]:
+        return iter(self.source)
 
 
 @pytest.fixture
-def repo(testrepo):
+def repo(testrepo: Repository) -> Generator[Repository, None, None]:
     testrepo.backend = ProxyRefdbBackend(pygit2.RefdbFsBackend(testrepo))
     yield testrepo
 
 
-def test_exists(repo):
+def test_exists(repo: Repository) -> None:
     assert not repo.backend.exists('refs/heads/does-not-exist')
     assert repo.backend.exists('refs/heads/master')
 
 
-def test_lookup(repo):
+def test_lookup(repo: Repository) -> None:
     assert repo.backend.lookup('refs/heads/does-not-exist') is None
     assert repo.backend.lookup('refs/heads/master').name == 'refs/heads/master'
 
 
-def test_write(repo):
+def test_write(repo: Repository) -> None:
     master = repo.backend.lookup('refs/heads/master')
-    commit = repo.get(master.target)
+    commit = repo[master.target]
     ref = pygit2.Reference('refs/heads/test-write', master.target, None)
     repo.backend.write(ref, False, commit.author, 'Create test-write', None, None)
     assert repo.backend.lookup('refs/heads/test-write').target == master.target
 
 
-def test_rename(repo):
+def test_rename(repo: Repository) -> None:
     old_ref = repo.backend.lookup('refs/heads/i18n')
     target = repo.get(old_ref.target)
+    assert isinstance(target, Commit)
     repo.backend.rename(
         'refs/heads/i18n', 'refs/heads/intl', False, target.committer, target.message
     )
     assert repo.backend.lookup('refs/heads/intl').target == target.id
 
 
-def test_delete(repo):
+def test_delete(repo: Repository) -> None:
     old = repo.backend.lookup('refs/heads/i18n')
     repo.backend.delete('refs/heads/i18n', old.target, None)
     assert not repo.backend.lookup('refs/heads/i18n')
 
 
-def test_compress(repo):
+def test_compress(repo: Repository) -> None:
     repo = repo
     packed_refs_file = Path(repo.path) / 'packed-refs'
     assert not packed_refs_file.exists()
     repo.backend.compress()
     assert packed_refs_file.exists()
 
 
-def test_has_log(repo):
+def test_has_log(repo: Repository) -> None:
     assert repo.backend.has_log('refs/heads/master')
     assert not repo.backend.has_log('refs/heads/does-not-exist')
 
 
-def test_ensure_log(repo):
+def test_ensure_log(repo: Repository) -> None:
     assert not repo.backend.has_log('refs/heads/new-log')
     repo.backend.ensure_log('refs/heads/new-log')
     assert repo.backend.has_log('refs/heads/new-log')