Understanding and monitoring test coverage is a crucial aspect of quality assurance, as it helps you identify which parts of the codebase have been exercised by your tests and which have not. By simulating test coverage tracking, you can gain practical insights into how coverage tools operate and why they are valuable for continuous QA improvement. In this challenge, you will create a Python script that maintains a set of function names as they are "called" during test execution, then reports which functions from a predefined list were covered and which were not. This hands-on exercise reinforces the importance of thorough testing and the value of coverage metrics in real-world QA workflows.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_covered_and_untested_identification(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        functions_to_test = ['login', 'logout', 'reset_password', 'update_profile', 'delete_account']
        tested_functions = ['login', 'update_profile', 'logout']
        expected_covered = ["login", "logout", "update_profile"]
        expected_untested = ["delete_account", "reset_password"]
        with redirect_stdout(f):
            user_code.simulate_test_coverage(functions_to_test, tested_functions)
        output = f.getvalue()
        # Check covered
        covered_line = [line for line in output.splitlines() if line.startswith("Tested functions:")]
        _dynamic_test(
            self,
            len(covered_line) > 0,
            "Output includes 'Tested functions:' line",
            "Expected line starting with 'Tested functions:' not found."
        )
        covered_str = covered_line[0][len("Tested functions:"):].strip()
        covered_list = [s.strip() for s in covered_str.split(",") if s.strip()]
        _dynamic_test(
            self,
            sorted(covered_list) == sorted(expected_covered),
            f"Correct tested functions listed: {expected_covered}",
            f"Expected tested: {expected_covered}, got: {covered_list}"
        )
        # Check untested
        untested_line = [line for line in output.splitlines() if line.startswith("Untested functions:")]
        _dynamic_test(
            self,
            len(untested_line) > 0,
            "Output includes 'Untested functions:' line",
            "Expected line starting with 'Untested functions:' not found."
        )
        untested_str = untested_line[0][len("Untested functions:"):].strip()
        untested_list = [s.strip() for s in untested_str.split(",") if s.strip()]
        _dynamic_test(
            self,
            sorted(untested_list) == sorted(expected_untested),
            f"Correct untested functions listed: {expected_untested}",
            f"Expected untested: {expected_untested}, got: {untested_list}"
        )

    def test_all_tested(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        functions_to_test = ['a', 'b', 'c']
        tested_functions = ['a', 'b', 'c']
        with redirect_stdout(f):
            user_code.simulate_test_coverage(functions_to_test, tested_functions)
        output = f.getvalue()
        covered_line = [line for line in output.splitlines() if line.startswith("Tested functions:")]
        untested_line = [line for line in output.splitlines() if line.startswith("Untested functions:")]
        covered_str = covered_line[0][len("Tested functions:"):].strip() if covered_line else ""
        untested_str = untested_line[0][len("Untested functions:"):].strip() if untested_line else ""
        _dynamic_test(
            self,
            sorted([s.strip() for s in covered_str.split(",") if s.strip()]) == ['a', 'b', 'c'],
            "All tested functions listed correctly when all are covered.",
            f"Expected all functions in covered, got: {covered_str}"
        )
        _dynamic_test(
            self,
            untested_str == "",
            "Untested functions is empty string when all are covered.",
            f"Expected empty untested, got: {untested_str}"
        )

    def test_none_tested(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        functions_to_test = ['a', 'b', 'c']
        tested_functions = []
        with redirect_stdout(f):
            user_code.simulate_test_coverage(functions_to_test, tested_functions)
        output = f.getvalue()
        covered_line = [line for line in output.splitlines() if line.startswith("Tested functions:")]
        untested_line = [line for line in output.splitlines() if line.startswith("Untested functions:")]
        covered_str = covered_line[0][len("Tested functions:"):].strip() if covered_line else ""
        untested_str = untested_line[0][len("Untested functions:"):].strip() if untested_line else ""
        _dynamic_test(
            self,
            covered_str == "",
            "Tested functions is empty string when none are covered.",
            f"Expected empty covered, got: {covered_str}"
        )
        _dynamic_test(
            self,
            sorted([s.strip() for s in untested_str.split(",") if s.strip()]) == ['a', 'b', 'c'],
            "All untested functions listed correctly when none are covered.",
            f"Expected all functions in untested, got: {untested_str}"
        )

    def test_extra_tested_functions_are_ignored(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        functions_to_test = ['a', 'b']
        tested_functions = ['a', 'b', 'c', 'd']
        with redirect_stdout(f):
            user_code.simulate_test_coverage(functions_to_test, tested_functions)
        output = f.getvalue()
        covered_line = [line for line in output.splitlines() if line.startswith("Tested functions:")]
        untested_line = [line for line in output.splitlines() if line.startswith("Untested functions:")]
        covered_str = covered_line[0][len("Tested functions:"):].strip() if covered_line else ""
        untested_str = untested_line[0][len("Untested functions:"):].strip() if untested_line else ""
        _dynamic_test(
            self,
            sorted([s.strip() for s in covered_str.split(",") if s.strip()]) == ['a', 'b'],
            "Correctly ignores extra tested functions not in functions_to_test.",
            f"Expected only functions from functions_to_test in covered, got: {covered_str}"
        )
        _dynamic_test(
            self,
            untested_str == "",
            "Untested functions is empty string if all functions_to_test are tested, even if tested_functions has extras.",
            f"Expected empty untested, got: {untested_str}"
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

A practical course designed for QA Engineers to leverage Python for automating, validating, and analyzing software quality. Learn how to use Python to write robust test scripts, analyze test data, and automate repetitive QA tasks, all with real-world scenarios and hands-on challenges.

Learn how Python can automate common QA tasks, from basic scripting to automating test case execution and validation.

Explore how Python can help QA engineers analyze and visualize test data to identify trends, issues, and opportunities for improvement.

Delve into advanced Python techniques for QA, including test parameterization, random data generation, and integrating with external APIs for test data.

Challenge: Simulate Test Coverage Tracking

解答