Initial pass with pydocstringformatter over tests (#1949)

Co-authored-by: Pierre Sassoulas <[email protected]>
(cherry picked from commit e259af2)

Author: DanielNoord

tests/test_brain_regex.py

@@ -26,7 +26,7 @@ def test_regex_flags(self) -> None:
 
     @test_utils.require_version(minver="3.9")
     def test_regex_pattern_and_match_subscriptable(self):
-        """Test regex.Pattern and regex.Match are subscriptable in PY39+"""
+        """Test regex.Pattern and regex.Match are subscriptable in PY39+."""
         node1 = builder.extract_node(
             """
         import regex

tests/unittest_brain_ctypes.py

@@ -57,8 +57,8 @@
     ],
 )
 def test_ctypes_redefined_types_members(c_type, builtin_type, type_code):
-    """
-    Test that the "value" and "_type_" member of each redefined types are correct
+    """Test that the "value" and "_type_" member of each redefined types are
+    correct.
     """
     src = f"""
     import ctypes
@@ -102,7 +102,8 @@ def test_cdata_member_access() -> None:
 
 def test_other_ctypes_member_untouched() -> None:
     """
-    Test that other ctypes members, which are not touched by the brain, are correctly inferred
+    Test that other ctypes members, which are not touched by the brain, are correctly
+    inferred.
     """
     src = """
     import ctypes

tests/unittest_brain_dataclasses.py

@@ -74,7 +74,8 @@ class A:
 @parametrize_module
 def test_inference_field_default(module: str):
     """Test inference of dataclass attribute with a field call default
-    (default keyword argument given)."""
+    (default keyword argument given).
+    """
     klass, instance = astroid.extract_node(
         f"""
     from {module} import dataclass
@@ -105,7 +106,8 @@ class A:
 @parametrize_module
 def test_inference_field_default_factory(module: str):
     """Test inference of dataclass attribute with a field call default
-    (default_factory keyword argument given)."""
+    (default_factory keyword argument given).
+    """
     klass, instance = astroid.extract_node(
         f"""
     from {module} import dataclass
@@ -406,7 +408,7 @@ class A:
 
 @parametrize_module
 def test_init_empty(module: str):
-    """Test init for a dataclass with no attributes"""
+    """Test init for a dataclass with no attributes."""
     node = astroid.extract_node(
         f"""
     from {module} import dataclass
@@ -424,7 +426,7 @@ class A:
 
 @parametrize_module
 def test_init_no_defaults(module: str):
-    """Test init for a dataclass with attributes and no defaults"""
+    """Test init for a dataclass with attributes and no defaults."""
     node = astroid.extract_node(
         f"""
     from {module} import dataclass
@@ -451,7 +453,7 @@ class A:
 
 @parametrize_module
 def test_init_defaults(module: str):
-    """Test init for a dataclass with attributes and some defaults"""
+    """Test init for a dataclass with attributes and some defaults."""
     node = astroid.extract_node(
         f"""
     from {module} import dataclass
@@ -486,7 +488,7 @@ class A:
 
 @parametrize_module
 def test_init_initvar(module: str):
-    """Test init for a dataclass with attributes and an InitVar"""
+    """Test init for a dataclass with attributes and an InitVar."""
     node = astroid.extract_node(
         f"""
     from {module} import dataclass
@@ -602,7 +604,8 @@ class B(A):
 
 @parametrize_module
 def test_init_attributes_from_superclasses(module: str):
-    """Test init for a dataclass that inherits and overrides attributes from superclasses.
+    """Test init for a dataclass that inherits and overrides attributes from
+    superclasses.
 
     Based on https://github.com/PyCQA/pylint/issues/3201
     """
@@ -636,7 +639,9 @@ class B(A):
 
 @parametrize_module
 def test_invalid_init(module: str):
-    """Test that astroid doesn't generate an initializer when attribute order is invalid."""
+    """Test that astroid doesn't generate an initializer when attribute order is
+    invalid.
+    """
     node = astroid.extract_node(
         f"""
     from {module} import dataclass
@@ -655,7 +660,9 @@ class A:
 
 @parametrize_module
 def test_annotated_enclosed_field_call(module: str):
-    """Test inference of dataclass attribute with a field call in another function call"""
+    """Test inference of dataclass attribute with a field call in another function
+    call.
+    """
     node = astroid.extract_node(
         f"""
     from {module} import dataclass, field

tests/unittest_brain_numpy_core_einsumfunc.py

@@ -29,9 +29,7 @@ def _inferred_numpy_func_call(func_name: str, *func_args: str) -> nodes.Function
 
 @pytest.mark.skipif(not HAS_NUMPY, reason="This test requires the numpy library.")
 def test_numpy_function_calls_inferred_as_ndarray() -> None:
-    """
-    Test that calls to numpy functions are inferred as numpy.ndarray
-    """
+    """Test that calls to numpy functions are inferred as numpy.ndarray."""
     method = "einsum"
     inferred_values = list(
         _inferred_numpy_func_call(method, "ii, np.arange(25).reshape(5, 5)")

tests/unittest_brain_numpy_core_fromnumeric.py

@@ -16,9 +16,7 @@
 
 @unittest.skipUnless(HAS_NUMPY, "This test requires the numpy library.")
 class BrainNumpyCoreFromNumericTest(unittest.TestCase):
-    """
-    Test the numpy core fromnumeric brain module
-    """
+    """Test the numpy core fromnumeric brain module."""
 
     numpy_functions = (("sum", "[1, 2]"),)
 
@@ -33,9 +31,7 @@ def _inferred_numpy_func_call(self, func_name, *func_args):
         return node.infer()
 
     def test_numpy_function_calls_inferred_as_ndarray(self):
-        """
-        Test that calls to numpy functions are inferred as numpy.ndarray
-        """
+        """Test that calls to numpy functions are inferred as numpy.ndarray."""
         licit_array_types = (".ndarray",)
         for func_ in self.numpy_functions:
             with self.subTest(typ=func_):

tests/unittest_brain_numpy_core_function_base.py

@@ -16,9 +16,7 @@
 
 @unittest.skipUnless(HAS_NUMPY, "This test requires the numpy library.")
 class BrainNumpyCoreFunctionBaseTest(unittest.TestCase):
-    """
-    Test the numpy core numeric brain module
-    """
+    """Test the numpy core numeric brain module."""
 
     numpy_functions = (
         ("linspace", "1, 100"),
@@ -37,9 +35,7 @@ def _inferred_numpy_func_call(self, func_name, *func_args):
         return node.infer()
 
     def test_numpy_function_calls_inferred_as_ndarray(self):
-        """
-        Test that calls to numpy functions are inferred as numpy.ndarray
-        """
+        """Test that calls to numpy functions are inferred as numpy.ndarray."""
         licit_array_types = (".ndarray",)
         for func_ in self.numpy_functions:
             with self.subTest(typ=func_):

tests/unittest_brain_numpy_core_multiarray.py

@@ -16,9 +16,7 @@
 
 @unittest.skipUnless(HAS_NUMPY, "This test requires the numpy library.")
 class BrainNumpyCoreMultiarrayTest(unittest.TestCase):
-    """
-    Test the numpy core multiarray brain module
-    """
+    """Test the numpy core multiarray brain module."""
 
     numpy_functions_returning_array = (
         ("array", "[1, 2]"),
@@ -82,9 +80,7 @@ def _inferred_numpy_no_alias_func_call(self, func_name, *func_args):
         return node.infer()
 
     def test_numpy_function_calls_inferred_as_ndarray(self):
-        """
-        Test that calls to numpy functions are inferred as numpy.ndarray
-        """
+        """Test that calls to numpy functions are inferred as numpy.ndarray."""
         for infer_wrapper in (
             self._inferred_numpy_func_call,
             self._inferred_numpy_no_alias_func_call,
@@ -106,9 +102,7 @@ def test_numpy_function_calls_inferred_as_ndarray(self):
                     )
 
     def test_numpy_function_calls_inferred_as_bool(self):
-        """
-        Test that calls to numpy functions are inferred as bool
-        """
+        """Test that calls to numpy functions are inferred as bool."""
         for infer_wrapper in (
             self._inferred_numpy_func_call,
             self._inferred_numpy_no_alias_func_call,
@@ -130,9 +124,7 @@ def test_numpy_function_calls_inferred_as_bool(self):
                     )
 
     def test_numpy_function_calls_inferred_as_dtype(self):
-        """
-        Test that calls to numpy functions are inferred as numpy.dtype
-        """
+        """Test that calls to numpy functions are inferred as numpy.dtype."""
         for infer_wrapper in (
             self._inferred_numpy_func_call,
             self._inferred_numpy_no_alias_func_call,
@@ -154,9 +146,7 @@ def test_numpy_function_calls_inferred_as_dtype(self):
                     )
 
     def test_numpy_function_calls_inferred_as_none(self):
-        """
-        Test that calls to numpy functions are inferred as None
-        """
+        """Test that calls to numpy functions are inferred as None."""
         for infer_wrapper in (
             self._inferred_numpy_func_call,
             self._inferred_numpy_no_alias_func_call,
@@ -178,9 +168,7 @@ def test_numpy_function_calls_inferred_as_none(self):
                     )
 
     def test_numpy_function_calls_inferred_as_tuple(self):
-        """
-        Test that calls to numpy functions are inferred as tuple
-        """
+        """Test that calls to numpy functions are inferred as tuple."""
         for infer_wrapper in (
             self._inferred_numpy_func_call,
             self._inferred_numpy_no_alias_func_call,

tests/unittest_brain_numpy_core_numeric.py

@@ -20,9 +20,7 @@
 
 @unittest.skipUnless(HAS_NUMPY, "This test requires the numpy library.")
 class BrainNumpyCoreNumericTest(unittest.TestCase):
-    """
-    Test the numpy core numeric brain module
-    """
+    """Test the numpy core numeric brain module."""
 
     numpy_functions = (
         ("zeros_like", "[1, 2]"),
@@ -42,9 +40,7 @@ def _inferred_numpy_func_call(self, func_name, *func_args):
         return node.infer()
 
     def test_numpy_function_calls_inferred_as_ndarray(self):
-        """
-        Test that calls to numpy functions are inferred as numpy.ndarray
-        """
+        """Test that calls to numpy functions are inferred as numpy.ndarray."""
         licit_array_types = (".ndarray",)
         for func_ in self.numpy_functions:
             with self.subTest(typ=func_):

tests/unittest_brain_numpy_core_numerictypes.py

@@ -21,9 +21,7 @@
 
 @unittest.skipUnless(HAS_NUMPY, "This test requires the numpy library.")
 class NumpyBrainCoreNumericTypesTest(unittest.TestCase):
-    """
-    Test of all the missing types defined in numerictypes module.
-    """
+    """Test of all the missing types defined in numerictypes module."""
 
     all_types = [
         "uint16",
@@ -87,18 +85,14 @@ def _inferred_numpy_attribute(self, attrib):
         return next(node.value.infer())
 
     def test_numpy_core_types(self):
-        """
-        Test that all defined types have ClassDef type.
-        """
+        """Test that all defined types have ClassDef type."""
         for typ in self.all_types:
             with self.subTest(typ=typ):
                 inferred = self._inferred_numpy_attribute(typ)
                 self.assertIsInstance(inferred, nodes.ClassDef)
 
     def test_generic_types_have_methods(self):
-        """
-        Test that all generic derived types have specified methods
-        """
+        """Test that all generic derived types have specified methods."""
         generic_methods = [
             "all",
             "any",
@@ -210,9 +204,7 @@ def test_generic_types_have_methods(self):
                         self.assertTrue(meth in {m.name for m in inferred.methods()})
 
     def test_generic_types_have_attributes(self):
-        """
-        Test that all generic derived types have specified attributes
-        """
+        """Test that all generic derived types have specified attributes."""
         generic_attr = [
             "base",
             "data",
@@ -270,9 +262,7 @@ def test_generic_types_have_attributes(self):
                         self.assertNotEqual(len(inferred.getattr(attr)), 0)
 
     def test_number_types_have_unary_operators(self):
-        """
-        Test that number types have unary operators
-        """
+        """Test that number types have unary operators."""
         unary_ops = ("__neg__",)
 
         for type_ in (
@@ -301,9 +291,7 @@ def test_number_types_have_unary_operators(self):
                         self.assertNotEqual(len(inferred.getattr(attr)), 0)
 
     def test_array_types_have_unary_operators(self):
-        """
-        Test that array types have unary operators
-        """
+        """Test that array types have unary operators."""
         unary_ops = ("__neg__", "__invert__")
 
         for type_ in ("ndarray",):
@@ -346,9 +334,7 @@ def test_datetime_astype_return(self):
         f"This test requires the numpy library with a version above {NUMPY_VERSION_TYPE_HINTS_SUPPORT}",
     )
     def test_generic_types_are_subscriptables(self):
-        """
-        Test that all types deriving from generic are subscriptables
-        """
+        """Test that all types deriving from generic are subscriptables."""
         for type_ in (
             "bool_",
             "bytes_",
@@ -401,19 +387,20 @@ def test_generic_types_are_subscriptables(self):
 class NumpyBrainUtilsTest(unittest.TestCase):
     """
     This class is dedicated to test that astroid does not crash
-    if numpy module is not available
+    if numpy module is not available.
     """
 
     def test_get_numpy_version_do_not_crash(self):
         """
-        Test that the function _get_numpy_version doesn't crash even if numpy is not installed
+        Test that the function _get_numpy_version doesn't crash even if numpy is not
+        installed.
         """
         self.assertEqual(_get_numpy_version(), ("0", "0", "0"))
 
     def test_numpy_object_uninferable(self):
         """
         Test that in case numpy is not available, then a numpy object is uninferable
-        but the inference doesn't lead to a crash
+        but the inference doesn't lead to a crash.
         """
         src = """
         import numpy as np