Tests

Author: hunterhogan

tests/conftest.py

@@ -1,6 +1,7 @@
 """SSOT for all tests."""
-
-from collections.abc import Iterator
+# pyright: standard
+from astToolkit import Be, Make
+from collections.abc import Callable, Iterator
 from functools import cache
 from tests.dataSamples.Make import allSubclasses
 from typing import Any
@@ -69,67 +70,59 @@ def beNegativeTestData(request: pytest.FixtureRequest) -> tuple[str, str, str, d
 	"""
 	return request.param
 
-
 # IfThis test data and fixtures
 
-def generateIdentifierTestData():
+def generateIdentifierTestData() -> Iterator[tuple[str, str, Callable, bool]]:
 	"""Generate test data for IfThis identifier-based methods."""
-	from astToolkit import Make
-	
+
 	# Basic identifier patterns
 	test_cases = [
-		# (method_name, test_identifier, node_factory, expected_result)
-		("isNameIdentifier", "test_var", lambda id: Make.Name(id), True),
-		("isNameIdentifier", "different_var", lambda id: Make.Name("test_var"), False),
-		("isFunctionDefIdentifier", "test_func", lambda id: Make.FunctionDef(name=id), True),
-		("isFunctionDefIdentifier", "other_func", lambda id: Make.FunctionDef(name="test_func"), False),
-		("isClassDefIdentifier", "TestClass", lambda id: Make.ClassDef(name=id), True),
-		("isClassDefIdentifier", "OtherClass", lambda id: Make.ClassDef(name="TestClass"), False),
-		("isCallIdentifier", "print", lambda id: Make.Call(callee=Make.Name(id)), True),
-		("isCallIdentifier", "input", lambda id: Make.Call(callee=Make.Name("print")), False),
-		("is_argIdentifier", "param", lambda id: Make.arg(id), True),
-		("is_argIdentifier", "other_param", lambda id: Make.arg("param"), False),
-		("is_keywordIdentifier", "key", lambda id: Make.keyword(id, Make.Constant("value")), True),
-		("is_keywordIdentifier", "other_key", lambda id: Make.keyword("key", Make.Constant("value")), False),
+# NOTE (method_name, test_identifier, node_factory, expected_result)
+		("isNameIdentifier", "test_var", lambda identifier: Make.Name(identifier), True),
+		("isNameIdentifier", "different_var", lambda identifier: Make.Name("test_var"), False),
+		("isFunctionDefIdentifier", "test_func", lambda identifier: Make.FunctionDef(name=identifier), True),
+		("isFunctionDefIdentifier", "other_func", lambda identifier: Make.FunctionDef(name="test_func"), False),
+		("isClassDefIdentifier", "TestClass", lambda identifier: Make.ClassDef(name=identifier), True),
+		("isClassDefIdentifier", "OtherClass", lambda identifier: Make.ClassDef(name="TestClass"), False),
+		("isCallIdentifier", "print", lambda identifier: Make.Call(callee=Make.Name(identifier)), True),
+		("isCallIdentifier", "input", lambda identifier: Make.Call(callee=Make.Name("print")), False),
+		("is_argIdentifier", "param", lambda identifier: Make.arg(identifier), True),
+		("is_argIdentifier", "other_param", lambda identifier: Make.arg("param"), False),
+		("is_keywordIdentifier", "key", lambda identifier: Make.keyword(identifier, Make.Constant("value")), True),
+		("is_keywordIdentifier", "other_key", lambda identifier: Make.keyword("key", Make.Constant("value")), False),
 	]
-	
-	for method_name, test_id, node_factory, expected in test_cases:
-		yield (method_name, test_id, node_factory, expected)
 
-def generateSimplePredicateTestData():
+	yield from test_cases
+
+def generateSimplePredicateTestData() -> Iterator[tuple[str, tuple, Callable, bool]]:
 	"""Generate test data for simple predicate methods."""
-	from astToolkit import Make, Be
-	
+
 	test_cases = [
-		# (method_name, test_args, node_factory, expected_result)
+		# method_name, test_args, node_factory, expected_result
 		("isConstant_value", (42,), lambda: Make.Constant(42), True),
 		("isConstant_value", (24,), lambda: Make.Constant(42), False),
 	]
-	
-	for method_name, args, node_factory, expected in test_cases:
-		yield (method_name, args, node_factory, expected)
 
-def generateDirectPredicateTestData():
+	yield from test_cases
+
+def generateDirectPredicateTestData() -> Iterator[tuple[str, Callable, bool]]:
 	"""Generate test data for direct predicate methods that take node directly."""
-	from astToolkit import Make
-	
+
 	test_cases = [
-		# (method_name, node_factory, expected_result)
+		# method_name, node_factory, expected_result
 		("isAttributeName", lambda: Make.Attribute(Make.Name("obj"), "attr"), True),
 		("isAttributeName", lambda: Make.Name("obj"), False),
 		("isCallToName", lambda: Make.Call(callee=Make.Name("func")), True),
 		("isCallToName", lambda: Make.Call(callee=Make.Attribute(Make.Name("obj"), "method")), False),
 	]
-	
-	for method_name, node_factory, expected in test_cases:
-		yield (method_name, node_factory, expected)
 
-def generateComplexPredicateTestData():
+	yield from test_cases
+
+def generateComplexPredicateTestData() -> Iterator[tuple[str, tuple, Callable, bool]]:
 	"""Generate test data for complex predicate methods."""
-	from astToolkit import Make
-	
+
 	test_cases = [
-		# (method_name, test_args, node_factory, expected_result)
+		# method_name, test_args, node_factory, expected_result
 		("isAttributeNamespaceIdentifier", ("obj", "method"), lambda: Make.Attribute(Make.Name("obj"), "method"), True),
 		("isAttributeNamespaceIdentifier", ("other_obj", "method"), lambda: Make.Attribute(Make.Name("obj"), "method"), False),
 		("isCallAttributeNamespaceIdentifier", ("obj", "method"), lambda: Make.Call(callee=Make.Attribute(Make.Name("obj"), "method")), True),
@@ -141,26 +134,25 @@ def generateComplexPredicateTestData():
 		("isUnaryNotAttributeNamespaceIdentifier", ("obj", "flag"), lambda: Make.UnaryOp(op=Make.Not(), operand=Make.Attribute(Make.Name("obj"), "flag")), True),
 		("isUnaryNotAttributeNamespaceIdentifier", ("other_obj", "flag"), lambda: Make.UnaryOp(op=Make.Not(), operand=Make.Attribute(Make.Name("obj"), "flag")), False),
 	]
-	
-	for method_name, args, node_factory, expected in test_cases:
-		yield (method_name, args, node_factory, expected)
+
+	yield from test_cases
 
 @pytest.fixture(params=list(generateIdentifierTestData()), ids=lambda param: f"{param[0]}_{param[1]}_{param[3]}")
-def identifierTestData(request):
+def identifierTestData(request: pytest.FixtureRequest) -> tuple[str, str, Callable, bool]:
 	"""Fixture providing test data for identifier-based IfThis methods."""
 	return request.param
 
 @pytest.fixture(params=list(generateSimplePredicateTestData()), ids=lambda param: f"{param[0]}_{param[3]}")
-def simplePredicateTestData(request):
+def simplePredicateTestData(request: pytest.FixtureRequest) -> tuple[str, tuple, Callable, bool]:
 	"""Fixture providing test data for simple IfThis predicate methods."""
 	return request.param
 
 @pytest.fixture(params=list(generateDirectPredicateTestData()), ids=lambda param: f"{param[0]}_{param[2]}")
-def directPredicateTestData(request):
+def directPredicateTestData(request: pytest.FixtureRequest) -> tuple[str, Callable, bool]:
 	"""Fixture providing test data for direct IfThis predicate methods."""
 	return request.param
 
 @pytest.fixture(params=list(generateComplexPredicateTestData()), ids=lambda param: f"{param[0]}_{param[3]}")
-def complexPredicateTestData(request):
+def complexPredicateTestData(request: pytest.FixtureRequest) -> tuple[str, tuple, Callable, bool]:
 	"""Fixture providing test data for complex IfThis predicate methods."""
 	return request.param