Fix types in test directory

Author: snejus

setup.cfg

@@ -24,3 +24,6 @@ allow_untyped_calls = true
 # FIXME: Would be better to actually type the libraries (if under our control),
 # or write our own stubs. For now, silence errors
 strict = true
+
+[mypy-test.*]
+allow_untyped_defs = true

test/__init__.py

@@ -1,11 +1,17 @@
+from __future__ import annotations
+
 import os
 import shutil
 import tempfile
+from typing import TYPE_CHECKING, Any
 
 import confuse
 
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
 
-def _root(*sources):
+def _root(*sources: Mapping[str, Any]) -> confuse.RootView:
     return confuse.RootView([confuse.ConfigSource.of(s) for s in sources])
 
 

test/test_dump.py

@@ -1,5 +1,6 @@
 import textwrap
 import unittest
+from collections import OrderedDict
 
 import confuse
 
@@ -32,7 +33,7 @@ def test_dump_short_list(self):
         assert yaml == "foo: [bar, baz]"
 
     def test_dump_ordered_dict(self):
-        odict = confuse.OrderedDict()
+        odict = OrderedDict()
         odict["foo"] = "bar"
         odict["bar"] = "baz"
         odict["baz"] = "qux"

test/test_env.py

@@ -1,21 +1,21 @@
 import os
 import unittest
+from unittest.mock import patch
 
 import pytest
 
 import confuse
 
 from . import _root
 
-ENVIRON = os.environ
-
 
 class EnvSourceTest(unittest.TestCase):
     def setUp(self):
-        os.environ = {}
+        self.env_patcher = patch.dict("os.environ", {})
+        self.env_patcher.start()
 
     def tearDown(self):
-        os.environ = ENVIRON
+        self.env_patcher.stop()
 
     def test_prefix(self):
         os.environ["TEST_FOO"] = "a"
@@ -235,16 +235,17 @@ def test_parse_yaml_docs_false(self):
 
 class ConfigEnvTest(unittest.TestCase):
     def setUp(self):
+        self.env_patcher = patch.dict(
+            "os.environ",
+            {
+                "TESTAPP_FOO": "a",
+                "TESTAPP_BAR__NESTED": "b",
+                "TESTAPP_BAZ_SEP_NESTED": "c",
+                "MYAPP_QUX_SEP_NESTED": "d",
+            },
+        )
+        self.env_patcher.start()
         self.config = confuse.Configuration("TestApp", read=False)
-        os.environ = {
-            "TESTAPP_FOO": "a",
-            "TESTAPP_BAR__NESTED": "b",
-            "TESTAPP_BAZ_SEP_NESTED": "c",
-            "MYAPP_QUX_SEP_NESTED": "d",
-        }
-
-    def tearDown(self):
-        os.environ = ENVIRON
 
     def test_defaults(self):
         self.config.set_env()

test/test_paths.py

@@ -10,19 +10,18 @@
 import confuse
 import confuse.yaml_util
 
-DEFAULT = [platform.system, os.environ, os.path]
-
+DEFAULT = (platform.system, os.environ, os.path)
 SYSTEMS = {
-    "Linux": [{"HOME": "/home/test", "XDG_CONFIG_HOME": "~/xdgconfig"}, posixpath],
-    "Darwin": [{"HOME": "/Users/test"}, posixpath],
-    "Windows": [
+    "Linux": ({"HOME": "/home/test", "XDG_CONFIG_HOME": "~/xdgconfig"}, posixpath),
+    "Darwin": ({"HOME": "/Users/test"}, posixpath),
+    "Windows": (
         {
             "APPDATA": "~\\winconfig",
             "HOME": "C:\\Users\\test",
             "USERPROFILE": "C:\\Users\\test",
         },
         ntpath,
-    ],
+    ),
 }
 
 
@@ -48,10 +47,10 @@ class FakeSystem(unittest.TestCase):
     def setUp(self):
         super().setUp()
         self.os_path = os.path
-        os.environ = {}
+        os.environ = {}  # type: ignore[assignment]
 
         environ, os.path = SYSTEMS[self.SYS_NAME]
-        os.environ.update(environ)  # copy
+        os.environ.update(environ)
         platform.system = lambda: self.SYS_NAME
 
     def tearDown(self):
@@ -128,11 +127,11 @@ def test_fallback_dir(self):
 class ConfigFilenamesTest(unittest.TestCase):
     def setUp(self):
         self._old = os.path.isfile, confuse.yaml_util.load_yaml
-        os.path.isfile = lambda x: True
+        os.path.isfile = lambda x: True  # type: ignore[assignment]
         confuse.yaml_util.load_yaml = lambda *args, **kwargs: {}
 
     def tearDown(self):
-        confuse.yaml_util.load_yaml, os.path.isfile = self._old
+        os.path.isfile, confuse.yaml_util.load_yaml = self._old
 
     def test_no_sources_when_files_missing(self):
         config = confuse.Configuration("myapp", read=False)
