beffroi-tools/tests/test_pptx_videos.py

212 lines
11 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

from collections import defaultdict
import contextlib
import io
import json
from pathlib import Path
import subprocess
import tempfile
import unittest
from unittest.mock import patch
import zipfile
from tools import pptx_videos as videos
class VideoTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
def invoke(self, source, *args):
with patch('sys.argv', ['pptx_videos.py', str(source), *args]), \
contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
return videos.main()
def deck(self, name='sample.pptx', media=True):
path = self.root / name
with zipfile.ZipFile(path, 'w') as archive:
if media:
archive.writestr('ppt/media/clip.mp4', b'video fixture')
return path
def test_discovery_uses_presentation_order_and_relationships(self):
source = self.root / 'ordered.pptx'
with zipfile.ZipFile(source, 'w') as archive:
archive.writestr('ppt/presentation.xml', f'''
<p:presentation xmlns:p="{videos.P_NS}" xmlns:r="{videos.R_NS}">
<p:sldIdLst><p:sldId r:id="second"/><p:sldId r:id="first"/></p:sldIdLst>
</p:presentation>''')
archive.writestr('ppt/_rels/presentation.xml.rels', f'''
<Relationships xmlns="{videos.REL_NS}">
<Relationship Id="first" Target="slides/slide1.xml"/>
<Relationship Id="second" Target="slides/slide2.xml"/>
</Relationships>''')
for number in (1, 2):
archive.writestr(f'ppt/slides/slide{number}.xml', f'''
<p:sld xmlns:p="{videos.P_NS}" xmlns:r="{videos.R_NS}">
<videoFile r:link="video"/><videoFile r:link="remote"/>
</p:sld>''')
archive.writestr(f'ppt/slides/_rels/slide{number}.xml.rels', f'''
<Relationships xmlns="{videos.REL_NS}">
<Relationship Id="video" Target="../media/clip{number}.mp4" Type="example/video"/>
<Relationship Id="remote" Target="https://example.invalid/video" TargetMode="External" Type="example/video"/>
</Relationships>''')
archive.writestr(f'ppt/media/clip{number}.mp4', b'video')
archive.writestr('ppt/media/audio.mp3', b'audio')
with zipfile.ZipFile(source) as archive:
parts, uses, external = videos.discover(archive)
self.assertEqual(parts, ['ppt/media/clip1.mp4', 'ppt/media/clip2.mp4'])
self.assertEqual(uses['ppt/media/clip2.mp4'], {1})
self.assertEqual(uses['ppt/media/clip1.mp4'], {2})
self.assertEqual(external, {1, 2})
def test_empty_deck_creates_no_output_and_requires_no_tools(self):
source = self.deck(media=False)
with patch.object(videos.shutil, 'which', side_effect=AssertionError('No tools needed')):
self.assertEqual(self.invoke(source, '--timings-only', '--report', 'pdf'), 0)
self.assertFalse((self.root / 'sample_videos').exists())
def test_timings_only_probes_temporary_copy_then_removes_it(self):
source = self.deck()
probed = []
def probe(path):
self.assertEqual(path.read_bytes(), b'video fixture')
probed.append(path)
return 1.25, '1920×1080', 'h264'
with patch.object(videos.shutil, 'which', return_value='/ffprobe'), patch.object(videos, 'probe', side_effect=probe):
self.assertEqual(self.invoke(source, '--timings-only', '--report', 'json,md'), 0)
output = self.root / 'sample_videos'
self.assertFalse((output / 'clip.mp4').exists())
self.assertEqual(len(probed), 1)
self.assertFalse(probed[0].exists())
data = json.loads((output / 'timings.json').read_text())
self.assertEqual(data['videos'][0]['duration_seconds'], 1.25)
self.assertIsNone(data['videos'][0]['extracted_file'])
self.assertNotIn('[clip.mp4]', (output / 'timings.md').read_text())
def test_extract_only_does_not_probe_or_write_reports(self):
source = self.deck()
with patch.object(videos, 'probe', side_effect=AssertionError('No probing')):
self.assertEqual(self.invoke(source, '--extract-only'), 0)
output = self.root / 'sample_videos'
self.assertEqual([p.name for p in output.iterdir()], ['clip.mp4'])
self.assertEqual((output / 'clip.mp4').read_bytes(), b'video fixture')
def test_default_reports_include_ontime_and_explicit_choice_overrides(self):
source = self.deck()
with patch.object(videos.shutil, 'which', return_value='/ffprobe'), \
patch.object(videos, 'probe', return_value=(1.25, '32×24', 'mpeg4')):
self.assertEqual(self.invoke(source, '--timings-only'), 0)
output = self.root / 'sample_videos'
self.assertEqual({p.name for p in output.iterdir()}, {'timings.md', 'timings.ontime.json'})
other = self.deck(name='explicit.pptx')
self.assertEqual(self.invoke(other, '--timings-only', '--report', 'json,ontime'), 0)
output = self.root / 'explicit_videos'
self.assertEqual({p.name for p in output.iterdir()}, {'timings.json', 'timings.ontime.json'})
other = self.deck(name='markdown.pptx')
self.assertEqual(self.invoke(other, '--timings-only', '--report', 'md'), 0)
self.assertEqual({p.name for p in (self.root / 'markdown_videos').iterdir()}, {'timings.md'})
def test_ontime_expands_shared_videos_in_slide_order(self):
project = json.loads(videos.render_report(self.report(), 'ontime'))
self.assertEqual(project['settings']['version'], '4.0.0')
rundown = project['rundowns']['default']
events = [rundown['entries'][event_id] for event_id in rundown['order']]
self.assertEqual([event['cue'] for event in events], ['Slide 2', 'Slide 10', 'Slide 12', 'Unreferenced'])
self.assertEqual([event['duration'] for event in events], [1000, 2500, 1000, 0])
self.assertEqual([event['timeStart'] for event in events], [0, 1000, 3500, 4500])
self.assertEqual([event['linkStart'] for event in events], [False, True, True, True])
self.assertEqual([event['skip'] for event in events], [False, False, False, True])
self.assertTrue(all(event['endAction'] == 'none' for event in events))
self.assertEqual(len(set(rundown['order'])), 4)
self.assertEqual(project, json.loads(videos.render_report(self.report(), 'ontime')))
def test_ontime_skips_unknown_duration_and_preserves_milliseconds(self):
data = self.report()
data['videos'][0]['duration_seconds'] = None
data['videos'][1]['duration_seconds'] = 2.345
events = list(json.loads(videos.render_report(data, 'ontime'))['rundowns']['default']['entries'].values())
self.assertTrue(events[0]['skip'])
self.assertIn('Duration unknown', events[0]['note'])
self.assertEqual(events[1]['duration'], 2345)
self.assertEqual(events[1]['timeStart'], 0)
self.assertFalse(events[1]['linkStart'])
def test_ontime_rejects_invalid_durations_without_invalid_json(self):
for seconds in (float('nan'), float('inf'), -1, 86400):
with self.subTest(seconds=seconds):
data = self.report()
data['videos'][0]['duration_seconds'] = seconds
project = json.loads(videos.render_report(data, 'ontime'))
event = next(iter(project['rundowns']['default']['entries'].values()))
self.assertEqual(event['duration'], 0)
self.assertTrue(event['skip'])
def report(self):
rows = [
('a', 'clip.mp4', 1024, 2.5, '1920×1080', 'h264'),
('b', 'A <clip> #1.mp4', 512, 1.0, '32×24', 'mpeg4'),
('c', 'unused.mp4', 128, None, 'Unknown', 'Unknown'),
]
return videos.report_data(Path('Review & plans.pptx'), rows,
defaultdict(set, a={10}, b={2, 12}), {5}, self.root)
def test_reports_sort_numerically_and_preserve_unknown_duration(self):
data = self.report()
self.assertEqual([v['slides'] for v in data['videos']], [[2, 12], [10], []])
self.assertEqual(data['total_duration_seconds'], 3.5)
self.assertEqual(data['known_durations'], 2)
decoded = json.loads(videos.render_report(data, 'json'))
self.assertIsNone(decoded['videos'][-1]['duration_seconds'])
self.assertEqual(decoded['external_media_slides'], [5])
def test_text_tables_align_and_put_duration_second(self):
for format in ('md', 'txt'):
with self.subTest(format=format):
lines = [line for line in videos.render_report(self.report(), format).splitlines() if line.startswith('|')]
self.assertEqual(lines[0].split('|')[2].strip(), 'Duration')
columns = {tuple(i for i, char in enumerate(line) if char == '|') for line in lines}
self.assertEqual(len(columns), 1)
self.assertIn('Unreferenced', lines[-1])
def test_visual_reports_escape_document_data(self):
data = self.report()
rendered = videos.render_report(data, 'html')
self.assertIn('Review &amp; plans.pptx', rendered)
self.assertIn('A &lt;clip&gt; #1.mp4', rendered)
self.assertNotIn('<clip>', rendered)
data['presentation'] = 'Quotes " and #panic("oops").pptx'
rendered = videos.render_report(data, 'typst')
self.assertIn(videos.typst_string(data['presentation']), rendered)
self.assertEqual(videos.typst_string('a\\b"\n'), '"a\\\\b\\"\\u{a}"')
def test_pdf_generation_keeps_source_and_invokes_typst(self):
def compile_pdf(command, **kwargs):
self.assertEqual(command[:2], ['typst', 'compile'])
self.assertTrue(Path(command[2]).is_file())
Path(command[3]).write_bytes(b'%PDF-test')
with patch.object(videos.subprocess, 'run', side_effect=compile_pdf) as run, contextlib.redirect_stdout(io.StringIO()):
videos.write_reports(self.report(), ['pdf'], self.root)
run.assert_called_once()
self.assertTrue((self.root / 'timings.typ').is_file())
self.assertEqual((self.root / 'timings.pdf').read_bytes(), b'%PDF-test')
def test_failed_probe_returns_unknown_metadata(self):
failure = subprocess.CalledProcessError(1, ['ffprobe'])
with patch.object(videos.subprocess, 'run', side_effect=failure):
self.assertEqual(videos.probe(self.root / 'bad.mp4'), (None, 'Unknown', 'Unknown'))
def test_invalid_archive_fails_without_output(self):
source = self.root / 'bad.pptx'
source.write_bytes(b'not a zip')
self.assertEqual(self.invoke(source, '--timings-only'), 1)
self.assertFalse((self.root / 'bad_videos').exists())
if __name__ == '__main__':
unittest.main()