Improve tests

Author: zenlyj

astroid/brain/helpers.py

@@ -5,7 +5,6 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-
 from typing import TYPE_CHECKING
 
 from astroid.exceptions import InferenceError

tests/brain/test_attr.py

@@ -232,44 +232,56 @@ class Foo:
 
     def test_attrs_with_class_var_annotation(self) -> None:
         cases = {
-            "from_import": """
+            "with-subscript": """
                 import attrs
                 from typing import ClassVar
 
                 @attrs.define
                 class Foo:
                     bar: ClassVar[int] = 1
-                    baz: int = 1
                 Foo()
             """,
-            "module_import": """
+            "no-subscript": """
                 import attrs
-                import typing
+                from typing import ClassVar
+
+                @attrs.define
+                class Foo:
+                    bar: ClassVar = 1
+                Foo()
+            """,
+        }
+
+        for name, code in cases.items():
+            with self.subTest(case=name):
+                instance = next(astroid.extract_node(code).infer())
+                self.assertIsInstance(instance.getattr("bar")[0], nodes.AssignName)
+                self.assertNotIn("bar", instance.instance_attrs)
+
+    def test_attrs_without_class_var_annotation(self) -> None:
+        cases = {
+            "wrong-name": """
+                import attrs
+                from typing import Final
 
                 @attrs.define
                 class Foo:
-                    bar: typing.ClassVar[int] = 1
-                    baz: int = 1
+                    bar: Final[int] = 1
                 Foo()
             """,
-            "no_subscript": """
+            "classvar-not-outermost": """
                 import attrs
                 from typing import ClassVar
 
                 @attrs.define
                 class Foo:
-                    bar: ClassVar = 1
-                    baz: int = 1
+                    bar: list[ClassVar[int]] = []
                 Foo()
             """,
         }
 
         for name, code in cases.items():
             with self.subTest(case=name):
                 instance = next(astroid.extract_node(code).infer())
-
-                self.assertIsInstance(instance.getattr("bar")[0], nodes.AssignName)
-                self.assertIsInstance(instance.getattr("baz")[0], nodes.Unknown)
-
-                self.assertNotIn("bar", instance.instance_attrs)
-                self.assertIn("baz", instance.instance_attrs)
+                self.assertIsInstance(instance.getattr("bar")[0], nodes.Unknown)
+                self.assertIn("bar", instance.instance_attrs)

tests/brain/test_helpers.py

@@ -0,0 +1,85 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/pylint-dev/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/pylint-dev/astroid/blob/main/CONTRIBUTORS.txt
+
+import pytest
+
+from astroid import extract_node, nodes
+from astroid.brain.helpers import is_class_var
+
+
+@pytest.mark.parametrize(
+    "code",
+    [
+        pytest.param(
+            """
+            from typing import ClassVar
+
+            foo: ClassVar[int]
+            """,
+            id="from-import",
+        ),
+        pytest.param(
+            """
+            from typing import ClassVar
+
+            foo: ClassVar
+            """,
+            id="bare-classvar",
+        ),
+        pytest.param(
+            """
+            import typing
+
+            foo: typing.ClassVar[int]
+            """,
+            id="module-import",
+        ),
+    ],
+)
+def test_is_class_var_returns_true(code):
+    node = extract_node(code)
+    assert isinstance(node, nodes.AnnAssign)
+    assert is_class_var(node.annotation)
+
+
+@pytest.mark.parametrize(
+    "code",
+    [
+        pytest.param(
+            """
+            from typing import Final
+
+            foo: Final[int]
+            """,
+            id="wrong-name",
+        ),
+        pytest.param(
+            """
+            from typing import ClassVar
+
+            foo: list[ClassVar[int]]
+            """,
+            id="classvar-not-outermost",
+        ),
+        pytest.param(
+            """
+            from typing import ClassVar
+            ClassVar = int
+
+            foo: ClassVar
+            """,
+            id="shadowed-name",
+        ),
+        pytest.param(
+            """
+            foo: ClassVar[int]
+            """,
+            id="missing-import",
+        ),
+    ],
+)
+def test_is_class_var_returns_false(code):
+    node = extract_node(code)
+    assert isinstance(node, nodes.AnnAssign)
+    assert not is_class_var(node.annotation)