@@ -173,7 +172,7 @@ def test_env_var_missing(self):
         assert self.config.config_dir() != self.home
 
 
-@unittest.skipUnless(os.system == "Linux", "Linux-specific tests")
+@unittest.skipUnless(platform.system() == "Linux", "Linux-specific tests")
 class PrimaryConfigDirTest(FakeHome, FakeSystem):
     SYS_NAME = "Linux"  # conversion from posix to nt is easy
 

test/test_utils.py

@@ -1,6 +1,7 @@
 import unittest
 from argparse import Namespace
 from collections import OrderedDict
+from typing import Any
 
 import pytest
 
@@ -20,15 +21,15 @@ def test_namespaces(self):
         assert 1 == result["another"]
 
     def test_dot_sep_keys(self):
-        config = {"foo.bar": 1}
+        config: dict[str, Any] = {"foo.bar": 1}
         result = confuse.util.build_dict(config.copy())
         assert 1 == result["foo.bar"]
 
         result = confuse.util.build_dict(config.copy(), sep=".")
         assert 1 == result["foo"]["bar"]
 
     def test_dot_sep_keys_clobber(self):
-        args = [("foo.bar", 1), ("foo.bar.zar", 2)]
+        args: list[tuple[str, Any]] = [("foo.bar", 1), ("foo.bar.zar", 2)]
         config = OrderedDict(args)
         result = confuse.util.build_dict(config.copy(), sep=".")
         assert {"zar": 2} == result["foo"]["bar"]
@@ -42,15 +43,19 @@ def test_dot_sep_keys_clobber(self):
         assert 2 == result["foo"]["bar"]["zar"]
 
     def test_dot_sep_keys_no_clobber(self):
-        args = [("foo.bar", 1), ("foo.far", 2), ("foo.zar.dar", 4)]
+        args: list[tuple[str, Any]] = [
+            ("foo.bar", 1),
+            ("foo.far", 2),
+            ("foo.zar.dar", 4),
+        ]
         config = OrderedDict(args)
         result = confuse.util.build_dict(config.copy(), sep=".")
         assert 1 == result["foo"]["bar"]
         assert 2 == result["foo"]["far"]
         assert 4 == result["foo"]["zar"]["dar"]
 
     def test_adjacent_underscores_sep_keys(self):
-        config = {"foo__bar_baz": 1}
+        config: dict[str, Any] = {"foo__bar_baz": 1}
         result = confuse.util.build_dict(config.copy())
         assert 1 == result["foo__bar_baz"]
 

test/test_valid.py

@@ -2,6 +2,7 @@
 import os
 import unittest
 from collections.abc import Mapping, Sequence
+from typing import Any
 
 import pytest
 
@@ -69,29 +70,13 @@ def test_validate_individual_value(self):
         assert valid == 5
 
     def test_nested_dict_template(self):
-        config = _root(
-            {
-                "foo": {"bar": 9},
-            }
-        )
-        valid = config.get(
-            {
-                "foo": {"bar": confuse.Integer()},
-            }
-        )
+        config = _root({"foo": {"bar": 9}})
+        valid = config.get({"foo": {"bar": confuse.Integer()}})
         assert valid["foo"]["bar"] == 9
 
     def test_nested_attribute_access(self):
-        config = _root(
-            {
-                "foo": {"bar": 8},
-            }
-        )
-        valid = config.get(
-            {
-                "foo": {"bar": confuse.Integer()},
-            }
-        )
+        config = _root({"foo": {"bar": 8}})
+        valid = config.get({"foo": {"bar": confuse.Integer()}})
         assert valid.foo.bar == 8
 
 
@@ -132,12 +117,12 @@ def test_nested_dict_as_template(self):
         assert typ.subtemplates["outer"].subtemplates["inner"].default == 2
 
     def test_list_as_template(self):
-        typ = confuse.as_template(list())
+        typ: confuse.OneOf[Any] = confuse.as_template(list())
         assert isinstance(typ, confuse.OneOf)
         assert typ.default == confuse.REQUIRED
 
     def test_set_as_template(self):
-        typ = confuse.as_template(set())
+        typ: confuse.Choice[Any] = confuse.as_template(set())
         assert isinstance(typ, confuse.Choice)
 
     def test_enum_type_as_template(self):
@@ -275,7 +260,7 @@ def test_default_value(self):
 
     def test_validate_good_choice_in_list(self):
         config = _root({"foo": 2})
