add check

MarcoGorelli · MarcoGorelli · commit 18bd5f42ab1b · 2022-12-22T16:37:37.000Z
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -333,3 +333,13 @@ repos:
         additional_dependencies:
         - autotyping==22.9.0
         - libcst==0.4.7
+    -   id: check-test-naming
+        name: test names should start with 'test'
+        entry: python -m scripts.check_test_naming
+        types: [python]
+        files: ^pandas/tests
+        language: python
+        exclude: |
+            (?x)
+            ^pandas/tests/generic/test_generic.py  # 50380
+            |^pandas/tests/io/json/test_readlines.py  # 50378
diff --git a/pandas/tests/computation/test_eval.py b/pandas/tests/computation/test_eval.py
@@ -353,16 +353,6 @@ def test_pow(self, lhs, rhs, engine, parser):
             expected = _eval_single_bin(middle, "**", rhs, engine)
             tm.assert_almost_equal(result, expected)
 
-    def check_single_invert_op(self, lhs, engine, parser):
-        # simple
-        try:
-            elb = lhs.astype(bool)
-        except AttributeError:
-            elb = np.array([bool(lhs)])
-        expected = ~elb
-        result = pd.eval("~elb", engine=engine, parser=parser)
-        tm.assert_almost_equal(expected, result)
-
     def test_frame_invert(self, engine, parser):
         expr = "~lhs"
 
diff --git a/pandas/tests/frame/methods/test_to_timestamp.py b/pandas/tests/frame/methods/test_to_timestamp.py
@@ -121,7 +121,7 @@ def test_to_timestamp_columns(self):
         assert result1.columns.freqstr == "AS-JAN"
         assert result2.columns.freqstr == "AS-JAN"
 
-    def to_timestamp_invalid_axis(self):
+    def test_to_timestamp_invalid_axis(self):
         index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
         obj = DataFrame(np.random.randn(len(index), 5), index=index)
 
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
@@ -1323,10 +1323,6 @@ def test_period_can_hold_element(self, element):
         elem = element(dti)
         self.check_series_setitem(elem, pi, False)
 
-    def check_setting(self, elem, index: Index, inplace: bool):
-        self.check_series_setitem(elem, index, inplace)
-        self.check_frame_setitem(elem, index, inplace)
-
     def check_can_hold_element(self, obj, elem, inplace: bool):
         blk = obj._mgr.blocks[0]
         if inplace:
@@ -1350,23 +1346,6 @@ def check_series_setitem(self, elem, index: Index, inplace: bool):
         else:
             assert ser.dtype == object
 
-    def check_frame_setitem(self, elem, index: Index, inplace: bool):
-        arr = index._data.copy()
-        df = DataFrame(arr)
-
-        self.check_can_hold_element(df, elem, inplace)
-
-        if is_scalar(elem):
-            df.iloc[0, 0] = elem
-        else:
-            df.iloc[: len(elem), 0] = elem
-
-        if inplace:
-            # assertion here implies setting was done inplace
-            assert df._mgr.arrays[0] is arr
-        else:
-            assert df.dtypes[0] == object
-
 
 class TestShouldStore:
     def test_should_store_categorical(self):
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
@@ -11,7 +11,6 @@
 import itertools
 import locale
 from operator import methodcaller
-import os
 from pathlib import Path
 import re
 from shutil import get_terminal_size
@@ -106,11 +105,6 @@ def _assert_filepath_or_buffer_equals(expected):
     return _assert_filepath_or_buffer_equals
 
 
-def curpath():
-    pth, _ = os.path.split(os.path.abspath(__file__))
-    return pth
-
-
 def has_info_repr(df):
     r = repr(df)
     c1 = r.split("\n")[0].startswith("<class")
diff --git a/pandas/tests/io/test_feather.py b/pandas/tests/io/test_feather.py
@@ -113,7 +113,7 @@ def test_read_columns(self):
         columns = ["col1", "col3"]
         self.check_round_trip(df, expected=df[columns], columns=columns)
 
-    def read_columns_different_order(self):
+    def test_read_columns_different_order(self):
         # GH 33878
         df = pd.DataFrame({"A": [1, 2], "B": ["x", "y"], "C": [True, False]})
         self.check_round_trip(df, columns=["B", "A"])
diff --git a/pandas/tests/series/methods/test_explode.py b/pandas/tests/series/methods/test_explode.py
@@ -76,7 +76,7 @@ def test_invert_array():
 @pytest.mark.parametrize(
     "s", [pd.Series([1, 2, 3]), pd.Series(pd.date_range("2019", periods=3, tz="UTC"))]
 )
-def non_object_dtype(s):
+def test_non_object_dtype(s):
     result = s.explode()
     tm.assert_series_equal(result, s)
 
