test: cover edge-case exception and branch paths

Add tests for the remaining uncovered error/edge-case branches:

- Binder.provider_for raising UnknownProvider for an unbindable target
- Module configuration re-raising NameError for an unresolvable forward
  reference in a @Provider return annotation
- create_object wrapping a __new__ TypeError in a CallError
- _infer_injected_bindings dropping Union members marked NoInject
- Injector.get unwrapping a ScopeDecorator to its underlying scope

Also mark the import-time logger-level guard with `# pragma: no branch`:
its else-branch is only reachable on a fresh import with a pre-set level,
which can't be exercised in-process without importlib.reload corrupting
shared marker state for the rest of the suite.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: KrzysztofMadejski

injector/__init__.py

@@ -53,7 +53,7 @@
 log = logging.getLogger('injector')
 log.addHandler(logging.NullHandler())
 
-if log.level == logging.NOTSET:
+if log.level == logging.NOTSET:  # pragma: no branch
     log.setLevel(logging.WARN)
 
 T = TypeVar('T')

injector_100_percent_coverage_test.py

@@ -5,11 +5,21 @@
 rarely-hit edge-case/error branches purely to drive coverage to 100%.
 """
 
-from typing import Dict, List
+from typing import Dict, List, Union
 
-import injector
-from injector import UnsatisfiedRequirement
+import pytest
 
+import injector
+from injector import (
+    CallError,
+    Injector,
+    Module,
+    NoInject,
+    UnknownProvider,
+    UnsatisfiedRequirement,
+    provider,
+    singleton,
+)
 
 # --- String / representation formatting --------------------------------------
 
@@ -59,3 +69,60 @@ class FakeDictAlias:
 
     assert injector._get_origin(FakeListAlias) is list
     assert injector._get_origin(FakeDictAlias) is dict
+
+
+# --- Edge-case exception / branch paths --------------------------------------
+
+
+def test_provider_for_unknown_target_raises():
+    # Neither a class, callable, provider nor a recognized bindable instance –
+    # provider_for can't figure out what to do and raises UnknownProvider.
+    binder = Injector().binder
+    with pytest.raises(UnknownProvider):
+        binder.provider_for(123, to=123)
+
+
+def test_unresolvable_forward_reference_in_provider_raises_name_error():
+    # The return annotation is a forward reference to a name that never exists,
+    # so it stays "__deferred__" and re-evaluation at configure time fails.
+    class BrokenModule(Module):
+        @provider
+        def provide(self) -> 'ThisNameNeverExists':  # noqa: F821
+            return object()
+
+    with pytest.raises(NameError, match='forward reference'):
+        Injector([BrokenModule])
+
+
+def test_create_object_wraps_new_type_error_in_call_error():
+    # ``cls.__new__(cls)`` raises TypeError (extra required arg), which gets
+    # re-raised as a CallError.
+    class NeedsArg:
+        def __new__(cls, required):
+            return super().__new__(cls)
+
+    with pytest.raises(CallError):
+        Injector().create_object(NeedsArg)
+
+
+def test_union_member_marked_noinject_is_dropped():
+    # A Union whose members carry the NoInject marker is removed from the
+    # inferred bindings.
+    def target(x: Union[NoInject[int], str]):
+        pass
+
+    bindings = injector._infer_injected_bindings(target, only_explicit_bindings=False)
+    assert 'x' not in bindings
+
+
+def test_get_with_scope_decorator_unwraps_to_scope():
+    # Passing a ScopeDecorator (e.g. ``singleton``) to Injector.get unwraps it
+    # to the underlying scope before resolving.
+    class Service:
+        pass
+
+    inj = Injector()
+    first = inj.get(Service, scope=singleton)
+    second = inj.get(Service, scope=singleton)
+    assert isinstance(first, Service)
+    assert first is second