Spotting **outlier test durations** is a vital skill for QA engineers, as it helps you quickly identify problematic tests that may be slowing down your pipeline or masking deeper issues. Outliers among **failed tests** can signal flaky tests, infrastructure hiccups, or code regressions that deserve immediate attention. In this challenge, you will use a hardcoded `pandas` DataFrame representing test cases, each with a `duration` and `status`, and apply `seaborn` to visualize the distribution of test durations. Your goal is to highlight any outliers among the failed tests, making it easier to prioritize investigation and continuous improvement of your test suite.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            "test_case": [
                "test_login", "test_signup", "test_checkout", "test_logout", "test_profile",
                "test_search", "test_payment", "test_cart", "test_wishlist", "test_order"
            ],
            "duration": [2.1, 2.3, 5.6, 2.0, 2.2, 2.5, 18.0, 2.3, 2.4, 2.2],
            "status": [
                "passed", "passed", "failed", "passed", "passed",
                "passed", "failed", "passed", "passed", "passed"
            ]
        }
        self.df = pd.DataFrame(self.data)
        self.user_code = importlib.import_module("user_code")

    def test_function_exists(self):
        func = getattr(self.user_code, 'plot_test_durations_with_outliers', None)
        _dynamic_test(
            self,
            callable(func),
            "Function 'plot_test_durations_with_outliers' is defined.",
            "Function 'plot_test_durations_with_outliers' is not defined."
        )

    def test_plot_is_created(self):
        plt.close('all')
        func = getattr(self.user_code, 'plot_test_durations_with_outliers', None)
        _dynamic_test(
            self,
            callable(func),
            "Function is callable.",
            "Function is not callable."
        )
        # Count number of figures before
        before_figs = len(plt.get_fignums())
        func(self.df)
        after_figs = len(plt.get_fignums())
        _dynamic_test(
            self,
            after_figs > before_figs,
            "A plot figure is created when function is called.",
            "No plot figure created by the function."
        )

    def test_boxplot_grouped_by_status(self):
        plt.close('all')
        func = getattr(self.user_code, 'plot_test_durations_with_outliers', None)
        _dynamic_test(
            self,
            callable(func),
            "Function is callable.",
            "Function is not callable."
        )
        # Patch seaborn.boxplot to capture call arguments
        called_args = {}
        orig_boxplot = sns.boxplot
        def fake_boxplot(*args, **kwargs):
            called_args.update(kwargs)
            return orig_boxplot(*args, **kwargs)
        sns.boxplot = fake_boxplot
        try:
            func(self.df)
            _dynamic_test(
                self,
                called_args.get("x", None) == "status" and called_args.get("y", None) == "duration",
                "Boxplot groups durations by status.",
                f"Boxplot is not grouped by status and duration: args were {called_args}"
            )
        finally:
            sns.boxplot = orig_boxplot

    def test_outliers_are_shown(self):
        plt.close('all')
        func = getattr(self.user_code, 'plot_test_durations_with_outliers', None)
        _dynamic_test(
            self,
            callable(func),
            "Function is callable.",
            "Function is not callable."
        )
        # Patch seaborn.boxplot to capture call arguments
        called_args = {}
        orig_boxplot = sns.boxplot
        def fake_boxplot(*args, **kwargs):
            called_args.update(kwargs)
            return orig_boxplot(*args, **kwargs)
        sns.boxplot = fake_boxplot
        try:
            func(self.df)
            _dynamic_test(
                self,
                called_args.get("showfliers", False) == True,
                "Outliers are displayed in the boxplot (showfliers=True).",
                f"Expected showfliers=True in boxplot, got {called_args.get('showfliers', None)}"
            )
        finally:
            sns.boxplot = orig_boxplot

    def test_uses_provided_dataframe(self):
        # Change the DataFrame and check that plot uses the new data
        plt.close('all')
        func = getattr(self.user_code, 'plot_test_durations_with_outliers', None)
        new_df = pd.DataFrame({
            "test_case": ["a", "b", "c", "d"],
            "duration": [10, 20, 30, 40],
            "status": ["passed", "failed", "failed", "passed"]
        })
        called_args = {}
        orig_boxplot = sns.boxplot
        def fake_boxplot(*args, **kwargs):
            called_args.update(kwargs)
            return orig_boxplot(*args, **kwargs)
        sns.boxplot = fake_boxplot
        try:
            func(new_df)
            _dynamic_test(
                self,
                called_args.get("data", None) is new_df,
                "Function uses the DataFrame provided as input.",
                "Function did not use the DataFrame provided as input to boxplot."
            )
        finally:
            sns.boxplot = orig_boxplot

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: Identify Outlier Test Durations

解答