Efficiently summarizing test results is a core skill for any QA engineer, as it enables you to quickly assess the health of your testing process and communicate outcomes to your team. In this challenge, you will put your Python skills to use by writing a script that processes a hardcoded list of test case results. Your script will calculate and display the total number of tests, the number of passes, the number of fails, and the pass rate as a percentage. Mastering this type of automation will help you streamline your daily QA tasks and ensure that critical information is always at your fingertips.


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_total_tests_count(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_test_results(['PASS', 'FAIL', 'PASS', 'FAIL'])
        output = f.getvalue()
        _dynamic_test(
            self,
            'Total tests: 4' in output,
            "Correct total test count printed for non-empty list.",
            f"Expected 'Total tests: 4' in output, got: {output}"
        )

    def test_passes_count(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_test_results(['PASS', 'FAIL', 'PASS', 'FAIL'])
        output = f.getvalue()
        _dynamic_test(
            self,
            'Passes: 2' in output,
            "Correct number of passes printed.",
            f"Expected 'Passes: 2' in output, got: {output}"
        )

    def test_fails_count(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_test_results(['PASS', 'FAIL', 'PASS', 'FAIL'])
        output = f.getvalue()
        _dynamic_test(
            self,
            'Fails: 2' in output,
            "Correct number of fails printed.",
            f"Expected 'Fails: 2' in output, got: {output}"
        )

    def test_pass_rate_percentage(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_test_results(['PASS', 'FAIL', 'PASS', 'FAIL'])
        output = f.getvalue()
        _dynamic_test(
            self,
            'Pass rate: 50.00%' in output,
            "Correct pass rate percentage printed (two decimals).",
            f"Expected 'Pass rate: 50.00%' in output, got: {output}"
        )

    def test_empty_list(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_test_results([])
        output = f.getvalue()
        _dynamic_test(
            self,
            'Total tests: 0' in output and 'Passes: 0' in output and 'Fails: 0' in output and 'Pass rate: 0.00%' in output,
            "Correct summary for empty test list.",
            f"Expected correct summary for empty list, got: {output}"
        )

    def test_all_pass(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_test_results(['PASS', 'PASS', 'PASS'])
        output = f.getvalue()
        _dynamic_test(
            self,
            'Total tests: 3' in output and 'Passes: 3' in output and 'Fails: 0' in output and 'Pass rate: 100.00%' in output,
            "Correct summary for all passes.",
            f"Expected correct summary for all passes, got: {output}"
        )

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: Automate Test Result Summarization

解答