Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,182 @@
|
||||
# SPDX-License-Identifier: GPL-3.0-or-later
|
||||
"""Authored regressions for explicit firmware preparation and bundle boundaries."""
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
|
||||
MODULE = Path(__file__).resolve().parents[1] / 'build.py'
|
||||
SPEC = importlib.util.spec_from_file_location('rom_build', MODULE)
|
||||
BUILD = importlib.util.module_from_spec(SPEC)
|
||||
SPEC.loader.exec_module(BUILD)
|
||||
|
||||
|
||||
def fingerprint(data):
|
||||
return hashlib.sha256(data).hexdigest()
|
||||
|
||||
|
||||
class ROMBuildTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temporary = tempfile.TemporaryDirectory(prefix='vcc-rom-builder-test-')
|
||||
self.addCleanup(self.temporary.cleanup)
|
||||
self.root = Path(self.temporary.name)
|
||||
self.records, self.locations = BUILD.DEPENDENCIES.load_records()
|
||||
self.record = json.loads(json.dumps(self.records['cocoroms']))
|
||||
|
||||
def fixture_outputs(self):
|
||||
directory = self.root / 'roms'
|
||||
directory.mkdir()
|
||||
expected = {}
|
||||
for name in BUILD.ROM_NAMES:
|
||||
data = bytes(32768 if name == 'coco3.rom' else 8192)
|
||||
(directory / name).write_bytes(data)
|
||||
expected[name] = {'bytes': len(data), 'sha256': fingerprint(data)}
|
||||
return directory, expected
|
||||
|
||||
def fixture_inputs(self):
|
||||
dependencies = self.root / 'dependencies'
|
||||
source = dependencies / 'cocoroms'
|
||||
source.mkdir(parents=True)
|
||||
hashes = {}
|
||||
for name in BUILD.SOURCE_NAMES:
|
||||
data = ('Authored source fixture: ' + name + '\n').encode()
|
||||
(source / name).write_bytes(data)
|
||||
hashes[name] = fingerprint(data)
|
||||
self.record['upstreamFileSHA256'] = self.record['vendoredFileSHA256'] = hashes
|
||||
_, self.record['romOutputs'] = self.fixture_outputs()
|
||||
return dependencies
|
||||
|
||||
def fixture_assembler(self, fail=False):
|
||||
tool = self.root / 'explicit-assembler-with-another-name'
|
||||
tool.write_text('''#!/usr/bin/env python3
|
||||
from pathlib import Path
|
||||
import sys
|
||||
if '--version' in sys.argv: print('Authored assembler fixture'); raise SystemExit(0)
|
||||
''' + ("raise SystemExit(7)\n" if fail else '''if '--raw' in sys.argv:
|
||||
name = sys.argv[sys.argv.index('-o') + 1]
|
||||
Path(name).write_bytes(bytes(32768 if name == 'coco3.rom' else 8192))
|
||||
else: print('fixture EQU 0')
|
||||
'''))
|
||||
tool.chmod(0o755)
|
||||
return tool
|
||||
|
||||
def test_firmware_fetch_is_explicit_and_manifest_contains_only_source(self):
|
||||
record = BUILD.source_record(self.records)
|
||||
self.assertEqual(set(record['upstreamFileSHA256']), BUILD.SOURCE_NAMES)
|
||||
self.assertNotIn('cocoroms', BUILD.DEPENDENCIES.default_selection(self.records))
|
||||
self.assertEqual(len(BUILD.DEPENDENCIES.default_selection(self.records)), 17)
|
||||
self.assertNotIn('.rom', ''.join(record['upstreamFileSHA256']))
|
||||
self.assertEqual(record['archiveRootPrefix'], 'cocoroms/')
|
||||
|
||||
def test_unreviewed_firmware_input_is_refused(self):
|
||||
self.record['vendoredFileSHA256']['supplied.rom'] = '0' * 64
|
||||
with self.assertRaisesRegex(ValueError, 'exactly the eight'):
|
||||
BUILD.source_record({'cocoroms': self.record})
|
||||
|
||||
def test_optional_flag_requires_a_boolean(self):
|
||||
self.record['optional'] = 'true'
|
||||
with self.assertRaisesRegex(ValueError, 'optional flag'):
|
||||
BUILD.DEPENDENCIES.validate_record(self.record)
|
||||
|
||||
def test_malformed_output_metadata_is_rejected_explicitly(self):
|
||||
for spec in [None, {'bytes': 32768, 'sha256': None}, {'bytes': 32768, 'sha256': 'not-a-hash'}]:
|
||||
record = json.loads(json.dumps(self.records['cocoroms']))
|
||||
record['romOutputs']['coco3.rom'] = spec
|
||||
with self.assertRaisesRegex(ValueError, 'firmware fingerprint'):
|
||||
BUILD.source_record({'cocoroms': record})
|
||||
record = json.loads(json.dumps(self.records['cocoroms']))
|
||||
record['romOutputs'] = None
|
||||
with self.assertRaisesRegex(ValueError, 'output inventory'):
|
||||
BUILD.source_record({'cocoroms': record})
|
||||
|
||||
def test_generated_hash_size_links_and_hardlinks_are_checked(self):
|
||||
source, expected = self.fixture_outputs()
|
||||
self.assertEqual(BUILD.validate_outputs(source, expected), expected)
|
||||
target = source / 'disk11.rom'
|
||||
target.write_bytes(b'changed')
|
||||
with self.assertRaisesRegex(ValueError, 'qualified fingerprint'):
|
||||
BUILD.validate_outputs(source, expected)
|
||||
target.unlink()
|
||||
target.symlink_to(source / 'bas13.rom')
|
||||
with self.assertRaisesRegex(ValueError, 'unlinked'):
|
||||
BUILD.validate_outputs(source, expected)
|
||||
target.unlink()
|
||||
os.link(source / 'bas13.rom', target)
|
||||
with self.assertRaisesRegex(ValueError, 'unlinked'):
|
||||
BUILD.validate_outputs(source, expected)
|
||||
|
||||
def test_bundle_has_exactly_two_roms_manifest_notice_and_no_private_paths(self):
|
||||
source, expected = self.fixture_outputs()
|
||||
manifest = BUILD.bundle_manifest(self.record, self.locations['cocoroms'] / 'cocoroms.json',
|
||||
{'version': 'fixture', 'sha256': 'a' * 64}, expected)
|
||||
destination = self.root / 'bundle'
|
||||
BUILD.write_bundle(destination, source, manifest)
|
||||
self.assertEqual({p.name for p in destination.iterdir()},
|
||||
{'ROMBuild.json', 'ROM_SOURCE_NOTICE.txt', 'coco3.rom', 'disk11.rom'})
|
||||
published = json.loads((destination / 'ROMBuild.json').read_text())
|
||||
self.assertEqual(published['schemaVersion'], 1)
|
||||
self.assertEqual(published['generator'], 'vccplus-rom-build')
|
||||
self.assertEqual(set(published['roms']), set(BUILD.BUNDLE_NAMES))
|
||||
self.assertNotIn(str(self.root), (destination / 'ROMBuild.json').read_text())
|
||||
self.assertIn('MICROWARE', (destination / 'ROM_SOURCE_NOTICE.txt').read_text())
|
||||
with self.assertRaisesRegex(ValueError, 'fresh ROM bundle'):
|
||||
BUILD.write_bundle(destination, source, manifest)
|
||||
|
||||
def test_cold_build_uses_exact_explicit_assembler_and_no_existing_roms(self):
|
||||
dependencies = self.fixture_inputs()
|
||||
records = dict(self.records, cocoroms=self.record)
|
||||
tool = self.fixture_assembler()
|
||||
output, bundle = self.root / 'output', self.root / 'bundle'
|
||||
with patch.object(BUILD.DEPENDENCIES, 'load_records', return_value=(records, self.locations)):
|
||||
report = BUILD.build(output, dependencies, tool, bundle)
|
||||
self.assertEqual(report['status'], 'passed')
|
||||
self.assertEqual(len(report['commands']), 6)
|
||||
self.assertTrue(all(command['argv'][0] == str(tool.resolve()) for command in report['commands']))
|
||||
self.assertFalse(report['preassembledROMInputs'])
|
||||
self.assertEqual(report['roms'], self.record['romOutputs'])
|
||||
self.assertTrue((bundle / 'coco3.rom').is_file())
|
||||
|
||||
def test_preassembled_dependency_payload_is_refused_before_execution(self):
|
||||
dependencies = self.fixture_inputs()
|
||||
(dependencies / 'cocoroms/preassembled.rom').write_bytes(b'fixture')
|
||||
records = dict(self.records, cocoroms=self.record)
|
||||
with patch.object(BUILD.DEPENDENCIES, 'load_records', return_value=(records, self.locations)), \
|
||||
patch.object(BUILD.subprocess, 'run') as execute:
|
||||
with self.assertRaisesRegex(ValueError, 'differs from reviewed import'):
|
||||
BUILD.build(self.root / 'output', dependencies, self.fixture_assembler())
|
||||
execute.assert_not_called()
|
||||
self.assertFalse((self.root / 'output').exists())
|
||||
|
||||
def test_failed_assembly_retains_evidence_without_creating_bundle(self):
|
||||
dependencies = self.fixture_inputs()
|
||||
records = dict(self.records, cocoroms=self.record)
|
||||
output, bundle = self.root / 'output', self.root / 'bundle'
|
||||
with patch.object(BUILD.DEPENDENCIES, 'load_records', return_value=(records, self.locations)):
|
||||
with self.assertRaises(BUILD.subprocess.CalledProcessError):
|
||||
BUILD.build(output, dependencies, self.fixture_assembler(fail=True), bundle)
|
||||
self.assertEqual(json.loads((output / 'BuildReport.json').read_text())['status'], 'failed')
|
||||
self.assertTrue((output / 'build.log').is_file())
|
||||
self.assertFalse(bundle.exists())
|
||||
|
||||
def test_bundle_cannot_contaminate_dependencies_or_occupy_build_ancestor(self):
|
||||
dependencies = self.fixture_inputs()
|
||||
records = dict(self.records, cocoroms=self.record)
|
||||
tool = self.fixture_assembler()
|
||||
for bundle in [dependencies / 'cocoroms/package', dependencies.resolve() / 'cocoroms/canonical-package', self.root / 'new-build-parent']:
|
||||
output = self.root / 'new-build-parent/output'
|
||||
with patch.object(BUILD.DEPENDENCIES, 'load_records', return_value=(records, self.locations)), \
|
||||
patch.object(BUILD.subprocess, 'run') as execute:
|
||||
with self.assertRaisesRegex(ValueError, 'separate from dependency'):
|
||||
BUILD.build(output, dependencies, tool, bundle)
|
||||
execute.assert_not_called()
|
||||
self.assertFalse(output.exists())
|
||||
self.assertFalse(bundle.exists())
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,468 @@
|
||||
# SPDX-License-Identifier: GPL-3.0-or-later
|
||||
"""Source-ROM staging checks using authored synthetic bytes, never real ROMs."""
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest import mock
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[3]
|
||||
SCRIPT = ROOT / 'tools/roms/stage.py'
|
||||
SPEC = importlib.util.spec_from_file_location('source_rom_stage', SCRIPT)
|
||||
stage = importlib.util.module_from_spec(SPEC)
|
||||
SPEC.loader.exec_module(stage)
|
||||
|
||||
|
||||
class SourceROMStageTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
temporary = tempfile.TemporaryDirectory(prefix='vcc-source-rom-stage-')
|
||||
self.addCleanup(temporary.cleanup)
|
||||
self.root = Path(temporary.name)
|
||||
self.srcroot = self.root / 'Source With Spaces/platforms/macos'
|
||||
self.starter = self.srcroot / 'Resources/StarterMedia'
|
||||
self.starter.mkdir(parents=True)
|
||||
self.media = {
|
||||
'Hello World.dsk': b'AUTHORED HELLO DISK',
|
||||
'Hello World.cas': b'AUTHORED HELLO CASSETTE',
|
||||
'Blank Disk.dsk': b'AUTHORED BLANK DISK',
|
||||
'Hello Hard Disk.dsk': b'AUTHORED HARD DISK',
|
||||
'Blank OS9 Header.bin': b'\x00' * 8192,
|
||||
}
|
||||
for name, data in self.media.items():
|
||||
(self.starter / name).write_bytes(data)
|
||||
self.resources = self.root / 'Build With Spaces/VCC Plus.app/Contents/Resources'
|
||||
self.bundle = self.root / 'Source ROM Bundle'
|
||||
self.create_bundle(self.bundle)
|
||||
|
||||
def create_bundle(self, path, seed=0x12):
|
||||
path.mkdir(parents=True, exist_ok=True)
|
||||
roms = {}
|
||||
for index, (name, size) in enumerate(stage.ROM_SIZES.items()):
|
||||
data = bytes([(seed + index) & 255]) * size
|
||||
(path / name).write_bytes(data)
|
||||
roms[name] = {'bytes': size, 'sha256': hashlib.sha256(data).hexdigest()}
|
||||
record = {'schemaVersion': 1, 'generator': 'vccplus-rom-build',
|
||||
'source': {'project': 'authored unit fixture', 'revision': '0' * 40},
|
||||
'assembler': {'version': 'authored fixture'}, 'roms': roms}
|
||||
(path / 'ROMBuild.json').write_text(json.dumps(record, indent=2) + '\n')
|
||||
(path / 'ROM_SOURCE_NOTICE.txt').write_text('Authored synthetic test bytes. No hardware ROM payload.\n')
|
||||
return record
|
||||
|
||||
def apply(self, source=None, environ=None):
|
||||
return stage.stage_source_roms(self.srcroot, self.resources, source,
|
||||
environ={} if environ is None else environ)
|
||||
|
||||
def tree(self, root):
|
||||
if not root.exists():
|
||||
return None
|
||||
return {str(path.relative_to(root)): (path.read_bytes(), path.stat().st_mode & 0o777,
|
||||
path.stat().st_mtime_ns)
|
||||
for path in root.rglob('*') if path.is_file()}
|
||||
|
||||
def alter_manifest(self, operation):
|
||||
path = self.bundle / 'ROMBuild.json'
|
||||
record = json.loads(path.read_text())
|
||||
operation(record)
|
||||
path.write_text(json.dumps(record))
|
||||
|
||||
def seed_old_kit(self):
|
||||
kit = self.resources / 'StarterKit'
|
||||
kit.mkdir(parents=True)
|
||||
(kit / 'stale-private-marker').write_bytes(b'OLDER BUILD ONLY')
|
||||
(self.resources / 'Blank OS9 Header.bin').write_bytes(self.media['Blank OS9 Header.bin'])
|
||||
return kit
|
||||
|
||||
def test_valid_bundle_copies_owned_bytes_and_preserves_all_inputs(self):
|
||||
bundle_before, starter_before = self.tree(self.bundle), self.tree(self.starter)
|
||||
result = self.apply(self.bundle)
|
||||
self.assertTrue(result['staged'])
|
||||
kit = self.resources / 'StarterKit'
|
||||
self.assertEqual(set(path.name for path in kit.iterdir()), stage.BUNDLE_FILES | set(stage.STARTER_FILES))
|
||||
for name in stage.BUNDLE_FILES:
|
||||
self.assertEqual((kit / name).read_bytes(), (self.bundle / name).read_bytes())
|
||||
self.assertNotEqual((kit / name).stat().st_ino, (self.bundle / name).stat().st_ino)
|
||||
for name, data in self.media.items():
|
||||
self.assertEqual((kit / name).read_bytes(), data)
|
||||
self.assertEqual((self.resources / 'Blank OS9 Header.bin').read_bytes(), self.media['Blank OS9 Header.bin'])
|
||||
self.assertEqual(self.tree(self.bundle), bundle_before)
|
||||
self.assertEqual(self.tree(self.starter), starter_before)
|
||||
self.assertEqual(result['roms']['coco3.rom']['bytes'], 32768)
|
||||
self.assertEqual(result['roms']['disk11.rom']['bytes'], 8192)
|
||||
|
||||
def test_missing_default_removes_only_owned_stale_kit(self):
|
||||
kit = self.seed_old_kit()
|
||||
untouched = self.resources / 'unrelated-resource.txt'
|
||||
untouched.write_bytes(b'PRESERVE')
|
||||
self.assertFalse(self.apply()['staged'])
|
||||
self.assertFalse(kit.exists())
|
||||
self.assertEqual(untouched.read_bytes(), b'PRESERVE')
|
||||
self.assertTrue((self.resources / 'Blank OS9 Header.bin').is_file())
|
||||
|
||||
def test_explicit_and_environment_selection_never_fall_back(self):
|
||||
default = self.srcroot / 'LocalResources/SourceROMBundle'
|
||||
self.create_bundle(default, seed=0x44)
|
||||
chosen = stage.selected_source(self.srcroot, self.bundle, {'VCC_SOURCE_ROM_DIR': str(default)})
|
||||
self.assertEqual(chosen, self.bundle)
|
||||
self.assertEqual(stage.selected_source(self.srcroot, environ={'VCC_SOURCE_ROM_DIR': str(self.bundle)}), self.bundle)
|
||||
self.assertEqual(stage.selected_source(self.srcroot, environ={'VCC_SOURCE_ROM_DIR': ''}), default)
|
||||
self.assertTrue(self.apply(environ={'VCC_SOURCE_ROM_DIR': str(self.bundle)})['staged'])
|
||||
self.assertEqual((self.resources / 'StarterKit/coco3.rom').read_bytes(), (self.bundle / 'coco3.rom').read_bytes())
|
||||
self.assertFalse(self.apply(self.root / 'Absent Explicit Bundle')['staged'])
|
||||
self.assertFalse((self.resources / 'StarterKit').exists())
|
||||
|
||||
def test_default_bundle_is_used_only_from_source_specific_directory(self):
|
||||
destination = self.srcroot / 'LocalResources/SourceROMBundle'
|
||||
shutil.copytree(self.bundle, destination)
|
||||
self.assertTrue(self.apply()['staged'])
|
||||
shutil.rmtree(destination)
|
||||
private = self.srcroot / 'LocalResources/ROMs'
|
||||
private.mkdir()
|
||||
(private / 'coco3.rom').write_bytes(b'PRIVATE PATH MUST NOT BE READ')
|
||||
media = self.srcroot / 'LocalResources/Media'
|
||||
media.mkdir()
|
||||
(media / 'NitrOS-9 L2 V3.3.0.vhd').write_bytes(b'NO PRIVATE MEDIA DISCOVERY')
|
||||
self.assertFalse(self.apply()['staged'])
|
||||
self.assertFalse((self.resources / 'StarterKit').exists())
|
||||
self.assertEqual((private / 'coco3.rom').read_bytes(), b'PRIVATE PATH MUST NOT BE READ')
|
||||
|
||||
def test_isolated_ui_product_never_selects_or_reads_prepared_rom_bundles(self):
|
||||
default = self.srcroot / 'LocalResources/SourceROMBundle'
|
||||
shutil.copytree(self.bundle, default)
|
||||
original, default_original = self.tree(self.bundle), self.tree(default)
|
||||
configurations = (
|
||||
{'CONFIGURATION': 'UITesting'},
|
||||
{'CONFIGURATION': 'Debug', 'SWIFT_ACTIVE_COMPILATION_CONDITIONS': 'DEBUG VCC_UI_TESTING'},
|
||||
{'CONFIGURATION': 'Release', 'GCC_PREPROCESSOR_DEFINITIONS': 'VCC_UI_TESTING=1'},
|
||||
)
|
||||
for environment in configurations:
|
||||
with self.subTest(environment=environment):
|
||||
self.seed_old_kit()
|
||||
environment['VCC_SOURCE_ROM_DIR'] = str(self.bundle)
|
||||
with mock.patch.object(stage, 'selected_source', side_effect=AssertionError('UI build selected a ROM input')):
|
||||
with mock.patch.object(stage, 'read_bundle', side_effect=AssertionError('UI build read a ROM input')):
|
||||
result = self.apply(self.bundle, environment)
|
||||
self.assertFalse(result['staged'])
|
||||
self.assertTrue(result['ui_testing'])
|
||||
self.assertFalse((self.resources / 'StarterKit').exists())
|
||||
self.assertEqual((self.resources / 'Blank OS9 Header.bin').read_bytes(), self.media['Blank OS9 Header.bin'])
|
||||
self.assertEqual(self.tree(self.bundle), original)
|
||||
self.assertEqual(self.tree(default), default_original)
|
||||
|
||||
def test_isolated_ui_product_does_not_probe_unsafe_explicit_or_environment_paths(self):
|
||||
alias = self.root / 'Unsafe ROM Alias'
|
||||
alias.symlink_to(self.bundle, target_is_directory=True)
|
||||
original = self.tree(self.bundle)
|
||||
self.seed_old_kit()
|
||||
# Parent traversal and linked input locations would both be refused for
|
||||
# an ordinary source app, but neither location is probed by a UI build.
|
||||
result = self.apply(alias / '..' / 'missing', {'CONFIGURATION': 'UITesting',
|
||||
'VCC_SOURCE_ROM_DIR': str(alias)})
|
||||
self.assertFalse(result['staged'])
|
||||
self.assertFalse((self.resources / 'StarterKit').exists())
|
||||
self.assertEqual(self.tree(self.bundle), original)
|
||||
self.assertEqual((self.resources / 'Blank OS9 Header.bin').read_bytes(), self.media['Blank OS9 Header.bin'])
|
||||
|
||||
def test_atomic_replacement_removes_all_previous_profile_payload(self):
|
||||
old = self.seed_old_kit()
|
||||
nested = old / 'old-nested'
|
||||
nested.mkdir()
|
||||
(nested / 'payload').write_bytes(b'OLD')
|
||||
self.assertTrue(self.apply(self.bundle)['staged'])
|
||||
self.assertFalse((old / 'stale-private-marker').exists())
|
||||
self.assertFalse(nested.exists())
|
||||
self.assertEqual(set(path.name for path in old.iterdir()), stage.BUNDLE_FILES | set(stage.STARTER_FILES))
|
||||
self.assertFalse(list(self.resources.glob('.source-rom-starter-*')))
|
||||
|
||||
def test_failed_atomic_exchange_preserves_previous_kit(self):
|
||||
old = self.seed_old_kit()
|
||||
before = self.tree(old)
|
||||
with mock.patch.object(stage, 'exchange_directories', side_effect=OSError('authored exchange refusal')):
|
||||
with self.assertRaises(OSError):
|
||||
self.apply(self.bundle)
|
||||
self.assertEqual(self.tree(old), before)
|
||||
self.assertFalse(list(self.resources.glob('.source-rom-starter-*')))
|
||||
|
||||
def test_next_build_removes_only_interrupted_owned_staging(self):
|
||||
self.resources.mkdir(parents=True)
|
||||
stale = self.resources / '.source-rom-starter-abcdefgh'
|
||||
stale.mkdir()
|
||||
(stale / 'prior-private-rom-marker').write_bytes(b'PRIOR PROFILE')
|
||||
(self.resources / '.source-rom-resource-12345678').write_bytes(b'PARTIAL HEADER')
|
||||
unrelated = self.resources / '.source-rom-starter-not-a-generated-name'
|
||||
unrelated.mkdir()
|
||||
(unrelated / 'preserve').write_bytes(b'KEEP')
|
||||
self.assertFalse(self.apply()['staged'])
|
||||
self.assertFalse(stale.exists())
|
||||
self.assertFalse((self.resources / '.source-rom-resource-12345678').exists())
|
||||
self.assertEqual((unrelated / 'preserve').read_bytes(), b'KEEP')
|
||||
# Even a helper-shaped name cannot redirect cleanup through a link.
|
||||
stale.symlink_to(unrelated, target_is_directory=True)
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply()
|
||||
self.assertEqual((unrelated / 'preserve').read_bytes(), b'KEEP')
|
||||
|
||||
def test_invalid_manifest_fields_refuse_before_changing_build_output(self):
|
||||
cases = (
|
||||
lambda r: r.update(schemaVersion=2),
|
||||
lambda r: r.update(schemaVersion=True),
|
||||
lambda r: r.update(generator='different-generator'),
|
||||
lambda r: r.update(source={}),
|
||||
lambda r: r.update(roms=[]),
|
||||
lambda r: r['roms'].pop('disk11.rom'),
|
||||
lambda r: r['roms'].update({'extra.rom': {'bytes': 1, 'sha256': '0' * 64}}),
|
||||
lambda r: r['roms']['coco3.rom'].update(bytes=32767),
|
||||
lambda r: r['roms']['coco3.rom'].update(bytes=True),
|
||||
lambda r: r['roms']['disk11.rom'].update(sha256='A' * 64),
|
||||
lambda r: r['roms']['disk11.rom'].update(sha256='0' * 64),
|
||||
)
|
||||
old = self.seed_old_kit()
|
||||
before = self.tree(self.resources)
|
||||
for operation in cases:
|
||||
with self.subTest(operation=operation):
|
||||
self.create_bundle(self.bundle)
|
||||
self.alter_manifest(operation)
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(self.bundle)
|
||||
self.assertEqual(self.tree(self.resources), before)
|
||||
self.assertTrue((old / 'stale-private-marker').is_file())
|
||||
|
||||
def test_invalid_json_duplicate_fields_and_nonobject_manifest_are_refused(self):
|
||||
for data in (b'{', b'[]', b'{"schemaVersion":1,"schemaVersion":1}', b'\xff', b' ' * (stage.MANIFEST_LIMIT + 1)):
|
||||
with self.subTest(data=data[:25]):
|
||||
(self.bundle / 'ROMBuild.json').write_bytes(data)
|
||||
with self.assertRaises((ValueError, UnicodeError)):
|
||||
self.apply(self.bundle)
|
||||
self.assertFalse(self.resources.exists())
|
||||
|
||||
def test_missing_extra_or_nonregular_bundle_members_are_refused(self):
|
||||
for name in stage.BUNDLE_FILES:
|
||||
with self.subTest(missing=name):
|
||||
self.create_bundle(self.bundle)
|
||||
(self.bundle / name).unlink()
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(self.bundle)
|
||||
self.create_bundle(self.bundle)
|
||||
(self.bundle / '.unexpected').write_bytes(b'NO EXTRA FILES')
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(self.bundle)
|
||||
(self.bundle / '.unexpected').unlink()
|
||||
(self.bundle / 'disk11.rom').unlink()
|
||||
(self.bundle / 'disk11.rom').mkdir()
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(self.bundle)
|
||||
self.assertFalse(self.resources.exists())
|
||||
|
||||
def test_rom_payload_sizes_and_manifest_identity_are_enforced(self):
|
||||
for name, size in stage.ROM_SIZES.items():
|
||||
for length in (0, size - 1, size + 1):
|
||||
with self.subTest(name=name, length=length):
|
||||
self.create_bundle(self.bundle)
|
||||
(self.bundle / name).write_bytes(bytes(length))
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(self.bundle)
|
||||
self.create_bundle(self.bundle)
|
||||
(self.bundle / name).write_bytes(bytes([0x77]) * size)
|
||||
with self.assertRaisesRegex(ValueError, 'do not match'):
|
||||
self.apply(self.bundle)
|
||||
self.assertFalse(self.resources.exists())
|
||||
|
||||
def test_notice_is_required_bounded_nonempty_utf8(self):
|
||||
for notice in (b'', b' \n\t', b'\xff', b'notice\0', b'x' * (stage.NOTICE_LIMIT + 1)):
|
||||
with self.subTest(notice=notice[:25]):
|
||||
(self.bundle / 'ROM_SOURCE_NOTICE.txt').write_bytes(notice)
|
||||
with self.assertRaises((ValueError, UnicodeError)):
|
||||
self.apply(self.bundle)
|
||||
self.assertFalse(self.resources.exists())
|
||||
|
||||
def test_source_bundle_leaf_and_ancestor_symlinks_are_refused(self):
|
||||
alias = self.root / 'Linked Bundle'
|
||||
alias.symlink_to(self.bundle, target_is_directory=True)
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(alias)
|
||||
parent = self.root / 'Linked Parent'
|
||||
parent.symlink_to(self.root, target_is_directory=True)
|
||||
with self.assertRaisesRegex(ValueError, 'linked ancestor'):
|
||||
self.apply(parent / self.bundle.name)
|
||||
dangling = self.root / 'Dangling Bundle'
|
||||
dangling.symlink_to(self.root / 'missing')
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(dangling)
|
||||
self.assertFalse(self.resources.exists())
|
||||
|
||||
def test_source_members_must_not_be_symbolic_or_hard_links(self):
|
||||
for name in stage.BUNDLE_FILES:
|
||||
for kind in ('symbolic', 'hard'):
|
||||
with self.subTest(name=name, kind=kind):
|
||||
self.create_bundle(self.bundle)
|
||||
original = self.bundle / name
|
||||
victim = self.root / 'Input Victim'
|
||||
victim.write_bytes(original.read_bytes())
|
||||
before = victim.read_bytes()
|
||||
original.unlink()
|
||||
if kind == 'symbolic':
|
||||
original.symlink_to(victim)
|
||||
else:
|
||||
os.link(victim, original)
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(self.bundle)
|
||||
self.assertEqual(victim.read_bytes(), before)
|
||||
original.unlink()
|
||||
victim.unlink()
|
||||
self.assertFalse(self.resources.exists())
|
||||
|
||||
def test_output_shape_and_linked_ancestors_cannot_redirect_writes(self):
|
||||
with self.assertRaisesRegex(ValueError, 'APP.app'):
|
||||
stage.stage_source_roms(self.srcroot, self.root / 'Not An App/Resources', self.bundle, {})
|
||||
victim = self.root / 'Untouched Output Victim'
|
||||
victim.mkdir()
|
||||
build = self.root / 'Linked Build'
|
||||
build.symlink_to(victim, target_is_directory=True)
|
||||
with self.assertRaisesRegex(ValueError, 'linked ancestor'):
|
||||
stage.stage_source_roms(self.srcroot, build / 'VCC.app/Contents/Resources', self.bundle, {})
|
||||
self.assertEqual(list(victim.iterdir()), [])
|
||||
|
||||
def test_existing_kit_links_refuse_cleanup_or_replacement(self):
|
||||
kit = self.seed_old_kit()
|
||||
victim = self.root / 'Kit Victim'
|
||||
victim.write_bytes(b'UNCHANGED')
|
||||
for kind in ('symbolic', 'hard', 'directory'):
|
||||
with self.subTest(kind=kind):
|
||||
link = kit / 'unsafe-member'
|
||||
if kind == 'symbolic':
|
||||
link.symlink_to(victim)
|
||||
elif kind == 'hard':
|
||||
os.link(victim, link)
|
||||
else:
|
||||
link.symlink_to(self.root, target_is_directory=True)
|
||||
for source in (None, self.bundle):
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(source)
|
||||
self.assertEqual(victim.read_bytes(), b'UNCHANGED')
|
||||
self.assertTrue((kit / 'stale-private-marker').is_file())
|
||||
link.unlink()
|
||||
shutil.rmtree(kit)
|
||||
kit.symlink_to(self.bundle, target_is_directory=True)
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply()
|
||||
self.assertEqual(set(path.name for path in self.bundle.iterdir()), stage.BUNDLE_FILES)
|
||||
|
||||
def test_linked_standalone_header_is_never_replaced(self):
|
||||
self.resources.mkdir(parents=True)
|
||||
victim = self.root / 'Header Victim'
|
||||
victim.write_bytes(b'UNCHANGED')
|
||||
for kind in ('symbolic', 'hard'):
|
||||
with self.subTest(kind=kind):
|
||||
destination = self.resources / 'Blank OS9 Header.bin'
|
||||
if kind == 'symbolic':
|
||||
destination.symlink_to(victim)
|
||||
else:
|
||||
os.link(victim, destination)
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(self.bundle)
|
||||
self.assertEqual(victim.read_bytes(), b'UNCHANGED')
|
||||
self.assertFalse((self.resources / 'StarterKit').exists())
|
||||
destination.unlink()
|
||||
|
||||
def test_authored_input_links_and_bad_header_refuse_before_mutation(self):
|
||||
header = self.starter / 'Blank OS9 Header.bin'
|
||||
header.write_bytes(b'SHORT')
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(self.bundle)
|
||||
header.write_bytes(self.media[header.name])
|
||||
target = self.starter / 'Hello World.cas'
|
||||
victim = self.root / 'Authored Input Victim'
|
||||
victim.write_bytes(target.read_bytes())
|
||||
target.unlink()
|
||||
target.symlink_to(victim)
|
||||
with self.assertRaises(ValueError):
|
||||
self.apply(self.bundle)
|
||||
self.assertFalse(self.resources.exists())
|
||||
|
||||
def test_inputs_and_build_output_must_not_overlap(self):
|
||||
self.resources.mkdir(parents=True)
|
||||
embedded = self.resources / 'StarterKit'
|
||||
shutil.copytree(self.bundle, embedded)
|
||||
before = self.tree(embedded)
|
||||
with self.assertRaisesRegex(ValueError, 'overlap'):
|
||||
self.apply(embedded)
|
||||
self.assertEqual(self.tree(embedded), before)
|
||||
with self.assertRaisesRegex(ValueError, 'parent traversal'):
|
||||
self.apply(self.bundle / '..' / self.bundle.name)
|
||||
|
||||
def run_build_phase(self, *, profile, configuration='Release', source=None):
|
||||
helper = self.srcroot.parents[1] / 'tools/roms/stage.py'
|
||||
helper.parent.mkdir(parents=True, exist_ok=True)
|
||||
shutil.copyfile(SCRIPT, helper)
|
||||
environment = os.environ.copy()
|
||||
environment.update(SRCROOT=str(self.srcroot), TARGET_BUILD_DIR=str(self.resources.parents[2]),
|
||||
UNLOCALIZED_RESOURCES_FOLDER_PATH='VCC Plus.app/Contents/Resources',
|
||||
VCC_BUILD_CONTENT_PROFILE=profile, CONFIGURATION=configuration)
|
||||
environment.pop('VCC_SOURCE_ROM_DIR', None)
|
||||
if source is not None:
|
||||
environment['VCC_SOURCE_ROM_DIR'] = str(source)
|
||||
return subprocess.run(['/bin/sh', str(ROOT / 'platforms/macos/Packaging/copy-development-starter.sh')],
|
||||
env=environment, capture_output=True, text=True)
|
||||
|
||||
def test_source_build_phase_accepts_bundle_in_debug_and_release_without_private_discovery(self):
|
||||
private = self.srcroot / 'LocalResources/ROMs'
|
||||
private.mkdir(parents=True)
|
||||
(private / 'coco3.rom').write_bytes(b'INVALID NORMAL PROFILE INPUT')
|
||||
for configuration in ('Debug', 'Release'):
|
||||
with self.subTest(configuration=configuration):
|
||||
result = self.run_build_phase(profile='source', configuration=configuration, source=self.bundle)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual((self.resources / 'StarterKit/coco3.rom').read_bytes(), (self.bundle / 'coco3.rom').read_bytes())
|
||||
self.assertEqual((private / 'coco3.rom').read_bytes(), b'INVALID NORMAL PROFILE INPUT')
|
||||
|
||||
def test_source_ui_testing_build_phase_omits_prepared_bundle_and_stale_kit(self):
|
||||
default = self.srcroot / 'LocalResources/SourceROMBundle'
|
||||
shutil.copytree(self.bundle, default)
|
||||
original, default_original = self.tree(self.bundle), self.tree(default)
|
||||
self.seed_old_kit()
|
||||
result = self.run_build_phase(profile='source', configuration='UITesting', source=self.bundle)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertIn('Isolated UI-test build', result.stdout)
|
||||
self.assertFalse((self.resources / 'StarterKit').exists())
|
||||
self.assertEqual((self.resources / 'Blank OS9 Header.bin').read_bytes(), self.media['Blank OS9 Header.bin'])
|
||||
self.assertEqual(self.tree(self.bundle), original)
|
||||
self.assertEqual(self.tree(default), default_original)
|
||||
|
||||
def test_source_build_phase_rejects_malformed_present_bundle(self):
|
||||
(self.bundle / 'coco3.rom').write_bytes(b'INVALID')
|
||||
result = self.run_build_phase(profile='source', source=self.bundle)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn('invalid size', result.stderr)
|
||||
self.assertFalse((self.resources / 'StarterKit').exists())
|
||||
|
||||
def test_normal_debug_phase_preserves_existing_private_workflow(self):
|
||||
private = self.srcroot / 'LocalResources/ROMs'
|
||||
private.mkdir(parents=True)
|
||||
expected = {'coco3.rom': bytes([0x33]) * 32768, 'disk11.rom': bytes([0x44]) * 8192,
|
||||
'orch90.rom': bytes([0x55]) * 8192}
|
||||
for name, data in expected.items():
|
||||
(private / name).write_bytes(data)
|
||||
result = self.run_build_phase(profile='normal', configuration='Debug', source=self.bundle)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
kit = self.resources / 'StarterKit'
|
||||
for name, data in expected.items():
|
||||
self.assertEqual((kit / name).read_bytes(), data)
|
||||
self.assertFalse((kit / 'ROMBuild.json').exists())
|
||||
for name, data in self.media.items():
|
||||
self.assertEqual((kit / name).read_bytes(), data)
|
||||
|
||||
def test_normal_release_phase_still_excludes_optional_development_roms(self):
|
||||
self.seed_old_kit()
|
||||
result = self.run_build_phase(profile='normal', configuration='Release', source=self.bundle)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertFalse((self.resources / 'StarterKit').exists())
|
||||
self.assertEqual((self.resources / 'Blank OS9 Header.bin').read_bytes(), self.media['Blank OS9 Header.bin'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user