252 lines
13 KiB
Python
252 lines
13 KiB
Python
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_all_reports_generate_every_format_once(self):
|
||
source = self.deck()
|
||
|
||
def compile_pdf(command, **kwargs):
|
||
self.assertEqual(command[:2], ['typst', 'compile'])
|
||
Path(command[-1]).write_bytes(b'%PDF-test')
|
||
|
||
with patch.object(videos.shutil, 'which', return_value='/tool'), \
|
||
patch.object(videos, 'probe', return_value=(1.25, '32×24', 'mpeg4')), \
|
||
patch.object(videos.subprocess, 'run', side_effect=compile_pdf) as compiler:
|
||
self.assertEqual(self.invoke(source, '--timings-only', '--report', ' ALL,md', '--report', 'pdf'), 0)
|
||
self.assertEqual(compiler.call_count, 2)
|
||
self.assertEqual(
|
||
{p.name for p in (self.root / 'sample_videos').iterdir()},
|
||
{'timings.html', 'timings.typ', 'timings.pdf', 'timings.md',
|
||
'timings.txt', 'timings.json', 'timings.ontime.json',
|
||
'timings-dense.typ', 'timings-dense.pdf'},
|
||
)
|
||
|
||
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 & plans.pptx', rendered)
|
||
self.assertIn('A <clip> #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_dense_pdf_has_portrait_media_table_and_discreet_title(self):
|
||
source = videos.render_report(self.report(), 'pdf-dense')
|
||
self.assertNotIn('flipped: true', source)
|
||
self.assertIn('columns: (30mm, 1fr, auto)', source)
|
||
self.assertIn('table.header(strong("Slide(s)"), strong("Media"), strong("Duration"))', source)
|
||
self.assertIn('"2, 12", "A <clip> #1.mp4", pill("00:00:01.000"', source)
|
||
self.assertIn('"Unreferenced", "unused.mp4", pill("Unknown"', source)
|
||
self.assertIn('#par(text(size: 10pt, fill: rgb("#626b80"), "Video timings — Review & plans.pptx"))', source)
|
||
for unwanted in ('metric(', 'Embedded videos', 'Total duration', 'Resolution', 'Codec'):
|
||
self.assertNotIn(unwanted, source)
|
||
self.assertIn('text(size: 7pt', source)
|
||
self.assertIn('trimming', source)
|
||
|
||
def test_dense_pdf_compiles_its_own_source(self):
|
||
with patch.object(videos.subprocess, 'run') as compiler, contextlib.redirect_stdout(io.StringIO()):
|
||
videos.write_reports(self.report(), ['pdf-dense'], self.root)
|
||
command = compiler.call_args.args[0]
|
||
self.assertEqual(command, ['typst', 'compile', str(self.root / 'timings-dense.typ'),
|
||
str(self.root / 'timings-dense.pdf')])
|
||
self.assertFalse((self.root / 'timings.typ').exists())
|
||
|
||
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()
|