v31.1-roots.1 · Commit 11: [PATCH 11/17] fix(test): bound policy oracles and retain CI diagnostics

ci/test/test_roots_regressions.py

Before: ci/test/test_roots_regressions.py · After: ci/test/test_roots_regressions.py

File metadata

index 0c65dd7a2a5e2335be1dc1dee906f6ecd548fa19..722a2775c7986aaf2edac7ec2bccf86c1e2b54cc 100644

Download original patch · Release notes

Diff rows 1–100 of 100. Line numbers refer to the original before/after files.

+ Added− RemovedUnmarked lines are context.

Scroll the code area horizontally to read long lines. The two line-number columns refer to before and after.

ci/test/test_roots_regressions.py CHANGED Viewed

@@ -2,12 +2,17 @@
 # Copyright (c) 2026-present The Bitcoin Roots developers
 # Distributed under the MIT software license, see the accompanying file COPYING.
 """Exercise actual affected selections, execution budgets and failure artifacts."""
+import contextlib
 import importlib.util
+import io
 import json
+import os
 from pathlib import Path
 import sys
 import tempfile
+from types import SimpleNamespace
 import unittest
+from unittest.mock import patch
 ROOT = Path(__file__).resolve().parents[2]
 SPEC = importlib.util.spec_from_file_location('roots_regressions', ROOT / 'ci/test/roots-regressions.py')
@@ -60,7 +65,9 @@ class RootsRegressionTest(unittest.TestCase):
             for cadence, expected in [('fast', 5), ('nightly', 60)]:
                 artifacts = build / cadence
                 plan = MODULE.selection(['src/wallet/wallet.cpp'], cadence)
-                self.assertEqual(MODULE.execute(plan, 'fuzz', build, artifacts, []), 1)
+                summary = io.StringIO()
+                with contextlib.redirect_stderr(summary):
+                    self.assertEqual(MODULE.execute(plan, 'fuzz', build, artifacts, []), 1)
                 results = json.loads((artifacts / 'fuzz-results.json').read_text())['results']
                 self.assertEqual(len(results), 2)
                 for record in results:
@@ -69,6 +76,8 @@ class RootsRegressionTest(unittest.TestCase):
                     self.assertIn('-max_total_time=' + str(expected), record['command'])
                     self.assertNotIn('-runs=', ' '.join(record['command']))
                     self.assertIn(record['target'], (artifacts / (record['target'] + '.log')).read_text())
+                    self.assertEqual(record['log'], record['target'] + '.log')
+                    self.assertIn(record['target'] + ' failed (exit 3)', summary.getvalue())
     def test_real_timeout_is_failure_with_retained_log(self):
         with tempfile.TemporaryDirectory() as directory:
@@ -79,6 +88,65 @@ class RootsRegressionTest(unittest.TestCase):
             self.assertEqual(MODULE.run_bounded([str(Path(directory) / 'absent')], 1, log), 127)
             self.assertTrue(log.stat().st_size)
+    def test_failure_summary_is_bounded_and_full_output_is_retained(self):
+        with tempfile.TemporaryDirectory() as directory:
+            build = Path(directory)
+            runner = build / 'test/functional/test_runner.py'
+            runner.parent.mkdir(parents=True)
+            runner.write_text('import sys\nprint("x" * 20000, flush=True)\nprint("specific failure", file=sys.stderr)\nsys.exit(4)\n')
+            artifacts = build / 'host-artifacts'
+            summary = io.StringIO()
+            with contextlib.redirect_stderr(summary):
+                result = MODULE.execute(MODULE.selection(['src/wallet/spend.cpp'], 'fast'), 'functional', build, artifacts, [])
+            self.assertEqual(result, 1)
+            record = json.loads((artifacts / 'functional-results.json').read_text())['results'][0]
+            self.assertEqual(record['log'], 'functional.log')
+            self.assertEqual(record['exit'], 4)
+            self.assertGreater((artifacts / record['log']).stat().st_size, 20000)
+            self.assertIn('specific failure', summary.getvalue())
+            self.assertIn('exit 4', summary.getvalue())
+            self.assertLess(len(summary.getvalue()), 3500)
+    def test_container_binds_artifacts_and_forwards_explicit_path(self):
+        spec = importlib.util.spec_from_file_location('container', ROOT / 'ci/test/02_run_container.py')
+        container = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(container)
+        with tempfile.TemporaryDirectory() as directory:
+            work = Path(directory)
+            artifacts = work / 'host-artifacts'
+            env = {'USER': work.name, 'CONTAINER_NAME': 'diagnostic-fixture',
+                   'PATH': os.environ.get('PATH', '/usr/bin'), 'ROOTS_ARTIFACTS_DIR': str(artifacts),
+                   'BASE_READ_ONLY_DIR': str(ROOT), 'BASE_ROOT_DIR': str(work / 'guest'),
+                   'CCACHE_DIR': str(work / 'ccache'), 'DEPENDS_DIR': str(work / 'depends'),
+                   'PREVIOUS_RELEASES_DIR': str(work / 'previous'), 'CI_IMAGE_NAME_TAG': 'fixture',
+                   'CI_IMAGE_PLATFORM': 'linux', 'FILE_ENV': 'fixture'}
+            env_file = Path(f"/tmp/env-{env['USER']}-{env['CONTAINER_NAME']}")
+            self.addCleanup(env_file.unlink, missing_ok=True)
+            calls = []
+            def run(command, **kwargs):
+                calls.append(command)
+                if command[:2] == ['bash', '-c']:
+                    return SimpleNamespace(stdout='export ROOTS_ARTIFACTS_DIR=\n')
+                if command[:2] == ['docker', 'run']:
+                    self.assertTrue(artifacts.is_dir())
+                    self.assertIn(f'--mount=type=bind,src={artifacts},dst={artifacts}', command)
+                    self.assertIn(f'ROOTS_ARTIFACTS_DIR={artifacts}', env_file.read_text())
+                    return SimpleNamespace(stdout='fixture-container\n')
+                if command[:2] == ['docker', 'exec'] and command[-1].endswith('/03_test_script.sh'):
+                    # Emulate writes through the declared bind mount. No actual
+                    # Docker build, dependency install or fuzz target executes.
+                    log = artifacts / 'functional.log'
+                    result = MODULE.run_bounded([sys.executable, '-c', 'import sys; print("host-visible failure"); sys.exit(3)'], 5, log)
+                    (artifacts / 'functional-results.json').write_text(json.dumps({'exit': result, 'log': log.name}))
+                return SimpleNamespace(stdout='', returncode=0)
+            with patch.dict(os.environ, env, clear=True), patch.object(container, 'run', side_effect=run):
+                container.main()
+            self.assertIn('host-visible failure', (artifacts / 'functional.log').read_text())
+            self.assertEqual(json.loads((artifacts / 'functional-results.json').read_text())['exit'], 3)
+            self.assertTrue(any(command[:2] == ['docker', 'run'] for command in calls))
 if __name__ == '__main__':
     unittest.main()