In QA engineering, **visual summaries** such as charts are powerful tools for quickly communicating the outcomes of test executions to both technical and non-technical stakeholders. **Pie charts**, in particular, are effective for illustrating the proportion of passed and failed tests, making it easy to spot issues at a glance and prioritize further investigation. In this challenge, you will practice your data visualization skills by creating a pie chart that displays the distribution of test statuses from a static list.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import matplotlib
matplotlib.use('Agg')  # Use non-interactive backend for testing
import matplotlib.pyplot as plt
import user_code

class TestTask(unittest.TestCase):
    def setUp(self):
        self.test_statuses = ["passed", "failed", "passed", "passed", "failed", "passed", "failed", "passed", "passed", "failed"]
        self.expected_counts = (6, 4)  # passed, failed
        # Patch plt.show to prevent actual chart popup
        self._original_show = plt.show
        plt.show = lambda: None

    def tearDown(self):
        plt.show = self._original_show

    def test_counts_correct(self):
        # Test that function counts passed/failed correctly
        importlib.reload(user_code)
        func = getattr(user_code, "plot_test_status_pie", None)
        _dynamic_test(
            self,
            callable(func),
            "plot_test_status_pie is defined as a function",
            "plot_test_status_pie is not defined or not callable",
        )
        # Patch plt.pie to capture input
        captured = {}
        def fake_pie(counts, labels=None, colors=None, autopct=None, startangle=None, explode=None):
            captured["counts"] = counts
            captured["labels"] = labels
            captured["colors"] = colors
            captured["autopct"] = autopct
            captured["startangle"] = startangle
            captured["explode"] = explode
            return [None, None, None]
        orig_pie = plt.pie
        plt.pie = fake_pie
        try:
            func(self.test_statuses)
        finally:
            plt.pie = orig_pie
        expected = [self.expected_counts[0], self.expected_counts[1]]
        _dynamic_test(
            self,
            "counts" in captured and captured["counts"] == expected,
            f"Counts passed to pie are correct: {expected}",
            f"Counts passed to pie are incorrect. Expected {expected}, got {captured.get('counts')}",
        )

    def test_labels_and_colors(self):
        importlib.reload(user_code)
        func = getattr(user_code, "plot_test_status_pie", None)
        captured = {}
        def fake_pie(counts, labels=None, colors=None, autopct=None, startangle=None, explode=None):
            captured["labels"] = labels
            captured["colors"] = colors
            return [None, None, None]
        orig_pie = plt.pie
        plt.pie = fake_pie
        try:
            func(self.test_statuses)
        finally:
            plt.pie = orig_pie
        _dynamic_test(
            self,
            "labels" in captured and isinstance(captured["labels"], list) and "Passed" in captured["labels"] and "Failed" in captured["labels"],
            "Pie chart labels include 'Passed' and 'Failed'",
            f"Pie chart labels missing or incorrect: {captured.get('labels')}",
        )
        _dynamic_test(
            self,
            "colors" in captured and isinstance(captured["colors"], list) and len(set(captured["colors"])) == 2,
            "Pie chart uses two different colors",
            f"Pie chart colors missing or not two distinct values: {captured.get('colors')}",
        )

    def test_percentage_labels(self):
        importlib.reload(user_code)
        func = getattr(user_code, "plot_test_status_pie", None)
        captured = {}
        def fake_pie(counts, labels=None, colors=None, autopct=None, startangle=None, explode=None):
            captured["autopct"] = autopct
            return [None, None, None]
        orig_pie = plt.pie
        plt.pie = fake_pie
        try:
            func(self.test_statuses)
        finally:
            plt.pie = orig_pie
        _dynamic_test(
            self,
            "autopct" in captured and "%" in str(captured["autopct"]),
            "Pie chart displays percentage labels",
            f"Pie chart autopct missing or not showing percentages: {captured.get('autopct')}",
        )

    def test_title_and_equal_aspect(self):
        importlib.reload(user_code)
        func = getattr(user_code, "plot_test_status_pie", None)
        captured = {"title": None, "aspect": None}
        orig_title = plt.title
        orig_axis = plt.axis
        def fake_title(val):
            captured["title"] = val
        def fake_axis(val):
            captured["aspect"] = val
        plt.title = fake_title
        plt.axis = fake_axis
        try:
            func(self.test_statuses)
        finally:
            plt.title = orig_title
            plt.axis = orig_axis
        _dynamic_test(
            self,
            normalize_text(captured["title"] or "") == normalize_text("Test Status Distribution"),
            "Chart title set to 'Test Status Distribution'",
            f"Chart title incorrect or missing: {captured['title']}",
        )
        _dynamic_test(
            self,
            captured["aspect"] == "equal",
            "Chart aspect ratio set to equal",
            f"Chart aspect not set to 'equal': {captured['aspect']}",
        )

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: Visualize Test Status Distribution

解答