In quality assurance, being able to quickly pinpoint failed tests and spot performance issues is critical. When you have a large suite of automated tests, efficiently extracting the IDs of failed tests and determining the average duration of passing tests helps you focus your debugging efforts and optimize your test runs. In this challenge, you will use **pandas** to analyze a **DataFrame** of test case results, practicing your ability to filter, aggregate, and extract key metrics that matter most in real-world QA scenarios.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd

class TestTask(unittest.TestCase):
    def test_failed_ids_and_avg_duration(self):
        import user_code
        importlib.reload(user_code)
        data = {
            'id': [10, 20, 30, 40, 50],
            'status': ['passed', 'failed', 'passed', 'failed', 'passed'],
            'duration': [1.0, 2.0, 1.5, 3.0, 0.5]
        }
        df = pd.DataFrame(data)
        func = getattr(user_code, 'analyze_test_results', None)
        _dynamic_test(
            self,
            callable(func),
            "Function 'analyze_test_results' is defined.",
            "Function 'analyze_test_results' is not defined."
        )
        result = func(df) if func else None
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and len(result) == 2,
            "Function returns a tuple of length 2.",
            f"Function should return a tuple of length 2, got: {result}"
        )
        failed_ids, avg_duration = result if result else (None, None)
        _dynamic_test(
            self,
            failed_ids == [20, 40],
            "Correctly extracts IDs of failed tests.",
            f"Expected failed IDs [20, 40], got: {failed_ids}"
        )
        _dynamic_test(
            self,
            abs(avg_duration - 1.0) < 1e-6,
            "Correctly calculates average duration for passing tests.",
            f"Expected average duration 1.0, got: {avg_duration}"
        )

    def test_no_passing_tests(self):
        import user_code
        importlib.reload(user_code)
        data = {
            'id': [1, 2, 3],
            'status': ['failed', 'failed', 'failed'],
            'duration': [2.0, 2.5, 3.0]
        }
        df = pd.DataFrame(data)
        func = getattr(user_code, 'analyze_test_results', None)
        result = func(df) if func else None
        failed_ids, avg_duration = result if result else (None, None)
        _dynamic_test(
            self,
            failed_ids == [1, 2, 3],
            "Returns all IDs as failed when no passing tests.",
            f"Expected failed IDs [1, 2, 3], got: {failed_ids}"
        )
        _dynamic_test(
            self,
            avg_duration is None,
            "Returns None for average duration when no passing tests.",
            f"Expected None for average duration, got: {avg_duration}"
        )

    def test_no_failed_tests(self):
        import user_code
        importlib.reload(user_code)
        data = {
            'id': [1, 2, 3],
            'status': ['passed', 'passed', 'passed'],
            'duration': [1.0, 1.5, 2.0]
        }
        df = pd.DataFrame(data)
        func = getattr(user_code, 'analyze_test_results', None)
        result = func(df) if func else None
        failed_ids, avg_duration = result if result else (None, None)
        _dynamic_test(
            self,
            failed_ids == [],
            "Returns empty list for failed IDs when no failed tests.",
            f"Expected [], got: {failed_ids}"
        )
        _dynamic_test(
            self,
            abs(avg_duration - 1.5) < 1e-6,
            "Calculates correct average for all passing tests.",
            f"Expected average duration 1.5, got: {avg_duration}"
        )

    def test_empty_dataframe(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame({'id': [], 'status': [], 'duration': []})
        func = getattr(user_code, 'analyze_test_results', None)
        result = func(df) if func else None
        failed_ids, avg_duration = result if result else (None, None)
        _dynamic_test(
            self,
            failed_ids == [],
            "Returns empty list for failed IDs on empty DataFrame.",
            f"Expected [], got: {failed_ids}"
        )
        _dynamic_test(
            self,
            avg_duration is None,
            "Returns None for average duration on empty DataFrame.",
            f"Expected None for average duration, got: {avg_duration}"
        )

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: Analyze Test Failures with Pandas

Oplossing

Challenge: Analyze Test Failures with Pandas

Oplossing