field_ios

In-the-field app for Radroots on iOS
git clone https://radroots.dev/git/field_ios.git
Log | Files | Refs | README | LICENSE

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