Automating the process of updating test case statuses saves time and reduces human error in quality assurance workflows. By programmatically comparing the `expected` and `actual` results for each test case, you can instantly determine whether each test passes or fails. This challenge will help you practice using Python to efficiently update test case records, a common task when managing large test suites.


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

class TestTask(unittest.TestCase):
    def test_pass_status_for_equal_values(self):
        import user_code
        importlib.reload(user_code)
        test_cases = [
            {'id': 1, 'expected': 'A', 'actual': 'A'},
            {'id': 2, 'expected': 100, 'actual': 100},
            {'id': 3, 'expected': True, 'actual': True},
            {'id': 4, 'expected': None, 'actual': None},
        ]
        result = user_code.update_test_case_status([d.copy() for d in test_cases])
        all_pass = all(tc.get('status') == 'PASS' for tc in result)
        _dynamic_test(
            self,
            all_pass,
            "Status set to 'PASS' for all equal 'expected' and 'actual' values.",
            f"Expected all status to be 'PASS', got: {[tc.get('status') for tc in result]}",
        )

    def test_fail_status_for_unequal_values(self):
        import user_code
        importlib.reload(user_code)
        test_cases = [
            {'id': 1, 'expected': 'A', 'actual': 'B'},
            {'id': 2, 'expected': 100, 'actual': 200},
            {'id': 3, 'expected': False, 'actual': True},
            {'id': 4, 'expected': None, 'actual': 0},
        ]
        result = user_code.update_test_case_status([d.copy() for d in test_cases])
        all_fail = all(tc.get('status') == 'FAIL' for tc in result)
        _dynamic_test(
            self,
            all_fail,
            "Status set to 'FAIL' for all unequal 'expected' and 'actual' values.",
            f"Expected all status to be 'FAIL', got: {[tc.get('status') for tc in result]}",
        )

    def test_status_field_added(self):
        import user_code
        importlib.reload(user_code)
        test_cases = [
            {'id': 1, 'expected': 5, 'actual': 5},
            {'id': 2, 'expected': 5, 'actual': 6},
        ]
        result = user_code.update_test_case_status([d.copy() for d in test_cases])
        has_status = all('status' in tc for tc in result)
        _dynamic_test(
            self,
            has_status,
            "All test cases have 'status' field added.",
            f"Not all test cases have 'status' field: {result}",
        )

    def test_existing_fields_untouched(self):
        import user_code
        importlib.reload(user_code)
        test_cases = [
            {'id': 1, 'expected': 1, 'actual': 1, 'custom': 'foo'},
            {'id': 2, 'expected': 2, 'actual': 3, 'meta': 123},
        ]
        orig_keys = [set(tc.keys()) for tc in test_cases]
        result = user_code.update_test_case_status([d.copy() for d in test_cases])
        for i, tc in enumerate(result):
            expected_keys = orig_keys[i] | {'status'}
            _dynamic_test(
                self,
                set(tc.keys()) == expected_keys,
                f"All original fields plus 'status' are present for test case {i+1}.",
                f"Fields changed for test case {i+1}: {tc.keys()} vs {expected_keys}",
            )

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: Test Case Status Updater

Solution