Check ImportMode exhaustively

Author: bluetech

src/_pytest/compat.py

@@ -33,6 +33,7 @@
 
 
 if TYPE_CHECKING:
+    from typing import NoReturn
     from typing import Type
     from typing_extensions import Final
 
@@ -401,3 +402,38 @@ def __get__(self, instance, owner=None):  # noqa: F811
     from collections import OrderedDict
 
     order_preserving_dict = OrderedDict
+
+
+# Perform exhaustiveness checking.
+#
+# Consider this example:
+#
+#     MyUnion = Union[int, str]
+#
+#     def handle(x: MyUnion) -> int {
+#         if isinstance(x, int):
+#             return 1
+#         elif isinstance(x, str):
+#             return 2
+#         else:
+#             raise Exception('unreachable')
+#
+# Now suppose we add a new variant:
+#
+#     MyUnion = Union[int, str, bytes]
+#
+# After doing this, we must remember ourselves to go and update the handle
+# function to handle the new variant.
+#
+# With `assert_never` we can do better:
+#
+#     // throw new Error('unreachable');
+#     return assert_never(x)
+#
+# Now, if we forget to handle the new variant, the type-checker will emit a
+# compile-time error, instead of the runtime error we would have gotten
+# previously.
+#
+# This also work for Enums (if you use `is` to compare) and Literals.
+def assert_never(value: "NoReturn") -> "NoReturn":
+    assert False, "Unhandled value: {} ({})".format(value, type(value).__name__)

src/_pytest/pathlib.py

@@ -25,6 +25,7 @@
 
 import py
 
+from _pytest.compat import assert_never
 from _pytest.outcomes import skip
 from _pytest.warning_types import PytestWarning
 
@@ -470,7 +471,7 @@ def import_path(
     if not path.exists():
         raise ImportError(path)
 
-    if mode == ImportMode.importlib:
+    if mode is ImportMode.importlib:
         module_name = path.stem
 
         for meta_importer in sys.meta_path:
@@ -502,13 +503,14 @@ def import_path(
     # change sys.path permanently: restoring it at the end of this function would cause surprising
     # problems because of delayed imports: for example, a conftest.py file imported by this function
     # might have local imports, which would fail at runtime if we restored sys.path.
-    if mode == ImportMode.append:
+    if mode is ImportMode.append:
         if str(pkg_root) not in sys.path:
             sys.path.append(str(pkg_root))
-    else:
-        assert mode == ImportMode.prepend, "unexpected mode: {}".format(mode)
+    elif mode is ImportMode.prepend:
         if str(pkg_root) != sys.path[0]:
             sys.path.insert(0, str(pkg_root))
+    else:
+        assert_never(mode)
 
     importlib.import_module(module_name)
 

testing/test_compat.py

@@ -1,16 +1,23 @@
+import enum
 import sys
 from functools import partial
 from functools import wraps
+from typing import Union
 
 import pytest
 from _pytest.compat import _PytestWrapper
+from _pytest.compat import assert_never
 from _pytest.compat import cached_property
 from _pytest.compat import get_real_func
 from _pytest.compat import is_generator
 from _pytest.compat import safe_getattr
 from _pytest.compat import safe_isclass
+from _pytest.compat import TYPE_CHECKING
 from _pytest.outcomes import OutcomeException
 
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
 
 def test_is_generator():
     def zap():
@@ -205,3 +212,55 @@ def prop(self) -> int:
     assert ncalls == 1
     assert c2.prop == 2
     assert c1.prop == 1
+
+
+def test_assert_never_union() -> None:
+    x = 10  # type: Union[int, str]
+
+    if isinstance(x, int):
+        pass
+    else:
+        with pytest.raises(AssertionError):
+            assert_never(x)  # type: ignore[arg-type]
+
+    if isinstance(x, int):
+        pass
+    elif isinstance(x, str):
+        pass
+    else:
+        assert_never(x)
+
+
+def test_assert_never_enum() -> None:
+    E = enum.Enum("E", "a b")
+    x = E.a  # type: E
+
+    if x is E.a:
+        pass
+    else:
+        with pytest.raises(AssertionError):
+            assert_never(x)  # type: ignore[arg-type]
+
+    if x is E.a:
+        pass
+    elif x is E.b:
+        pass
+    else:
+        assert_never(x)
+
+
+def test_assert_never_literal() -> None:
+    x = "a"  # type: Literal["a", "b"]
+
+    if x == "a":
+        pass
+    else:
+        with pytest.raises(AssertionError):
+            assert_never(x)  # type: ignore[arg-type]
+
+    if x == "a":
+        pass
+    elif x == "b":
+        pass
+    else:
+        assert_never(x)