In this challenge, you will create a **parameterized test runner** that streamlines the process of executing multiple test cases efficiently. By passing a list of `(input, expected)` value pairs along with a test function, you can automatically run all test scenarios and quickly summarize which tests passed or failed. This approach reduces repetitive code and helps you scale your test coverage with minimal effort. **Parameterized test execution** is a powerful technique for QA engineers, making it easier to maintain and extend test suites as requirements evolve.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_returns_dict_with_keys(self):
        import user_code
        importlib.reload(user_code)
        # Use sample cases from starter code
        cases = [
            (1, 1),
            (2, 2),
            (3, 4),
            (5, 5)
        ]
        result = user_code.parameterized_test_runner(cases, user_code.sample_test_function)
        _dynamic_test(
            self,
            isinstance(result, dict) and 'passes' in result and 'fails' in result,
            "Returned dictionary contains 'passes' and 'fails' keys.",
            f"Returned value does not contain correct keys: {result}",
        )

    def test_pass_and_fail_counts(self):
        import user_code
        importlib.reload(user_code)
        cases = [
            (1, 1), # pass
            (2, 2), # pass
            (3, 4), # fail
            (5, 5)  # pass
        ]
        result = user_code.parameterized_test_runner(cases, user_code.sample_test_function)
        _dynamic_test(
            self,
            result.get('passes', -1) == 3 and result.get('fails', -1) == 1,
            "Correct count of passes (3) and fails (1) for sample_test_function.",
            f"Expected 3 passes and 1 fail, got: {result}",
        )

    def test_works_with_different_test_func(self):
        import user_code
        importlib.reload(user_code)
        def always_false(inp, expected):
            return False
        cases = [
            (1, 1),
            (2, 2),
            (3, 4)
        ]
        result = user_code.parameterized_test_runner(cases, always_false)
        _dynamic_test(
            self,
            result.get('passes', -1) == 0 and result.get('fails', -1) == 3,
            "Works with test function that always fails.",
            f"Expected 0 passes and 3 fails, got: {result}",
        )
        def always_true(inp, expected):
            return True
        result2 = user_code.parameterized_test_runner(cases, always_true)
        _dynamic_test(
            self,
            result2.get('passes', -1) == 3 and result2.get('fails', -1) == 0,
            "Works with test function that always passes.",
            f"Expected 3 passes and 0 fails, got: {result2}",
        )

    def test_empty_cases(self):
        import user_code
        importlib.reload(user_code)
        cases = []
        def dummy(inp, expected):
            return True
        result = user_code.parameterized_test_runner(cases, dummy)
        _dynamic_test(
            self,
            result.get('passes', -1) == 0 and result.get('fails', -1) == 0,
            "Returns zero passes and fails for empty test cases.",
            f"Expected 0 passes and 0 fails for empty cases, got: {result}",
        )

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: Parameterized Test Runner

Løsning

Challenge: Parameterized Test Runner

Løsning