-        valid = config["foo"].get(
+        valid: str | int = config["foo"].get(
             confuse.OneOf(
                 [
                     confuse.String(),
@@ -287,7 +272,7 @@ def test_validate_good_choice_in_list(self):
 
     def test_validate_first_good_choice_in_list(self):
         config = _root({"foo": 3.14})
-        valid = config["foo"].get(
+        valid: str | int = config["foo"].get(
             confuse.OneOf(
                 [
                     confuse.Integer(),
@@ -315,7 +300,7 @@ class BadTemplate:
 
         config = _root({})
         with pytest.raises(ValueError, match="cannot convert to template"):
-            config.get(confuse.OneOf([BadTemplate()]))
+            config.get(confuse.OneOf([BadTemplate()]))  # type: ignore[list-item]
         del BadTemplate
 
 
@@ -416,7 +401,7 @@ def test_filename_with_non_file_source(self):
     def test_filename_with_file_source(self):
         source = confuse.ConfigSource({"foo": "foo/bar"}, filename="/baz/config.yaml")
         config = _root(source)
-        config.config_dir = lambda: "/config/path"
+        config.config_dir = lambda: "/config/path"  # type: ignore[attr-defined]
         valid = config["foo"].get(confuse.Filename())
         assert valid == os.path.realpath("/config/path/foo/bar")
 
@@ -425,7 +410,7 @@ def test_filename_with_default_source(self):
             {"foo": "foo/bar"}, filename="/baz/config.yaml", default=True
         )
         config = _root(source)
-        config.config_dir = lambda: "/config/path"
+        config.config_dir = lambda: "/config/path"  # type: ignore[attr-defined]
         valid = config["foo"].get(confuse.Filename())
         assert valid == os.path.realpath("/config/path/foo/bar")
 
@@ -434,28 +419,28 @@ def test_filename_use_config_source_dir(self):
             {"foo": "foo/bar"}, filename="/baz/config.yaml", base_for_paths=True
         )
         config = _root(source)
-        config.config_dir = lambda: "/config/path"
+        config.config_dir = lambda: "/config/path"  # type: ignore[attr-defined]
         valid = config["foo"].get(confuse.Filename())
         assert valid == os.path.realpath("/baz/foo/bar")
 
     def test_filename_in_source_dir(self):
         source = confuse.ConfigSource({"foo": "foo/bar"}, filename="/baz/config.yaml")
         config = _root(source)
-        config.config_dir = lambda: "/config/path"
+        config.config_dir = lambda: "/config/path"  # type: ignore[attr-defined]
         valid = config["foo"].get(confuse.Filename(in_source_dir=True))
         assert valid == os.path.realpath("/baz/foo/bar")
 
     def test_filename_in_source_dir_overrides_in_app_dir(self):
         source = confuse.ConfigSource({"foo": "foo/bar"}, filename="/baz/config.yaml")
         config = _root(source)
-        config.config_dir = lambda: "/config/path"
+        config.config_dir = lambda: "/config/path"  # type: ignore[attr-defined]
         valid = config["foo"].get(confuse.Filename(in_source_dir=True, in_app_dir=True))
         assert valid == os.path.realpath("/baz/foo/bar")
 
     def test_filename_in_app_dir_non_file_source(self):
         source = confuse.ConfigSource({"foo": "foo/bar"})
         config = _root(source)
-        config.config_dir = lambda: "/config/path"
+        config.config_dir = lambda: "/config/path"  # type: ignore[attr-defined]
         valid = config["foo"].get(confuse.Filename(in_app_dir=True))
         assert valid == os.path.realpath("/config/path/foo/bar")
 
@@ -464,7 +449,7 @@ def test_filename_in_app_dir_overrides_config_source_dir(self):
             {"foo": "foo/bar"}, filename="/baz/config.yaml", base_for_paths=True
         )
         config = _root(source)
-        config.config_dir = lambda: "/config/path"
+        config.config_dir = lambda: "/config/path"  # type: ignore[attr-defined]
         valid = config["foo"].get(confuse.Filename(in_app_dir=True))
         assert valid == os.path.realpath("/config/path/foo/bar")
 
@@ -503,7 +488,7 @@ def test_missing_required_value(self):
 class BaseTemplateTest(unittest.TestCase):
     def test_base_template_accepts_any_value(self):
         config = _root({"foo": 4.2})
-        valid = config["foo"].get(confuse.Template())
+        valid: float = config["foo"].get(confuse.Template())
         assert valid == 4.2
 
     def test_base_template_required(self):
@@ -576,7 +561,9 @@ def test_dict_dict(self):
         config = _root(
             {"foo": {"first": {"bar": 1, "baz": 2}, "second": {"bar": 3, "baz": 4}}}
         )
-        valid = config["foo"].get(confuse.MappingValues({"bar": int, "baz": int}))
+        valid: dict[str, dict[str, int]] = config["foo"].get(
+            confuse.MappingValues({"bar": int, "baz": int})
+        )
         assert valid == {"first": {"bar": 1, "baz": 2}, "second": {"bar": 3, "baz": 4}}
 
     def test_invalid_item(self):
@@ -656,6 +643,7 @@ def test_optional_mapping_template_valid(self):
         config = _root({"foo": {"bar": 5, "baz": "bak"}})
         template = {"bar": confuse.Integer(), "baz": confuse.String()}
         valid = config.get({"foo": confuse.Optional(template)})
+        assert valid["foo"]
         assert valid["foo"]["bar"] == 5
         assert valid["foo"]["baz"] == "bak"