derivepassphrase.git

@@ -186,11 +186,13 @@ class SocketProvider:

             """

             for alias in [name, *aliases]:

                 try:

-                    existing = cls.resolve(alias)

+                    existing = cls.lookup(alias)

                 except (NoSuchProviderError, NotImplementedError):

                     cls.registry[alias] = f if alias == name else name

                 else:

-                    if existing != f:

+                    if existing is None:

+                        cls.registry[alias] = f if alias == name else name

+                    elif existing != f:

                         msg = (

                             f'The SSH agent socket provider {alias!r} '

                             f'is already registered.'

@@ -200,10 +202,36 @@ class SocketProvider:

         return decorator

+    @classmethod

+    def lookup(

+        cls, provider: _types.SSHAgentSocketProvider | str | None, /

+    ) -> _types.SSHAgentSocketProvider | None:

+        """Look up a socket provider entry.

+

+        Args:

+            provider: The provider to look up.

+

+        Returns:

+            The callable indicated by this provider, if it is

+            implemented, or `None`, if it is merely registered.

+

+        Raises:

+            NoSuchProviderError:

+                The provider is not registered.

+

+        """

+        ret = provider

+        while isinstance(ret, str):

+            try:

+                ret = cls.registry[ret]

+            except KeyError as exc:

+                raise NoSuchProviderError(ret) from exc

+        return ret

+

     @classmethod

     def resolve(

-        cls, provider: Callable[[], _types.SSHAgentSocket] | str | None, /

-    ) -> Callable[[], _types.SSHAgentSocket]:

+        cls, provider: _types.SSHAgentSocketProvider | str | None, /

+    ) -> _types.SSHAgentSocketProvider:

         """Resolve a socket provider to a proper callable.

         Args:

@@ -220,12 +248,7 @@ class SocketProvider:

                 applicable to this `derivepassphrase` installation.

         """

-        ret = provider

-        while isinstance(ret, str):

-            try:

-                ret = cls.registry[ret]

-            except KeyError as exc:

-                raise NoSuchProviderError(ret) from exc

+        ret = cls.lookup(provider)

         if ret is None:

             msg = (

                 f'The {ret!r} socket provider is not functional on or '

@@ -764,11 +764,9 @@ class SystemSupportAction(str, enum.Enum):

                 | None

             )

             try:

-                intended = socketprovider.SocketProvider.resolve(provider)

+                intended = socketprovider.SocketProvider.lookup(provider)

             except socketprovider.NoSuchProviderError as exc:

                 intended = exc

-            except NotImplementedError:

-                intended = None

             actual: (

                 _types.SSHAgentSocketProvider

                 | socketprovider.NoSuchProviderError

@@ -776,10 +774,10 @@ class SystemSupportAction(str, enum.Enum):

             )

             for name in ssh_agent.SSHAgentClient.SOCKET_PROVIDERS:

                 try:

-                    actual = socketprovider.SocketProvider.resolve(name)

+                    actual = socketprovider.SocketProvider.lookup(name)

                 except socketprovider.NoSuchProviderError as exc:

                     actual = exc

-                except NotImplementedError:

+                if actual is None:

                     continue

                 break

             else:

@@ -927,9 +927,12 @@ class TestStaticFunctionality:

         """Resolving entries in the socket provider registry works."""

         registry = socketprovider.SocketProvider.registry

         resolve = socketprovider.SocketProvider.resolve

+        lookup = socketprovider.SocketProvider.lookup

         with pytest.MonkeyPatch.context() as monkeypatch:

             monkeypatch.setitem(registry, 'stub_agent', None)

+            assert callable(lookup('native'))

             assert callable(resolve('native'))

+            assert lookup('stub_agent') is None

             with pytest.raises(NotImplementedError):

                 resolve('stub_agent')

@@ -942,6 +945,7 @@ class TestStaticFunctionality:

         """Resolving a chain of providers works."""

         registry = socketprovider.SocketProvider.registry

         resolve = socketprovider.SocketProvider.resolve

+        lookup = socketprovider.SocketProvider.lookup

         try:

             implementation = resolve('native')

         except NotImplementedError:  # pragma: no cover

@@ -959,11 +963,15 @@ class TestStaticFunctionality:

             for link in chain:

                 monkeypatch.setitem(registry, link, target)

                 target = link

+            for link in chain:

+                assert lookup(link) == (

+                    implementation if terminal != 'unimplemented' else None

+                )

                 if terminal == 'unimplemented':

                     with pytest.raises(NotImplementedError):

-                    resolve(chain[-1])

+                        resolve(link)

                 else:

-                assert resolve(chain[-1]) == implementation

+                    assert resolve(link) == implementation

     @hypothesis.given(

         terminal=strategies.sampled_from([

@@ -996,6 +1004,7 @@ class TestStaticFunctionality:

         """Resolving a chain of providers works."""

         registry = socketprovider.SocketProvider.registry

         resolve = socketprovider.SocketProvider.resolve

+        lookup = socketprovider.SocketProvider.lookup

         try:

             implementation = resolve('native')

         except NotImplementedError:  # pragma: no cover

@@ -1014,11 +1023,15 @@ class TestStaticFunctionality:

             for link in chain:

                 monkeypatch.setitem(registry, link, target)

                 target = link

+            for link in chain:

+                assert lookup(link) == (

+                    implementation if terminal != 'unimplemented' else None

+                )

                 if terminal == 'unimplemented':

                     with pytest.raises(NotImplementedError):

-                    resolve(chain[-1])

+                        resolve(link)

                 else:

-                assert resolve(chain[-1]) == implementation

+                    assert resolve(link) == implementation

     @Parametrize.GOOD_ENTRY_POINTS

     def test_230_find_all_socket_providers(

@@ -1664,32 +1677,6 @@ class TestAgentInteraction:

                 client.query_extensions()

-def safe_resolve(name: str) -> _types.SSHAgentSocketProvider | None:

-    """Safely resolve an SSH agent socket provider name.

