unittest_report_origin.py (13972B)
1 """Standalone nofollow source reads and canonical module ancestry admission.""" 2 3 from __future__ import annotations 4 5 import hashlib 6 import importlib.machinery 7 import importlib.util 8 import os 9 import re 10 import stat 11 import sys 12 import types 13 from pathlib import Path 14 15 MAX_BYTES = 2_000_000 16 MAX_ITEMS = 4096 17 MODULE = re.compile(r"scripts(?:\.[A-Za-z_][A-Za-z0-9_]*)*\.test_[A-Za-z0-9_]+") 18 19 20 class ReportError(Exception): 21 """A stable, secret-free report rejection.""" 22 23 24 def require(condition, message): 25 if not condition: 26 raise ReportError(message) 27 28 29 def selectors(values): 30 require(0 < len(values) <= MAX_ITEMS, "selected module count is invalid") 31 seen = set() 32 for value in values: 33 require( 34 isinstance(value, str) and len(value) <= 255, "selected module is invalid" 35 ) 36 require(MODULE.fullmatch(value) is not None, "selected module is not canonical") 37 require(value not in seen, "selected module is duplicated") 38 seen.add(value) 39 return values 40 41 42 def open_directory(path): 43 """Walk every component with nofollow; retain the actual directory descriptor.""" 44 require( 45 isinstance(path, str) and 0 < len(path) <= 4096 and "\x00" not in path, 46 "output path is invalid", 47 ) 48 absolute = path.startswith("/") 49 descriptor = os.open("/" if absolute else ".", os.O_RDONLY | os.O_DIRECTORY) 50 try: 51 for component in path.split("/"): 52 if not component or component == ".": 53 continue 54 child = os.open( 55 component, 56 os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, 57 dir_fd=descriptor, 58 ) 59 os.close(descriptor) 60 descriptor = child 61 return descriptor 62 except BaseException: 63 os.close(descriptor) 64 raise 65 66 67 def identity(information): 68 return (information.st_dev, information.st_ino) 69 70 71 def source_metadata(information): 72 return ( 73 identity(information), 74 information.st_mode, 75 information.st_nlink, 76 information.st_size, 77 information.st_mtime_ns, 78 information.st_ctime_ns, 79 ) 80 81 82 def source_snapshot(root, relative, *, allow_empty=False): 83 directory = open_directory(str(root / relative.parent)) 84 try: 85 descriptor = os.open( 86 relative.name, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=directory 87 ) 88 try: 89 before = os.fstat(descriptor) 90 require( 91 stat.S_ISREG(before.st_mode) 92 and int(not allow_empty) <= before.st_size <= MAX_BYTES, 93 "source origin is not a bounded regular file", 94 ) 95 digest = hashlib.sha256() 96 chunks = [] 97 remaining = before.st_size 98 while remaining: 99 chunk = os.read(descriptor, min(65536, remaining)) 100 require(bool(chunk), "source origin changed while reading") 101 digest.update(chunk) 102 chunks.append(chunk) 103 remaining -= len(chunk) 104 after = os.fstat(descriptor) 105 require( 106 source_metadata(before) == source_metadata(after), 107 "source origin changed while reading", 108 ) 109 current = os.stat(relative.name, dir_fd=directory, follow_symlinks=False) 110 require( 111 source_metadata(current) == source_metadata(before), 112 "source origin identity changed", 113 ) 114 return (source_metadata(before), digest.hexdigest()), b"".join(chunks) 115 finally: 116 os.close(descriptor) 117 finally: 118 os.close(directory) 119 120 121 def source_identity(root, relative): 122 return source_snapshot(root, relative, allow_empty=relative.name == "__init__.py")[ 123 0 124 ] 125 126 127 def owned_origin(module, expected): 128 require( 129 getattr(module, "__file__", None) == str(expected), 130 "loaded module file origin differs", 131 ) 132 require( 133 getattr(getattr(module, "__spec__", None), "origin", None) == str(expected), 134 "loaded module specification origin differs", 135 ) 136 137 138 def directory_identity(root, relative): 139 descriptor = open_directory(str(root / relative)) 140 try: 141 information = os.fstat(descriptor) 142 return identity(information), information.st_mode 143 finally: 144 os.close(descriptor) 145 146 147 def initializer_snapshot(root, directory): 148 relative = directory / "__init__.py" 149 descriptor = open_directory(str(root / directory)) 150 try: 151 try: 152 os.stat(relative.name, dir_fd=descriptor, follow_symlinks=False) 153 except FileNotFoundError: 154 return None 155 return source_snapshot(root, relative, allow_empty=True)[0] 156 finally: 157 os.close(descriptor) 158 159 160 class SourceFence: 161 """Fence all selected bytes and ancestry before any selected code executes.""" 162 163 def __init__(self, root, names): 164 self.root = root 165 self.sources, self.directories, self.initializers, self.loaded = {}, {}, {}, {} 166 for name in names: 167 components = name.split(".") 168 for length in range(1, len(components)): 169 directory = Path(*components[:length]) 170 self.directories[directory] = directory_identity(root, directory) 171 self.initializers[directory] = initializer_snapshot(root, directory) 172 relative = Path(*components).with_suffix(".py") 173 self.sources[relative] = source_identity(root, relative) 174 self.verify() 175 176 def verify(self): 177 for relative, before in self.sources.items(): 178 require( 179 source_identity(self.root, relative) == before, 180 "selected source changed", 181 ) 182 for directory, before in self.directories.items(): 183 require( 184 directory_identity(self.root, directory) == before, 185 "package directory changed", 186 ) 187 require( 188 initializer_snapshot(self.root, directory) 189 == self.initializers[directory], 190 "package initializer changed", 191 ) 192 for name, module in self.loaded.items(): 193 require(sys.modules.get(name) is module, "loaded module identity changed") 194 self.module_origin(name, module) 195 196 def module_origin(self, name, module): 197 directory = Path(*name.split(".")) 198 if directory not in self.directories: 199 owned_origin(module, (self.root / directory).with_suffix(".py")) 200 require( 201 module.__name__ == name 202 and module.__spec__.name == name 203 and type(module.__spec__.loader) 204 is importlib.machinery.SourceFileLoader, 205 "selected module identity or loader differs", 206 ) 207 return 208 self.package_spec(name, module.__spec__) 209 require( 210 list(getattr(module, "__path__", [])) == [str(self.root / directory)], 211 "loaded package search path differs", 212 ) 213 initializer = self.initializers[directory] 214 expected = str(self.root / directory / "__init__.py") if initializer else None 215 require( 216 getattr(module, "__file__", None) == expected, "loaded package file differs" 217 ) 218 219 def package_spec(self, name, spec): 220 directory = Path(*name.split(".")) 221 initializer = self.initializers[directory] 222 require(spec is not None and spec.name == name, "package specification differs") 223 expected = str(self.root / directory / "__init__.py") if initializer else None 224 require(spec.origin == expected, "package origin differs") 225 require( 226 list(spec.submodule_search_locations or []) == [str(self.root / directory)], 227 "package specification search path differs", 228 ) 229 expected_loader = ( 230 importlib.machinery.SourceFileLoader 231 if initializer 232 else importlib.machinery.NamespaceLoader 233 ) 234 require(type(spec.loader) is expected_loader, "package loader differs") 235 236 def package(self, name): 237 directory = Path(*name.split(".")) 238 self.verify() 239 if name in sys.modules: 240 module = sys.modules[name] 241 self.module_origin(name, module) 242 else: 243 spec = importlib.machinery.PathFinder.find_spec( 244 name, [str(self.root / directory.parent)] 245 ) 246 require(spec is not None, "package resolution failed") 247 module = importlib.util.module_from_spec(spec) 248 self.package_spec(name, module.__spec__) 249 sys.modules[name] = module 250 if name == "scripts": 251 for child in ("unittest_report", "unittest_report_origin"): 252 loaded = sys.modules.get(name + "." + child) 253 if loaded is not None: 254 owned_origin(loaded, self.root / directory / (child + ".py")) 255 setattr(module, child, loaded) 256 initializer = self.initializers[directory] 257 if initializer: 258 before, raw = source_snapshot( 259 self.root, directory / "__init__.py", allow_empty=True 260 ) 261 require( 262 before == initializer, "package initializer changed before import" 263 ) 264 exec( 265 compile(raw, str(self.root / directory / "__init__.py"), "exec"), 266 module.__dict__, 267 ) 268 self.module_origin(name, module) 269 self.loaded[name] = module 270 self.verify() 271 272 def selected(self, name): 273 components = name.split(".") 274 for length in range(1, len(components)): 275 self.package(".".join(components[:length])) 276 relative = Path(*components).with_suffix(".py") 277 spec = importlib.util.find_spec(name) 278 require( 279 spec is not None and spec.origin == str(self.root / relative), 280 "selected module resolution origin differs", 281 ) 282 require( 283 type(spec.loader) is importlib.machinery.SourceFileLoader, 284 "selected module loader differs", 285 ) 286 module = importlib.util.module_from_spec(spec) 287 self.verify() 288 sys.modules[name] = module 289 before, raw = source_snapshot(self.root, relative) 290 require( 291 before == self.sources[relative], "selected source changed before import" 292 ) 293 exec(compile(raw, str(self.root / relative), "exec"), module.__dict__) 294 self.module_origin(name, module) 295 self.loaded[name] = module 296 self.verify() 297 return module 298 299 300 def load_modules(root, names): 301 fence = SourceFence(root, names) 302 modules = [fence.selected(name) for name in names] 303 return modules, fence 304 305 306 def callable_identity(value): 307 if isinstance(value, property): 308 return ( 309 value, 310 tuple( 311 callable_identity(method) 312 for method in (value.fget, value.fset, value.fdel) 313 ), 314 None, 315 ) 316 if isinstance(value, (staticmethod, classmethod)): 317 value = value.__func__ 318 return value, getattr(value, "__code__", None), getattr(value, "__defaults__", None) 319 320 321 def implementation_identity(module): 322 values = {} 323 for name, value in vars(module).items(): 324 if isinstance(value, types.FunctionType): 325 values[name] = callable_identity(value) 326 elif isinstance(value, type): 327 values[name] = ( 328 value, 329 {key: callable_identity(method) for key, method in vars(value).items()}, 330 ) 331 elif name.isupper(): 332 values[name] = value, dict(getattr(value, "__dict__", {})) 333 return values 334 335 336 def extension_child_origin(name, module): 337 """Only genuine spec-less children generated by the verified pyexpat parent.""" 338 return ( 339 name 340 in { 341 "pyexpat.errors", 342 "pyexpat.model", 343 "xml.parsers.expat.errors", 344 "xml.parsers.expat.model", 345 } 346 and module is getattr(sys.modules.get("pyexpat"), name.rsplit(".", 1)[1], None) 347 and getattr(module, "__spec__", None) is None 348 and getattr(module, "__file__", None) is None 349 ) 350 351 352 def standard_library_origins(): 353 """Check interpreter-owned stdlib dependencies before implementation capture.""" 354 directory = Path(sys._stdlib_dir) 355 for name, module in tuple(sys.modules.items()): 356 if name.split(".", 1)[0] in sys.stdlib_module_names: 357 source = getattr(getattr(module, "__spec__", None), "origin", None) 358 require( 359 source in {"built-in", "frozen"} 360 or (isinstance(source, str) and Path(source).is_relative_to(directory)) 361 or extension_child_origin(name, module), 362 "standard library module origin differs", 363 ) 364 365 366 def inventory_execution(tests, capture, authored): 367 """Retain private executable baselines before ordinary module/class fixtures.""" 368 check = require 369 before = {test: capture(test) for test in tests} 370 371 def verify(test): 372 check( 373 test in before and authored(test) and capture(test) == before[test], 374 "inventoried testcase executable changed", 375 ) 376 377 return verify 378 379 380 def runtime_guard(modules): 381 """Capture callable implementation identities before selected code imports.""" 382 snapshot, check = implementation_identity, require 383 before = [(module, snapshot(module)) for module in modules] 384 385 def verify(): 386 for module, expected in before: 387 check(sys.modules.get(module.__name__) is module, "producer module changed") 388 check( 389 snapshot(module) == expected, 390 "producer callback or writer implementation changed", 391 ) 392 393 return verify