In automated QA, **data validation** is a crucial step to ensure that API responses meet the expected structure and content. As you work with APIs, you will often encounter scenarios where responses are missing required fields, which can lead to test failures or undetected issues in production. Automating the validation of API responses not only saves time but also increases the reliability of your testing process. Your challenge is to implement a function that inspects a batch of API responses (represented as dictionaries) and identifies any responses that are missing key fields. This technique is essential for robust automated QA pipelines and helps you quickly spot incomplete or malformed data.


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

class TestTask(unittest.TestCase):
    def test_returns_ids_of_incomplete_responses(self):
        import user_code
        importlib.reload(user_code)
        responses = [
            {'id': 1, 'status': 'OK', 'message': 'All good'},
            {'id': 2, 'status': 'FAIL'},
            {'id': 3, 'message': 'Missing status'},
            {'id': 4, 'status': 'OK', 'message': 'All good'},
            {'id': 5, 'status': 'OK'},
        ]
        result = user_code.find_incomplete_responses(responses)
        expected = [2, 3, 5]
        _dynamic_test(
            self,
            result == expected,
            f"Correct ids for incomplete responses: {expected}",
            f"Expected {expected}, got {result}",
        )

    def test_none_for_missing_id(self):
        import user_code
        importlib.reload(user_code)
        responses = [
            {'status': 'OK', 'message': 'No id'}, # missing id
            {'id': 7, 'status': 'FAIL'}, # missing message
        ]
        result = user_code.find_incomplete_responses(responses)
        expected = [None, 7]
        _dynamic_test(
            self,
            result == expected,
            f"Correctly adds None for missing id and 7 for missing message.",
            f"Expected {expected}, got {result}",
        )

    def test_no_incomplete_responses(self):
        import user_code
        importlib.reload(user_code)
        responses = [
            {'id': 10, 'status': 'OK', 'message': 'A'},
            {'id': 11, 'status': 'FAIL', 'message': 'B'},
        ]
        result = user_code.find_incomplete_responses(responses)
        expected = []
        _dynamic_test(
            self,
            result == expected,
            "Returns empty list when all responses are complete.",
            f"Expected empty list, got {result}",
        )

    def test_order_of_ids_preserved(self):
        import user_code
        importlib.reload(user_code)
        responses = [
            {'id': 20, 'status': 'OK'}, # missing message
            {'id': 21, 'message': 'Missing status'}, # missing status
            {'status': 'FAIL', 'message': 'Missing id'}, # missing id
        ]
        result = user_code.find_incomplete_responses(responses)
        expected = [20, 21, None]
        _dynamic_test(
            self,
            result == expected,
            "Order of ids for incomplete responses is preserved.",
            f"Expected {expected}, got {result}",
        )

    def test_sample_data(self):
        import user_code
        importlib.reload(user_code)
        responses = [
            {'id': 101, 'status': 'OK', 'message': 'Success'},
            {'id': 102, 'status': 'FAIL'},
            {'status': 'OK', 'message': 'Partial'},
            {'id': 104, 'status': 'OK', 'message': 'Done'},
            {'id': 105, 'message': 'Missing status'}
        ]
        result = user_code.find_incomplete_responses(responses)
        expected = [102, None, 105]
        _dynamic_test(
            self,
            result == expected,
            f"Sample data returns {expected}",
            f"Expected {expected}, 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: Data Validator for API Responses

解答