Skip to content

armgit / peach

Public Imported from GitHub
0

Peach: Local-first video metadata scraper and media manager.

7.6 KB
Raw Blame
"""untrunc 固定源码与发行清单的完整性。"""
import importlib.util
import json
import os
from pathlib import Path
import sys
import subprocess
import tempfile
import unittest
from unittest.mock import patch
import zipfile


ROOT = Path(__file__).resolve().parents[1]
with patch.object(sys, 'path', [str(ROOT / 'scripts'), *sys.path]):
    spec = importlib.util.spec_from_file_location('fetch_untrunc_sources', ROOT / 'scripts/fetch_untrunc_sources.py')
    build = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(build)


class UntruncSourceBuildTests(unittest.TestCase):
    def test_sources_pin_the_compatible_ffmpeg_branch_and_untrunc_revision(self):
        lock = build.load_sources()
        sources = {source['name']: source for source in lock['sources']}
        self.assertEqual(lock['license'], 'GPL-2.0-or-later')
        self.assertEqual(sources['ffmpeg']['revision'], 'n8.1.3')
        self.assertEqual(len(sources['untrunc']['revision']), 40)
        self.assertEqual(lock['version'], sources['untrunc']['revision'][:7])

    def test_source_lock_rejects_missing_dependencies_and_unsafe_archives(self):
        lock = build.load_sources()
        with tempfile.TemporaryDirectory() as directory:
            path = Path(directory).resolve() / 'sources.json'
            lock['sources'][0]['archive'] = '../untrunc.tar.gz'
            path.write_text(json.dumps(lock), encoding='utf-8')
            with self.assertRaises(ValueError):
                build.load_sources(path)
            lock['sources'] = lock['sources'][1:]
            path.write_text(json.dumps(lock), encoding='utf-8')
            with self.assertRaises(ValueError):
                build.load_sources(path)

    def fixture(self, output):
        for name, payload in {
            'untrunc/untrunc.exe': b'MZ-untrunc-fixture',
            'work/untrunc/COPYING': b'untrunc-license',
            'work/ffmpeg/COPYING.LGPLv2.1': b'ffmpeg-license',
            'buildconf.txt': b'--disable-autodetect --disable-network',
            'build-environment.txt': b'cross compiler version',
            'sources/untrunc.tar.gz': b'untrunc-source-fixture',
            'sources/ffmpeg.tar.xz': b'ffmpeg-source-fixture',
        }.items():
            path = output / name
            path.parent.mkdir(parents=True, exist_ok=True)
            path.write_bytes(payload)
        lock = {
            'version': 'abcdef0', 'license': 'GPL-2.0-or-later',
            'sources': [{'name': name, 'revision': revision, 'archive': archive,
                         'url': f'https://example.test/{archive}',
                         'sha256': build.digest(output / 'sources' / archive)}
                        for name, revision, archive in [('untrunc', 'abcdef0', 'untrunc.tar.gz'),
                                                         ('ffmpeg', 'n8.1.3', 'ffmpeg.tar.xz')]],
        }
        return lock

    def test_manifest_hashes_all_distributed_files_and_corresponding_sources(self):
        with tempfile.TemporaryDirectory() as directory:
            output = Path(directory).resolve()
            lock = self.fixture(output)
            manifest = build.finish(output, lock)
            self.assertEqual(manifest['version'], lock['version'])
            bundle = output / 'untrunc'
            self.assertEqual(set(manifest['files']), {path.name for path in bundle.iterdir()} - {'manifest.json'})
            for name, digest in manifest['files'].items():
                self.assertEqual(build.digest(bundle / name), digest)
            source_archive = output / manifest['source_archive']['name']
            self.assertEqual(build.digest(source_archive), manifest['source_archive']['sha256'])
            with zipfile.ZipFile(source_archive) as archive:
                for source in lock['sources']:
                    self.assertEqual(archive.read('sources/' + source['archive']),
                                     (output / 'sources' / source['archive']).read_bytes())
                self.assertTrue({'scripts/build_untrunc_windows.sh', 'scripts/fetch_ffmpeg_sources.py',
                                 'scripts/fetch_untrunc_sources.py', 'scripts/untrunc-sources.json',
                                 'README.md', 'buildconf.txt', 'build-environment.txt'} <= set(archive.namelist()))

    def test_corrupt_source_archive_prevents_a_release_manifest(self):
        with tempfile.TemporaryDirectory() as directory:
            output = Path(directory).resolve()
            lock = self.fixture(output)
            (output / 'sources/untrunc.tar.gz').write_bytes(b'tampered')
            with self.assertRaises(ValueError):
                build.finish(output, lock)
            self.assertFalse((output / 'untrunc/manifest.json').exists())