diff --git a/pandas/tests/strings/test_cat.py b/pandas/tests/strings/test_cat.py
@@ -11,7 +11,13 @@
     _testing as tm,
     concat,
 )
-from pandas.tests.strings.test_strings import assert_series_or_index_equal
+
+
+def assert_series_or_index_equal(left, right):
+    if isinstance(left, Series):
+        tm.assert_series_equal(left, right)
+    else:  # Index
+        tm.assert_index_equal(left, right)
 
 
 @pytest.mark.parametrize("other", [None, Series, Index])
diff --git a/pandas/tests/strings/test_strings.py b/pandas/tests/strings/test_strings.py
@@ -26,13 +26,6 @@ def test_startswith_endswith_non_str_patterns(pattern):
         ser.str.endswith(pattern)
 
 
-def assert_series_or_index_equal(left, right):
-    if isinstance(left, Series):
-        tm.assert_series_equal(left, right)
-    else:  # Index
-        tm.assert_index_equal(left, right)
-
-
 # test integer/float dtypes (inferred by constructor) and mixed
 
 
diff --git a/pandas/tests/tseries/offsets/test_dst.py b/pandas/tests/tseries/offsets/test_dst.py
@@ -30,13 +30,18 @@
     YearEnd,
 )
 
-from pandas.tests.tseries.offsets.test_offsets import get_utc_offset_hours
 from pandas.util.version import Version
 
 # error: Module has no attribute "__version__"
 pytz_version = Version(pytz.__version__)  # type: ignore[attr-defined]
 
 
+def get_utc_offset_hours(ts):
+    # take a Timestamp and compute total hours of utc offset
+    o = ts.utcoffset()
+    return (o.days * 24 * 3600 + o.seconds) / 3600.0
+
+
 class TestDST:
 
     # one microsecond before the DST transition
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
@@ -873,12 +873,6 @@ def test_str_for_named_is_name(self):
             assert offset.freqstr == name
 
 
-def get_utc_offset_hours(ts):
-    # take a Timestamp and compute total hours of utc offset
-    o = ts.utcoffset()
-    return (o.days * 24 * 3600 + o.seconds) / 3600.0
-
-
 # ---------------------------------------------------------------------
 
 
