|
| 1 | +#!/usr/bin/env python3 |
| 2 | +""" |
| 3 | +Script to standardize mock_response usage in test files. |
| 4 | +
|
| 5 | +This script finds test files that use direct mock_response manipulation and |
| 6 | +converts them to use mock_response_factory instead. |
| 7 | +""" |
| 8 | + |
| 9 | +# Standard library imports |
| 10 | +import os |
| 11 | +from pathlib import Path |
| 12 | +import re |
| 13 | +import sys |
| 14 | +from typing import List |
| 15 | +from typing import Tuple |
| 16 | + |
| 17 | + |
| 18 | +def find_pattern_in_file(file_path: str, pattern: str) -> List[str]: |
| 19 | + """Find all matches of pattern in the given file.""" |
| 20 | + with open(file_path, "r") as f: |
| 21 | + content = f.read() |
| 22 | + return re.findall(pattern, content, re.MULTILINE) |
| 23 | + |
| 24 | + |
| 25 | +def transform_file(file_path: str, dry_run: bool = False) -> bool: |
| 26 | + """Transform a file to use mock_response_factory.""" |
| 27 | + with open(file_path, "r") as f: |
| 28 | + content = f.read() |
| 29 | + |
| 30 | + # Backup original content |
| 31 | + original_content = content |
| 32 | + |
| 33 | + # Pattern 1: def test_*(mock_response) -> def test_*(mock_response_factory) |
| 34 | + # Find all test function definitions |
| 35 | + test_pattern = r"(def\s+test_\w+\([^)]*)(,\s*mock_response)(\s*[,)].*)" |
| 36 | + |
| 37 | + def param_replacement(match): |
| 38 | + before = match.group(1) |
| 39 | + param = match.group(2).replace("mock_response", "mock_response_factory") |
| 40 | + after = match.group(3) |
| 41 | + return f"{before}{param}{after}" |
| 42 | + |
| 43 | + content = re.sub(test_pattern, param_replacement, content) |
| 44 | + |
| 45 | + # Pattern 2: mock_response.json.return_value = {...} |
| 46 | + pattern2 = r"([ \t]*)mock_response\.json\.return_value\s*=\s*({[^;]*}|\[[^;]*\])" |
| 47 | + |
| 48 | + def replacement2(match): |
| 49 | + indent = match.group(1) |
| 50 | + data = match.group(2).strip() |
| 51 | + # Ensure data has balanced braces |
| 52 | + open_braces = data.count("{") - data.count("}") |
| 53 | + open_brackets = data.count("[") - data.count("]") |
| 54 | + |
| 55 | + if open_braces != 0 or open_brackets != 0: |
| 56 | + # Skip this match as it has unbalanced braces or brackets |
| 57 | + return match.group(0) |
| 58 | + |
| 59 | + return f"{indent}mock_response = mock_response_factory(\n{indent} 200, \n{indent} {data}\n{indent})" |
| 60 | + |
| 61 | + content = re.sub(pattern2, replacement2, content) |
| 62 | + |
| 63 | + # Pattern 3: mock_response.status_code = 204 |
| 64 | + pattern3 = r"([ \t]*)mock_response\.status_code\s*=\s*(\d+)" |
| 65 | + |
| 66 | + def replacement3(match): |
| 67 | + indent = match.group(1) |
| 68 | + status_code = match.group(2) |
| 69 | + return f"{indent}mock_response = mock_response_factory({status_code})" |
| 70 | + |
| 71 | + content = re.sub(pattern3, replacement3, content) |
| 72 | + |
| 73 | + # Pattern 4: We're disabling this pattern for now as it was causing issues |
| 74 | + # The goal was to change order of assignments (response assignment should come before oauth assignment) |
| 75 | + # but it was causing syntax errors |
| 76 | + """ |
| 77 | + pattern4 = r'([ \t]*)(.*?)\.oauth(?:\.|\w+\.)*request\.return_value\s*=\s*mock_response\n([ \t]*)mock_response\s*=\s*mock_response_factory' |
| 78 | + |
| 79 | + def replacement4(match): |
| 80 | + indent1 = match.group(1) |
| 81 | + obj = match.group(2) |
| 82 | + indent2 = match.group(3) |
| 83 | + return f"{indent2}mock_response = mock_response_factory\n{indent1}{obj}.oauth.request.return_value = mock_response" |
| 84 | + |
| 85 | + content = re.sub(pattern4, replacement4, content) |
| 86 | + """ |
| 87 | + |
| 88 | + # Pattern 5: Fix cases where test was updated to use mock_response_factory as parameter |
| 89 | + # but still uses mock_response in the body |
| 90 | + pattern5 = r"def\s+test_\w+\([^)]*mock_response_factory[^)]*\).*?(?=\n\s*def|\Z)" |
| 91 | + |
| 92 | + def fix_mock_response_usage(match): |
| 93 | + test_func = match.group(0) |
| 94 | + # If the function uses mock_response_factory but also has direct mock_response usage |
| 95 | + if ( |
| 96 | + "mock_response.json.return_value =" in test_func |
| 97 | + or "mock_response.status_code =" in test_func |
| 98 | + ): |
| 99 | + # Add a mock_response declaration at the beginning of the function body |
| 100 | + # Find the first indented line after the function def |
| 101 | + lines = test_func.split("\n") |
| 102 | + for i, line in enumerate(lines): |
| 103 | + if i > 0 and line.strip() and not line.strip().startswith("#"): |
| 104 | + indent = re.match(r"(\s*)", line).group(1) |
| 105 | + # Insert the mock_response assignment after docstring (if any) |
| 106 | + for j in range(i, len(lines)): |
| 107 | + if not lines[j].strip().startswith('"""') and not lines[ |
| 108 | + j |
| 109 | + ].strip().startswith("'''"): |
| 110 | + lines.insert(j, f"{indent}mock_response = mock_response_factory(200)") |
| 111 | + break |
| 112 | + break |
| 113 | + return "\n".join(lines) |
| 114 | + return test_func |
| 115 | + |
| 116 | + content = re.sub(pattern5, fix_mock_response_usage, content, flags=re.DOTALL) |
| 117 | + |
| 118 | + # Pattern 6: Replace assert result == mock_response.json.return_value with assert result == expected_data |
| 119 | + pattern6 = r"([ \t]*assert\s+.*?==\s*)mock_response\.json\.return_value" |
| 120 | + |
| 121 | + def fix_assertions(match): |
| 122 | + before_part = match.group(1) |
| 123 | + return f"{before_part}mock_response.json()" |
| 124 | + |
| 125 | + content = re.sub(pattern6, fix_assertions, content) |
| 126 | + |
| 127 | + # If no changes were made, return False |
| 128 | + if content == original_content: |
| 129 | + return False |
| 130 | + |
| 131 | + # Write the changes back to the file |
| 132 | + if not dry_run: |
| 133 | + with open(file_path, "w") as f: |
| 134 | + f.write(content) |
| 135 | + |
| 136 | + return True |
| 137 | + |
| 138 | + |
| 139 | +def find_files_to_transform() -> List[Tuple[str, bool]]: |
| 140 | + """Find all test files that need to be transformed.""" |
| 141 | + test_dir = Path("tests") |
| 142 | + # Allow specifying a subdirectory |
| 143 | + if len(sys.argv) > 1 and not sys.argv[1].startswith("--"): |
| 144 | + test_dir = Path(sys.argv[1]) |
| 145 | + print(f"Searching in directory: {test_dir}") |
| 146 | + |
| 147 | + result = [] |
| 148 | + verbose = "--verbose" in sys.argv |
| 149 | + |
| 150 | + for root, _, files in os.walk(test_dir): |
| 151 | + for file in files: |
| 152 | + if file.endswith(".py") and file.startswith("test_"): |
| 153 | + file_path = os.path.join(root, file) |
| 154 | + |
| 155 | + # First check for any mention of mock_response |
| 156 | + has_mock_response = bool(find_pattern_in_file(file_path, r"mock_response")) |
| 157 | + |
| 158 | + if not has_mock_response: |
| 159 | + continue |
| 160 | + |
| 161 | + # More detailed patterns |
| 162 | + # Check if file uses mock_response directly as parameter |
| 163 | + uses_mock_response = bool( |
| 164 | + find_pattern_in_file( |
| 165 | + file_path, r"def\s+test_\w+\([^)]*,\s*mock_response\s*[,)]" |
| 166 | + ) |
| 167 | + ) |
| 168 | + |
| 169 | + # Check if file directly manipulates mock_response |
| 170 | + manipulates_mock_response = bool( |
| 171 | + find_pattern_in_file( |
| 172 | + file_path, r"mock_response\.(json\.return_value|status_code)\s*=" |
| 173 | + ) |
| 174 | + ) |
| 175 | + |
| 176 | + # Check if file uses mock_response.json.return_value in assertions |
| 177 | + uses_return_value_in_assertions = bool( |
| 178 | + find_pattern_in_file( |
| 179 | + file_path, r"assert\s+.*?=.*?mock_response\.json\.return_value" |
| 180 | + ) |
| 181 | + ) |
| 182 | + |
| 183 | + # Check if file uses mock_response_factory |
| 184 | + uses_factory = bool( |
| 185 | + find_pattern_in_file(file_path, r"mock_response\s*=\s*mock_response_factory") |
| 186 | + ) |
| 187 | + |
| 188 | + # Determine if file needs transformation |
| 189 | + needs_transform = ( |
| 190 | + uses_mock_response or manipulates_mock_response |
| 191 | + ) and not uses_factory |
| 192 | + |
| 193 | + # Also flag files that use factory but still use mock_response.json.return_value in assertions |
| 194 | + if uses_factory and uses_return_value_in_assertions and not needs_transform: |
| 195 | + needs_transform = True |
| 196 | + |
| 197 | + if verbose or needs_transform: |
| 198 | + print(f"File: {file_path}") |
| 199 | + print(f" Has mock_response: {has_mock_response}") |
| 200 | + print(f" Uses as parameter: {uses_mock_response}") |
| 201 | + print(f" Manipulates: {manipulates_mock_response}") |
| 202 | + print(f" Uses in assertions: {uses_return_value_in_assertions}") |
| 203 | + print(f" Uses factory: {uses_factory}") |
| 204 | + print(f" Needs transform: {needs_transform}") |
| 205 | + |
| 206 | + if needs_transform: |
| 207 | + result.append((file_path, needs_transform)) |
| 208 | + |
| 209 | + return result |
| 210 | + |
| 211 | + |
| 212 | +def main(): |
| 213 | + """Main entry point.""" |
| 214 | + dry_run = "--dry-run" in sys.argv |
| 215 | + files = find_files_to_transform() |
| 216 | + |
| 217 | + print(f"Found {len(files)} files that need to be transformed.") |
| 218 | + if dry_run: |
| 219 | + print("Running in dry-run mode. No files will be modified.") |
| 220 | + |
| 221 | + for file_path, _ in files: |
| 222 | + print(f"Transforming {file_path}...", end="") |
| 223 | + transformed = transform_file(file_path, dry_run) |
| 224 | + print(" TRANSFORMED" if transformed else " SKIPPED (no changes)") |
| 225 | + |
| 226 | + print("\nDone!") |
| 227 | + print(f"Transformed {len(files)} files.") |
| 228 | + |
| 229 | + if dry_run: |
| 230 | + print("\nRun without --dry-run to apply changes.") |
| 231 | + |
| 232 | + |
| 233 | +if __name__ == "__main__": |
| 234 | + main() |
0 commit comments