Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

+182
View File
@@ -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()
+468
View File
@@ -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()