diff --git a/scripts/check_test_naming.py b/scripts/check_test_naming.py
@@ -0,0 +1,142 @@
+"""
+Check that test names start with `test`, and that test classes start with `Test`.
+
+This is meant to be run as a pre-commit hook - to run it manually, you can do:
+
+    pre-commit run check-test-naming --all-files
+
+NOTE: if this finds a false positive, you can add the comment `# not a test` to the
+class or function definition. Though hopefully that shouldn't be necessary.
+"""
+import argparse
+import ast
+import os
+from pathlib import Path
+import sys
+
+PRAGMA = "# not a test"
+
+
+def _find_names(node):
+    for _node in ast.walk(node):
+        if isinstance(_node, ast.Name):
+            yield _node.id
+        elif isinstance(_node, ast.Attribute):
+            yield _node.attr
+
+
+def _is_fixture(node):
+    if isinstance(node, ast.Call):
+        node = node.func
+    return (
+        isinstance(node, ast.Attribute)
+        and node.attr == "fixture"
+        and isinstance(node.value, ast.Name)
+        and node.value.id == "pytest"
+    )
+
+
+def _is_register_dtype(node):
+    return isinstance(node, ast.Name) and node.id == "register_extension_dtype"
+
+
+def visit_func(node: ast.FunctionDef, names, line):
+    return (
+        isinstance(node, ast.FunctionDef)
+        and not node.name.startswith("test")
+        and names.count(node.name) == 0
+        and not any(_is_fixture(decorator) for decorator in node.decorator_list)
+        and PRAGMA not in line
+        and not node.name.startswith("_")
+        and node.name
+        not in ("teardown_method", "setup_method", "teardown_class", "setup_class")
+    )
+
+
+def visit_class(node, names, line):
+    return (
+        isinstance(node, ast.ClassDef)
+        and not node.name.startswith("Test")
+        and names.count(node.name) == 0
+        and not any(_is_register_dtype(decorator) for decorator in node.decorator_list)
+        and PRAGMA not in line
+    )
+
+
+def main(content, file):
+    lines = content.splitlines()
+    tree = ast.parse(content)
+    names = list(_find_names(tree))
+    ret = 0
+    for node in tree.body:
+        if visit_func(node, names, lines[node.lineno - 1]):
+            print(
+                f"{file}:{node.lineno}:{node.col_offset} "
+                "found test function which does not start with 'test'"
+            )
+            ret = 1
+        elif visit_class(node, names, lines[node.lineno - 1]):
+            print(
+                f"{file}:{node.lineno}:{node.col_offset} "
+                "found test class which does not start with 'Test'"
+            )
+            ret = 1
+        if (
+            isinstance(node, ast.ClassDef)
+            and names.count(node.name) == 0
+            and not any(
+                _is_register_dtype(decorator) for decorator in node.decorator_list
+            )
+            and PRAGMA not in lines[node.lineno - 1]
+        ):
+            for _node in node.body:
+                if visit_func(_node, names, lines[_node.lineno - 1]):
+                    # It could be that this function is used somewhere by the
+                    # parent class. For example, there might be a base class
+                    # with
+                    #
+                    # class Foo:
+                    #     def foo(self):
+                    #          assert 1+1==2
+                    #     def test_foo(self):
+                    #         self.foo()
+                    #
+                    # and then some subclass overwrites `foo`. So, we check that
+                    # `self.foo` doesn't appear in any of the test classes.
+                    # Note some false negatives might get through, but that's OK.
+                    # This is good enough that has helped identify several examples
+                    # of tests not being run.
+                    should_continue = False
+                    for _file in (Path("pandas") / "tests").rglob("*.py"):
+                        with open(os.path.join(_file)) as fd:
+                            _content = fd.read()
+                        if f"self.{_node.name}" in _content:
+                            should_continue = True
+                            break
+                    if should_continue:
+                        continue
+
+                    print(
+                        f"{file}:{_node.lineno}:{_node.col_offset} "
+                        "found test function which does not start with 'test'"
+                    )
+                    ret = 1
+    return ret
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("paths", nargs="*")
+    args = parser.parse_args()
+
+    ret = 0
+
+    for file in args.paths:
+        filename = os.path.basename(file)
+        if not (filename.startswith("test") and filename.endswith(".py")):
+            continue
+        with open(file, encoding="utf-8") as fd:
+            content = fd.read()
+        ret |= main(content, file)
+
+    sys.exit(ret)
diff --git a/scripts/datetime_tests.sh b/scripts/datetime_tests.sh
@@ -0,0 +1,5 @@
+pytest pandas/tests/tools/test_to_datetime.py \
+pandas/tests/io/parser/test_parse_dates.py \
+pandas/tests/io/parser/usecols/test_parse_dates.py \
+pandas/tests/tslibs/test_parse_iso8601.py \
+pandas/tests/tslibs/test_parsing.py "$@"
diff --git a/scripts/tests/test_check_test_naming.py b/scripts/tests/test_check_test_naming.py
@@ -0,0 +1,54 @@
+import pytest
+
+from scripts.check_test_naming import main
+
+
+@pytest.mark.parametrize(
+    "src, expected_out, expected_ret",
+    [
+        (
+            "def foo(): pass\n",
+            "t.py:1:0 found test function which does not start with 'test'\n",
+            1,
+        ),
+        (
+            "class Foo:\n    def test_foo(): pass\n",
+            "t.py:1:0 found test class which does not start with 'Test'\n",
+            1,
+        ),
+        ("def test_foo(): pass\n", "", 0),
+        (
+            "class TestFoo:\n    def foo(): pass\n",
+            "t.py:2:4 found test function which does not start with 'test'\n",
+            1,
+        ),
+        ("class TestFoo:\n    def test_foo(): pass\n", "", 0),
+        (
+            "class Foo:\n    def foo(): pass\n",
+            "t.py:1:0 found test class which does not start with 'Test'\n"
+            "t.py:2:4 found test function which does not start with 'test'\n",
+            1,
+        ),
+        (
+            "def foo():\n    pass\ndef test_foo():\n    foo()\n",
+            "",
+            0,
+        ),
+        (
+            "class Foo:  # not a test\n"
+            "    pass\n"
+            "def test_foo():\n"
+            "    Class.foo()\n",
+            "",
+            0,
+        ),
+        ("@pytest.fixture\ndef foo(): pass\n", "", 0),
+        ("@pytest.fixture()\ndef foo(): pass\n", "", 0),
+        ("@register_extension_dtype\nclass Foo: pass\n", "", 0),
+    ],
+)
+def test_main(capsys, src, expected_out, expected_ret):
+    ret = main(src, "t.py")
+    out, _ = capsys.readouterr()
+    assert out == expected_out
+    assert ret == expected_ret

Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ def test_invert_array():`
`76`	`76`	`@pytest.mark.parametrize(`
`77`	`77`	`"s", [pd.Series([1, 2, 3]), pd.Series(pd.date_range("2019", periods=3, tz="UTC"))]`
`78`	`78`	`)`
`79`		`-def non_object_dtype(s):`
	`79`	`+def test_non_object_dtype(s):`
`80`	`80`	`result = s.explode()`
`81`	`81`	`tm.assert_series_equal(result, s)`
`82`	`82`