Skip to content

Commit 528d657

Browse files
youknowoneyouknowone
authored
[update_lib] Fix async func auto-mark (#6903)
1 parent bb0a201 commit 528d657

File tree

3 files changed

+240
-19
lines changed

3 files changed

+240
-19
lines changed

‎scripts/update_lib/cmd_auto_mark.py‎

Lines changed: 57 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -71,53 +71,89 @@ def run_test(test_name: str, skip_build: bool = False) -> TestResult:
7171
return parse_results(result)
7272

7373

74+
def _try_parse_test_info(test_info: str) -> tuple[str, str] | None:
75+
"""Try to extract (name, path) from 'test_name (path)' or 'test_name (path) [subtest]'."""
76+
first_space = test_info.find(" ")
77+
if first_space > 0:
78+
name = test_info[:first_space]
79+
rest = test_info[first_space:].strip()
80+
if rest.startswith("("):
81+
end_paren = rest.find(")")
82+
if end_paren > 0:
83+
return name, rest[1:end_paren]
84+
return None
85+
86+
7487
def parse_results(result: subprocess.CompletedProcess) -> TestResult:
7588
"""Parse subprocess result into TestResult."""
7689
lines = result.stdout.splitlines()
7790
test_results = TestResult()
7891
test_results.stdout = result.stdout
7992
in_test_results = False
93+
# For multiline format: "test_name (path)\ndocstring ... RESULT"
94+
pending_test_info = None
8095

8196
for line in lines:
8297
if re.search(r"Run \d+ tests? sequentially", line):
8398
in_test_results = True
84-
elif line.startswith("-----------"):
99+
elif "== Tests result: " in line:
85100
in_test_results = False
86101

87102
if in_test_results and " ... " in line:
88-
line = line.strip()
103+
stripped = line.strip()
89104
# Skip lines that don't look like test results
90-
if line.startswith("tests") or line.startswith("["):
105+
if stripped.startswith("tests") or stripped.startswith("["):
106+
pending_test_info = None
91107
continue
92108
# Parse: "test_name (path) [subtest] ... RESULT"
93-
parts = line.split(" ... ")
109+
parts = stripped.split(" ... ")
94110
if len(parts) >= 2:
95111
test_info = parts[0]
96112
result_str = parts[-1].lower()
97113
# Only process FAIL or ERROR
98114
if result_str not in ("fail", "error"):
115+
pending_test_info = None
99116
continue
100-
# Extract test name (first word)
101-
first_space = test_info.find(" ")
102-
if first_space > 0:
117+
# Try parsing from this line (single-line format)
118+
parsed = _try_parse_test_info(test_info)
119+
if not parsed and pending_test_info:
120+
# Multiline format: previous line had test_name (path)
121+
parsed = _try_parse_test_info(pending_test_info)
122+
if parsed:
103123
test = Test()
104-
test.name = test_info[:first_space]
105-
# Extract path from (path)
106-
rest = test_info[first_space:].strip()
107-
if rest.startswith("("):
108-
end_paren = rest.find(")")
109-
if end_paren > 0:
110-
test.path = rest[1:end_paren]
111-
test.result = result_str
112-
test_results.tests.append(test)
124+
test.name, test.path = parsed
125+
test.result = result_str
126+
test_results.tests.append(test)
127+
pending_test_info = None
128+
129+
elif in_test_results:
130+
# Track test info for multiline format:
131+
# test_name (path)
132+
# docstring ... RESULT
133+
stripped = line.strip()
134+
if (
135+
stripped
136+
and "(" in stripped
137+
and stripped.endswith(")")
138+
and ":" not in stripped.split("(")[0]
139+
):
140+
pending_test_info = stripped
141+
else:
142+
pending_test_info = None
143+
144+
# Also check for Tests result on non-" ... " lines
145+
if "== Tests result: " in line:
146+
res = line.split("== Tests result: ")[1]
147+
res = res.split(" ")[0]
148+
test_results.tests_result = res
113149

114150
elif "== Tests result: " in line:
115151
res = line.split("== Tests result: ")[1]
116152
res = res.split(" ")[0]
117153
test_results.tests_result = res
118154

119155
# Parse: "UNEXPECTED SUCCESS: test_name (path)"
120-
elif line.startswith("UNEXPECTED SUCCESS: "):
156+
if line.startswith("UNEXPECTED SUCCESS: "):
121157
rest = line[len("UNEXPECTED SUCCESS: ") :]
122158
# Format: "test_name (path)"
123159
first_space = rest.find(" ")
@@ -232,13 +268,16 @@ def build_patches(
232268

233269

234270
def _is_super_call_only(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
235-
"""Check if the method body is just 'return super().method_name()'."""
271+
"""Check if the method body is just 'return super().method_name()' or 'return await super().method_name()'."""
236272
if len(func_node.body) != 1:
237273
return False
238274
stmt = func_node.body[0]
239275
if not isinstance(stmt, ast.Return) or stmt.value is None:
240276
return False
241277
call = stmt.value
278+
# Unwrap await for async methods
279+
if isinstance(call, ast.Await):
280+
call = call.value
242281
if not isinstance(call, ast.Call):
243282
return False
244283
if not isinstance(call.func, ast.Attribute):

‎scripts/update_lib/patch_spec.py‎

Lines changed: 17 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -247,9 +247,17 @@ def _iter_patch_lines(
247247

248248
# Build cache of all classes (for Phase 2 to find classes without methods)
249249
cache = {}
250+
# Build per-class set of async method names (for Phase 2 to generate correct override)
251+
async_methods: dict[str, set[str]] = {}
250252
for node in tree.body:
251253
if isinstance(node, ast.ClassDef):
252254
cache[node.name] = node.end_lineno
255+
cls_async: set[str] = set()
256+
for item in node.body:
257+
if isinstance(item, ast.AsyncFunctionDef):
258+
cls_async.add(item.name)
259+
if cls_async:
260+
async_methods[node.name] = cls_async
253261

254262
# Phase 1: Iterate and mark existing tests
255263
for cls_node, fn_node in iter_tests(tree):
@@ -274,7 +282,15 @@ def _iter_patch_lines(
274282

275283
for test_name, specs in tests.items():
276284
decorators = "\n".join(spec.as_decorator() for spec in specs)
277-
patch_lines = f"""
285+
is_async = test_name in async_methods.get(cls_name, set())
286+
if is_async:
287+
patch_lines = f"""
288+
{decorators}
289+
async def {test_name}(self):
290+
{DEFAULT_INDENT}return await super().{test_name}()
291+
""".rstrip()
292+
else:
293+
patch_lines = f"""
278294
{decorators}
279295
def {test_name}(self):
280296
{DEFAULT_INDENT}return super().{test_name}()

‎scripts/update_lib/tests/test_auto_mark.py‎

Lines changed: 166 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -118,6 +118,76 @@ def test_parse_error_message(self):
118118
self.assertEqual(len(result.tests), 1)
119119
self.assertEqual(result.tests[0].error_message, "AssertionError: 1 != 2")
120120

121+
def test_parse_directory_test_multiple_submodules(self):
122+
"""Test parsing directory test output with multiple submodules.
123+
124+
When running a directory test (e.g., test_asyncio), the output contains
125+
multiple submodules separated by '------' lines. Failures in submodules
126+
after the first one must still be detected.
127+
"""
128+
stdout = """\
129+
Run 3 tests sequentially
130+
0:00:00 [ 1/3] test_asyncio.test_buffered_proto
131+
test_ok (test.test_asyncio.test_buffered_proto.TestProto.test_ok) ... ok
132+
133+
----------------------------------------------------------------------
134+
Ran 1 tests in 0.1s
135+
136+
OK
137+
138+
0:00:01 [ 2/3] test_asyncio.test_events
139+
test_create (test.test_asyncio.test_events.TestEvents.test_create) ... FAIL
140+
141+
----------------------------------------------------------------------
142+
Ran 1 tests in 0.2s
143+
144+
FAILED (failures=1)
145+
146+
0:00:02 [ 3/3] test_asyncio.test_tasks
147+
test_gather (test.test_asyncio.test_tasks.TestTasks.test_gather) ... ERROR
148+
149+
----------------------------------------------------------------------
150+
Ran 1 tests in 0.3s
151+
152+
FAILED (errors=1)
153+
154+
== Tests result: FAILURE ==
155+
"""
156+
result = parse_results(self._make_result(stdout))
157+
self.assertEqual(len(result.tests), 2)
158+
names = {t.name for t in result.tests}
159+
self.assertIn("test_create", names)
160+
self.assertIn("test_gather", names)
161+
# Verify results
162+
test_create = next(t for t in result.tests if t.name == "test_create")
163+
test_gather = next(t for t in result.tests if t.name == "test_gather")
164+
self.assertEqual(test_create.result, "fail")
165+
self.assertEqual(test_gather.result, "error")
166+
self.assertEqual(result.tests_result, "FAILURE")
167+
168+
def test_parse_multiline_test_with_docstring(self):
169+
"""Test parsing tests where docstring appears on a separate line.
170+
171+
Some tests have docstrings that cause the output to span two lines:
172+
test_name (path)
173+
docstring ... ERROR
174+
"""
175+
stdout = """\
176+
Run 3 tests sequentially
177+
test_ok (test.test_example.TestClass.test_ok) ... ok
178+
test_with_doc (test.test_example.TestClass.test_with_doc)
179+
Test that something works ... ERROR
180+
test_normal_fail (test.test_example.TestClass.test_normal_fail) ... FAIL
181+
"""
182+
result = parse_results(self._make_result(stdout))
183+
self.assertEqual(len(result.tests), 2)
184+
names = {t.name for t in result.tests}
185+
self.assertIn("test_with_doc", names)
186+
self.assertIn("test_normal_fail", names)
187+
test_doc = next(t for t in result.tests if t.name == "test_with_doc")
188+
self.assertEqual(test_doc.path, "test.test_example.TestClass.test_with_doc")
189+
self.assertEqual(test_doc.result, "error")
190+
121191
def test_parse_multiple_error_messages(self):
122192
"""Test parsing multiple error messages."""
123193
stdout = """
@@ -644,6 +714,102 @@ def test_one(self):
644714
method = self._parse_method(code)
645715
self.assertFalse(_is_super_call_only(method))
646716

717+
def test_async_await_super_call(self):
718+
"""Test async method that awaits super().same_name()."""
719+
code = """
720+
class Foo:
721+
async def test_one(self):
722+
return await super().test_one()
723+
"""
724+
method = self._parse_method(code)
725+
self.assertTrue(_is_super_call_only(method))
726+
727+
def test_async_await_mismatched_super_call(self):
728+
"""Test async method that awaits super().different_name()."""
729+
code = """
730+
class Foo:
731+
async def test_one(self):
732+
return await super().test_two()
733+
"""
734+
method = self._parse_method(code)
735+
self.assertFalse(_is_super_call_only(method))
736+
737+
def test_async_without_await(self):
738+
"""Test async method that calls super() without await (sync super call in async method)."""
739+
code = """
740+
class Foo:
741+
async def test_one(self):
742+
return super().test_one()
743+
"""
744+
method = self._parse_method(code)
745+
self.assertTrue(_is_super_call_only(method))
746+
747+
748+
class TestAsyncInheritedOverride(unittest.TestCase):
749+
"""Tests for async inherited method override generation."""
750+
751+
def test_inherited_async_method_generates_async_override(self):
752+
"""Test that inherited async methods get async def + await override."""
753+
code = """import unittest
754+
755+
class BaseTest:
756+
async def test_async_one(self):
757+
pass
758+
759+
class TestChild(BaseTest, unittest.TestCase):
760+
pass
761+
"""
762+
failing = {("TestChild", "test_async_one")}
763+
result = apply_test_changes(code, failing, set())
764+
765+
self.assertIn("async def test_async_one(self):", result)
766+
self.assertIn("return await super().test_async_one()", result)
767+
self.assertIn("@unittest.expectedFailure", result)
768+
769+
def test_inherited_sync_method_generates_sync_override(self):
770+
"""Test that inherited sync methods get sync def override."""
771+
code = """import unittest
772+
773+
class BaseTest:
774+
def test_sync_one(self):
775+
pass
776+
777+
class TestChild(BaseTest, unittest.TestCase):
778+
pass
779+
"""
780+
failing = {("TestChild", "test_sync_one")}
781+
result = apply_test_changes(code, failing, set())
782+
783+
self.assertIn("def test_sync_one(self):", result)
784+
self.assertIn("return super().test_sync_one()", result)
785+
self.assertNotIn("async def test_sync_one", result)
786+
self.assertNotIn("await", result)
787+
788+
def test_remove_async_super_call_override(self):
789+
"""Test removing async super call override on unexpected success."""
790+
code = f"""import unittest
791+
792+
class BaseTest:
793+
async def test_async_one(self):
794+
pass
795+
796+
class TestChild(BaseTest, unittest.TestCase):
797+
# {COMMENT}
798+
@unittest.expectedFailure
799+
async def test_async_one(self):
800+
return await super().test_async_one()
801+
"""
802+
successes = {("TestChild", "test_async_one")}
803+
result = apply_test_changes(code, set(), successes)
804+
805+
# The override in TestChild should be removed; base class method remains
806+
self.assertNotIn("return await super().test_async_one()", result)
807+
self.assertNotIn("@unittest.expectedFailure", result)
808+
self.assertIn("class TestChild", result)
809+
# Base class method should still be present
810+
self.assertIn("class BaseTest", result)
811+
self.assertIn("async def test_async_one(self):", result)
812+
647813

648814
if __name__ == "__main__":
649815
unittest.main()

0 commit comments

Comments
 (0)