@unittest.skipUnless(all(os.environ.get(name) for name in (
    'PEACH_TEST_UNTRUNC', 'PEACH_TEST_FFMPEG', 'PEACH_TEST_FFPROBE',
)), '构建验收需要显式提供三份原生工具')
class UntruncNativeRecoveryTests(unittest.TestCase):
    def test_native_distribution_has_matching_hashes_and_internal_ffmpeg_version(self):
        executable = Path(os.environ['PEACH_TEST_UNTRUNC']).resolve()
        bundle = executable.parent
        manifest = json.loads((bundle / 'manifest.json').read_text(encoding='utf-8'))
        self.assertEqual(manifest['license'], 'GPL-2.0-or-later')
        self.assertEqual(set(manifest['files']), {path.name for path in bundle.iterdir()} - {'manifest.json'})
        for name, digest in manifest['files'].items():
            self.assertEqual(build.digest(bundle / name), digest)
        archive = bundle.parent / manifest['source_archive']['name']
        self.assertEqual(build.digest(archive), manifest['source_archive']['sha256'])
        version = subprocess.run([str(executable), '-V'], check=True, capture_output=True,
                                 text=True, encoding='utf-8', timeout=15).stdout
        self.assertIn(manifest['version'], version)
        self.assertIn("ffmpeg '8.1.3'", version)

    def test_a_synthetic_truncated_mp4_is_recovered_and_decodes(self):
        from peach import mp4recover
        from peach.mp4repair import _top_level

        ffmpeg = Path(os.environ['PEACH_TEST_FFMPEG']).resolve()
        ffprobe = Path(os.environ['PEACH_TEST_FFPROBE']).resolve()
        untrunc = Path(os.environ['PEACH_TEST_UNTRUNC']).resolve()
        with tempfile.TemporaryDirectory() as directory:
            root = Path(directory).resolve()
            reference = root / 'reference.mp4'
            subprocess.run([
                str(ffmpeg), '-hide_banner', '-v', 'error', '-f', 'lavfi',
                '-i', 'testsrc2=size=128x96:rate=10', '-f', 'lavfi',
                '-i', 'sine=frequency=440:sample_rate=48000', '-t', '2',
                '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-c:a', 'aac', str(reference),
            ], check=True, capture_output=True, timeout=60)
            with reference.open('rb') as stream:
                boxes = list(_top_level(stream))
            self.assertEqual(boxes[-1][0], b'moov')
            broken = root / 'broken.mp4'
            broken.write_bytes(reference.read_bytes()[:boxes[-1][1]])
            self.assertTrue(mp4recover.missing_index(broken))
            size = broken.stat().st_size
            result = mp4recover.recover(broken, [reference], untrunc=untrunc,
                                        ffmpeg=ffmpeg, ffprobe=ffprobe, work=root / 'recovered')
            self.assertTrue(result.path.is_file())
            self.assertFalse(mp4recover.missing_index(result.path))
            self.assertAlmostEqual(result.duration, 2, delta=.2)
            self.assertGreater(result.coverage, .95)
            self.assertEqual(broken.stat().st_size, size)


if __name__ == '__main__':
    unittest.main()