-

-    If the provider is merely reserved, return `None` instead of raising

-    an exception.  Otherwise behave like

-    [`socketprovider.SocketProvider.resolve`][] does.

-

-    Args:

-        name: The name of the provider to resolve.

-

-    Returns:

-        The SSH agent socket provider if registered, `None` if merely

-        reserved, and an error if not found.

-

-    Raises:

-        socketprovider.NoSuchProviderError:

-            No such provider was found in the registry.  This includes

-            entries that are merely reserved.

-

-    """

-    try:

-        return socketprovider.SocketProvider.resolve(name)

-    except NotImplementedError:  # pragma: no cover

-        return None

-

-

 @strategies.composite

 def draw_alias_chain(

     draw: strategies.DrawFn,

@@ -1841,7 +1828,9 @@ class SSHAgentSocketProviderRegistryStateMachine(

     )

     def get_registry_keys(self) -> stateful.MultipleResults[str]:

         """Read the standard keys from the registry."""

-        self.model.update({k: safe_resolve(k) for k in self.registry})

+        self.model.update({

+            k: socketprovider.SocketProvider.lookup(k) for k in self.registry

+        })

         return stateful.multiple(*self.registry.keys())

     @stateful.rule(

@@ -1855,12 +1844,13 @@ class SSHAgentSocketProviderRegistryStateMachine(

     @stateful.invariant()

     def check_consistency(self) -> None:

+        lookup = socketprovider.SocketProvider.lookup

         assert self.registry.keys() == self.model.keys()

         for k in self.model:

-            resolved = safe_resolve(k)

+            resolved = lookup(k)

             modelled = self.model[k]

             step1 = self.registry[k]

-            manually = safe_resolve(step1) if isinstance(step1, str) else step1

+            manually = lookup(step1) if isinstance(step1, str) else step1

             assert resolved == modelled

             assert resolved == manually