Skip to content

Run a subset of the 14,000 tests for Be. #12

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
hunterhogan merged 1 commit into from
Sep 29, 2025
Merged

Run a subset of the 14,000 tests for Be. #12

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
143 changes: 80 additions & 63 deletions tests/conftest.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,8 +6,12 @@
from tests.dataSamples.Make import allSubclasses
from typing import Any
import ast # pyright: ignore[reportUnusedImport]
import datetime
import pytest

negativeTestsPerClass: int = 3
stepSize: int = (32 - datetime.date.today().weekday()) * (datetime.date.today().day + 1)

def generateBeTestData() -> Iterator[tuple[str, str, dict[str, Any]]]:
"""Yield test data for positive Be tests. (AI generated docstring).

Expand All @@ -29,12 +33,25 @@ def generateBeTestData() -> Iterator[tuple[str, str, dict[str, Any]]]:
def getTestData(vsClass: str, testName: str) -> dict[str, Any]:
return allSubclasses[vsClass][testName]

def generateBeNegativeTestData(): # noqa: ANN201
def generateBeNegativeTestData() -> Iterator[tuple[str, str, str, dict[str, Any]]]:
for class2test, *list_vsClass in [(C, *list(set(allSubclasses)-{C}-{c.__name__ for c in eval('ast.'+C).__subclasses__()})) for C in allSubclasses]: # noqa: S307
testName = "class Make, maximally empty parameters"
for vsClass in list_vsClass:
testData = getTestData(vsClass, testName)
yield (class2test, vsClass, testName, testData)

list_vsClass.sort()
indexNormalizer: int = len(list_vsClass)
setIndices: set[int] = set()
step: int = stepSize
while len(setIndices) < negativeTestsPerClass:
setIndices.add(step % indexNormalizer)
step = step + stepSize + 1

listIndices: list[int] = sorted(setIndices)

listTuplesTests: list[tuple[str, str, str, dict[str, Any]]] = [
(class2test, list_vsClass[index], testName, getTestData(list_vsClass[index], testName))
for index in listIndices
]
yield from listTuplesTests

@pytest.fixture(params=list(generateBeTestData()), ids=lambda param: f"{param[0]}_{param[1]}")
def beTestData(request: pytest.FixtureRequest) -> tuple[str, str, dict[str, Any]]:
Expand Down Expand Up @@ -72,87 +89,87 @@ def beNegativeTestData(request: pytest.FixtureRequest) -> tuple[str, str, str, d

# IfThis test data and fixtures

def generateIdentifierTestData() -> Iterator[tuple[str, str, Callable, bool]]:
"""Generate test data for IfThis identifier-based methods."""

# Basic identifier patterns
test_cases = [
# 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),
def generateIfThisIdentifierTestCases() -> Iterator[tuple[str, str, Callable[[str], ast.AST], bool]]:
"""Generate test data for IfThis identifier-based methods using non-contiguous test values."""

# Using non-contiguous, semantic test values as per instructions
listTestCases: list[tuple[str, str, Callable[[str], ast.AST], bool]] = [
# methodNameIfThis, identifierToTest, factoryNodeAST, expectedPredicateResult
("isNameIdentifier", "variableNorthward", lambda identifierParameter: Make.Name(identifierParameter), True),
("isNameIdentifier", "variableSouthward", lambda _identifierIgnored: Make.Name("variableNorthward"), False),
("isFunctionDefIdentifier", "functionEastward", lambda identifierParameter: Make.FunctionDef(name=identifierParameter), True),
("isFunctionDefIdentifier", "functionWestward", lambda _identifierIgnored: Make.FunctionDef(name="functionEastward"), False),
("isClassDefIdentifier", "ClassNorthEast", lambda identifierParameter: Make.ClassDef(name=identifierParameter), True),
("isClassDefIdentifier", "ClassSouthWest", lambda _identifierIgnored: Make.ClassDef(name="ClassNorthEast"), False),
("isCallIdentifier", "callablePrimary", lambda identifierParameter: Make.Call(Make.Name(identifierParameter)), True),
("isCallIdentifier", "callableSecondary", lambda _identifierIgnored: Make.Call(Make.Name("callablePrimary")), False),
("is_argIdentifier", "parameterFibonacci", lambda identifierParameter: Make.arg(identifierParameter), True),
("is_argIdentifier", "parameterPrime", lambda _identifierIgnored: Make.arg("parameterFibonacci"), False),
("is_keywordIdentifier", "keywordAlpha", lambda identifierParameter: Make.keyword(identifierParameter, Make.Constant("valueBeta")), True),
("is_keywordIdentifier", "keywordGamma", lambda _identifierIgnored: Make.keyword("keywordAlpha", Make.Constant("valueBeta")), False),
]

yield from test_cases
yield from listTestCases

def generateSimplePredicateTestData() -> Iterator[tuple[str, tuple, Callable, bool]]:
"""Generate test data for simple predicate methods."""
def generateIfThisSimplePredicateTestCases() -> Iterator[tuple[str, tuple[Any, ...], Callable[[], ast.AST], bool]]:
"""Generate test data for simple predicate methods using unique test values."""

test_cases = [
# method_name, test_args, node_factory, expected_result
("isConstant_value", (42,), lambda: Make.Constant(42), True),
("isConstant_value", (24,), lambda: Make.Constant(42), False),
listTestCases: list[tuple[str, tuple[Any, ...], Callable[[], ast.AST], bool]] = [
# methodNameIfThis, tupleArgumentsTest, factoryNodeAST, expectedPredicateResult
("isConstant_value", (233,), lambda: Make.Constant(233), True), # Fibonacci number
("isConstant_value", (89,), lambda: Make.Constant(233), False), # Different Fibonacci number
]

yield from test_cases
yield from listTestCases

def generateDirectPredicateTestData() -> Iterator[tuple[str, Callable, bool]]:
def generateIfThisDirectPredicateTestCases() -> Iterator[tuple[str, Callable[[], ast.AST], bool]]:
"""Generate test data for direct predicate methods that take node directly."""

test_cases = [
# 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),
listTestCases: list[tuple[str, Callable[[], ast.AST], bool]] = [
# methodNameIfThis, factoryNodeAST, expectedPredicateResult
("isAttributeName", lambda: Make.Attribute(Make.Name("objectPrime"), "attributeSecondary"), True),
("isAttributeName", lambda: Make.Name("objectPrime"), False),
("isCallToName", lambda: Make.Call(Make.Name("functionTertiary")), True),
("isCallToName", lambda: Make.Call(Make.Attribute(Make.Name("objectPrime"), "methodQuinary")), False),
]

yield from test_cases

def generateComplexPredicateTestData() -> Iterator[tuple[str, tuple, Callable, bool]]:
"""Generate test data for complex predicate methods."""

test_cases = [
# 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),
("isCallAttributeNamespaceIdentifier", ("other_obj", "method"), lambda: Make.Call(callee=Make.Attribute(Make.Name("obj"), "method")), False),
("isStarredIdentifier", ("args",), lambda: Make.Starred(value=Make.Name("args")), True),
("isStarredIdentifier", ("kwargs",), lambda: Make.Starred(value=Make.Name("args")), False),
("isSubscriptIdentifier", ("arr",), lambda: Make.Subscript(value=Make.Name("arr"), slice=Make.Constant(0)), True),
("isSubscriptIdentifier", ("list",), lambda: Make.Subscript(value=Make.Name("arr"), slice=Make.Constant(0)), False),
("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),
yield from listTestCases

def generateIfThisComplexPredicateTestCases() -> Iterator[tuple[str, tuple[Any, ...], Callable[[], ast.AST], bool]]:
"""Generate test data for complex predicate methods using cardinal directions and primes."""

listTestCases: list[tuple[str, tuple[Any, ...], Callable[[], ast.AST], bool]] = [
# methodNameIfThis, tupleArgumentsTest, factoryNodeAST, expectedPredicateResult
("isAttributeNamespaceIdentifier", ("namespacePrimary", "methodNorthward"), lambda: Make.Attribute(Make.Name("namespacePrimary"), "methodNorthward"), True),
("isAttributeNamespaceIdentifier", ("namespaceSecondary", "methodNorthward"), lambda: Make.Attribute(Make.Name("namespacePrimary"), "methodNorthward"), False),
("isCallAttributeNamespaceIdentifier", ("namespaceAlpha", "methodEastward"), lambda: Make.Call(Make.Attribute(Make.Name("namespaceAlpha"), "methodEastward")), True),
("isCallAttributeNamespaceIdentifier", ("namespaceBeta", "methodEastward"), lambda: Make.Call(Make.Attribute(Make.Name("namespaceAlpha"), "methodEastward")), False),
("isStarredIdentifier", ("argumentsCollection",), lambda: Make.Starred(Make.Name("argumentsCollection")), True),
("isStarredIdentifier", ("keywordsMapping",), lambda: Make.Starred(Make.Name("argumentsCollection")), False),
("isSubscriptIdentifier", ("arrayFibonacci",), lambda: Make.Subscript(Make.Name("arrayFibonacci"), Make.Constant(13)), True),
("isSubscriptIdentifier", ("listPrime",), lambda: Make.Subscript(Make.Name("arrayFibonacci"), Make.Constant(13)), False),
("isUnaryNotAttributeNamespaceIdentifier", ("objectTarget", "flagEnabled"), lambda: Make.UnaryOp(Make.Not(), Make.Attribute(Make.Name("objectTarget"), "flagEnabled")), True),
("isUnaryNotAttributeNamespaceIdentifier", ("objectAlternate", "flagEnabled"), lambda: Make.UnaryOp(Make.Not(), Make.Attribute(Make.Name("objectTarget"), "flagEnabled")), False),
]

yield from test_cases
yield from listTestCases

@pytest.fixture(params=list(generateIdentifierTestData()), ids=lambda param: f"{param[0]}_{param[1]}_{param[3]}")
def identifierTestData(request: pytest.FixtureRequest) -> tuple[str, str, Callable, bool]:
@pytest.fixture(params=list(generateIfThisIdentifierTestCases()), ids=lambda parametersTest: f"{parametersTest[0]}_{parametersTest[1]}_{parametersTest[3]}")
def ifThisIdentifierTestData(request: pytest.FixtureRequest) -> tuple[str, str, Callable[[str], ast.AST], 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: pytest.FixtureRequest) -> tuple[str, tuple, Callable, bool]:
@pytest.fixture(params=list(generateIfThisSimplePredicateTestCases()), ids=lambda parametersTest: f"{parametersTest[0]}_{parametersTest[3]}")
def ifThisSimplePredicateTestData(request: pytest.FixtureRequest) -> tuple[str, tuple[Any, ...], Callable[[], ast.AST], 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: pytest.FixtureRequest) -> tuple[str, Callable, bool]:
@pytest.fixture(params=list(generateIfThisDirectPredicateTestCases()), ids=lambda parametersTest: f"{parametersTest[0]}_{parametersTest[2]}")
def ifThisDirectPredicateTestData(request: pytest.FixtureRequest) -> tuple[str, Callable[[], ast.AST], 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: pytest.FixtureRequest) -> tuple[str, tuple, Callable, bool]:
@pytest.fixture(params=list(generateIfThisComplexPredicateTestCases()), ids=lambda parametersTest: f"{parametersTest[0]}_{parametersTest[3]}")
def ifThisComplexPredicateTestData(request: pytest.FixtureRequest) -> tuple[str, tuple[Any, ...], Callable[[], ast.AST], bool]:
"""Fixture providing test data for complex IfThis predicate methods."""
return request.param
Loading