rt/wrolpi
1
0
Fork 0
mirror of https://github.com/lrnselfreliance/wrolpi.git synced 2026-10-26 19:01:39 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
wrolpi/modules/videos/test/test_common.py
Roland 06ac0d2055 review: ffprobe out of the write transaction, and three tests that were watching nothing 
All three bugs confirmed; the two suggestions taken.

[bug] `video_modeler` awaited ffprobe -- a subprocess per video, up to 20
per batch -- inside its `commit=True` session.  With IMMEDIATE as the
default that holds the write lock for the whole batch, which is the same
starvation this branch is curing in `video_cleanup`.  (It was already
partly true before: the batch's first `session.flush([video])` took the
lock ahead of the remaining ffprobes.)  The batch is now read, ffprobed
with no transaction open, then written.  `get_or_create_ffprobe_json` in
modules/videos/common.py is the path-only entry point that makes that
possible; `Video.get_ffprobe_json` delegates to it and keeps appending
the cache file to its FileGroup.  `validate()` -- and the poster
generation it can trigger -- is still inside the write transaction, and
now says so.

[bug] `test_download_dispatched_outside_immediate_transaction` probed
`getattr(_immediate_txn, 'active', False)`, which a ContextVar never has,
so it passed unconditionally.  It now probes the actual write lock from a
competing connection under `production_like_sessions`.  Mutation-checked:
moving the dispatch back inside the claim transaction fails it.

[bug] `asyncio.create_task` snapshots the current Context, so a flag held
for a write session's lifetime was inherited by every task spawned inside
it -- and the parent's `reset()` cannot reach a child's copy, leaving
that task issuing BEGIN IMMEDIATE for its *read* sessions.
`create_downloads` spawns `dispatch_downloads` exactly that way, so every
user-created download hit it.  The flag now lives only across the
session's opening `connection()` call, which also means the write lock is
taken when the session opens rather than at the caller's first statement.

[suggestion] `renew_recurring_downloads` scanned every recurring Download
under the write lock, including the usual cycle where nothing is due.  It
reads first now and takes the lock only for the rows that change,
re-checking status since the dispatcher may have claimed one in between.

[nit] Parenthesized the directory OR in the claim join.

`probe_write_lock_is_held` moved to conftest alongside
`write_lock_held_briefly`; three suites use it now.

Suite: 1712 passed, 5 skipped.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-07 20:15:50 -06:00

646 lines
27 KiB
Python
Raw Blame History

import pathlib
import subprocess
import tempfile
from copy import copy
from unittest import mock
import pytest
from PIL import Image
from modules.videos.models import Channel, Video
from wrolpi.collections import Collection
from wrolpi.conftest import probe_write_lock_is_held, production_like_sessions
from wrolpi.common import get_absolute_media_path, get_wrolpi_config, get_relative_to_media_directory
from wrolpi.downloader import Download, DownloadFrequency
from wrolpi.vars import PROJECT_DIR
from .. import common
from ..common import convert_image, update_view_counts_and_censored, extract_video_duration, generate_video_poster, \
is_valid_poster
from ..lib import save_channels_config, get_channels_config, import_channels_config, ChannelsConfig
def test_get_absolute_media_path(test_directory):
path = get_absolute_media_path('videos')
assert str(path) == f'{test_directory}/videos'
# An absolute path is not changed.
path = get_absolute_media_path(path)
assert str(path) == f'{test_directory}/videos'
def test_extract_video_duration(test_directory, corrupted_video_file):
"""
Video duration can be retrieved from the video file.
"""
video_path = PROJECT_DIR / 'test/big_buck_bunny_720p_1mb.mp4'
assert extract_video_duration(video_path) == 5
with pytest.raises(FileNotFoundError):
extract_video_duration(PROJECT_DIR / 'test/does not exist.mp4')
with pytest.raises(subprocess.CalledProcessError):
empty_file = test_directory / 'empty.mp4'
empty_file.touch()
extract_video_duration(empty_file)
with pytest.raises(subprocess.CalledProcessError):
extract_video_duration(corrupted_video_file)
def test_convert_image():
"""
An image's format can be changed. This tests that convert_image() converts from a WEBP format, to a JPEG format.
"""
foo = Image.new('RGB', (25, 25), color='grey')
with tempfile.TemporaryDirectory() as tempdir:
tempdir = pathlib.Path(tempdir)
# Save the new image to "foo.webp".
existing_path = tempdir / 'foo.webp'
foo.save(existing_path)
assert Image.open(existing_path).format == 'WEBP'
destination_path = tempdir / 'foo.jpg'
assert not destination_path.is_file()
# Convert the WEBP to a JPEG. The WEBP image should be removed.
convert_image(existing_path, destination_path)
assert not existing_path.is_file()
assert destination_path.is_file()
assert Image.open(destination_path).format == 'JPEG'
@pytest.mark.parametrize(
'ext,expected',
[
('jpg', True),
('jpeg', True),
('png', False),
('webp', False),
('tif', False),
]
)
def test_is_valid_poster(ext, expected, test_directory):
foo = Image.new('RGB', (25, 25), color='blue')
image_path = test_directory / f'image.{ext}'
foo.save(image_path)
assert is_valid_poster(image_path) == expected, f'is_valid_poster({image_path}) should be {expected}'
@pytest.mark.asyncio
async def test_update_view_count(test_session, channel_factory, video_factory):
def check_view_counts(view_counts):
for source_id, view_count in view_counts.items():
video = test_session.query(Video).filter_by(source_id=source_id).one()
assert video.view_count == view_count
channel1, channel2, channel3 = channel_factory(), channel_factory(), channel_factory()
video_factory(channel_id=channel1.id, with_poster_ext='jpg', title='vid1')
video_factory(channel_id=channel2.id, title='vid2')
video_factory(channel_id=channel3.id, with_poster_ext='jpg', title='vid3')
video_factory(channel_id=channel3.id, title='vid4')
channel1.info_json = {'entries': [{'id': 'vid1', 'view_count': 10}]}
channel2.info_json = {'entries': [{'id': 'vid2', 'view_count': 11}, {'id': 'bad_id', 'view_count': 12}]}
channel3.info_json = {'entries': [{'id': 'vid3', 'view_count': 13}, {'id': 'vid4', 'view_count': 14}]}
test_session.commit()
# Check all videos are empty.
check_view_counts({'vid1': None, 'vid2': None, 'vid3': None, 'vid4': None})
# Channel 1 is updated, the other channels are left alone.
await update_view_counts_and_censored(channel1.id)
check_view_counts({'vid1': 10, 'vid2': None, 'vid3': None, 'vid4': None})
# Channel 2 is updated, the other channels are left alone. The 'bad_id' video is ignored.
await update_view_counts_and_censored(channel2.id)
check_view_counts({'vid1': 10, 'vid2': 11, 'vid3': None, 'vid4': None})
# All videos are updated.
await update_view_counts_and_censored(channel3.id)
check_view_counts({'vid1': 10, 'vid2': 11, 'vid3': 13, 'vid4': 14})
# An outdated view count will be overwritten.
vid = test_session.query(Video).filter_by(id=1).one()
vid.view_count = 8
test_session.commit() # Commit so raw SQL in update_view_counts_and_censored doesn't deadlock
check_view_counts({'vid1': 8, 'vid2': 11, 'vid3': 13, 'vid4': 14})
await update_view_counts_and_censored(channel1.id)
test_session.expire_all() # Expire cached values to see raw SQL changes
check_view_counts({'vid1': 10, 'vid2': 11, 'vid3': 13, 'vid4': 14})
@pytest.mark.asyncio
async def test_update_view_count_missing_view_count(test_session, channel_factory, video_factory):
"""Entries without a view_count key (e.g. private/unavailable videos) are skipped without error."""
channel = channel_factory()
video_factory(channel_id=channel.id, with_poster_ext='jpg', title='vid1')
channel.info_json = {'entries': [
{'id': 'vid1', 'view_count': 42},
{'id': 'vid_private'}, # No view_count key.
{'id': 'vid_null', 'view_count': None},
]}
test_session.commit()
# Should not raise KeyError.
await update_view_counts_and_censored(channel.id)
test_session.expire_all()
video = test_session.query(Video).filter_by(source_id='vid1').one()
assert video.view_count == 42
def test_generate_video_poster(video_file):
"""
A poster can be generated from a video file.
"""
poster_path = video_file.with_suffix('.jpg')
_, duration = generate_video_poster(video_file)
assert poster_path.is_file(), f'{poster_path} was not created!'
assert poster_path.stat().st_size > 0
assert duration == 5
@pytest.mark.asyncio
async def test_import_channel_downloads(await_switches, test_session, channel_factory, test_channels_config,
tag_factory):
"""Importing the Channels' config should create any missing download records"""
channel1 = channel_factory(source_id='foo', url='https://example.com/channel1')
channel2 = channel_factory(source_id='bar', url='https://example.com/channel2')
tag = await tag_factory()
assert len(test_session.query(Channel).all()) == 2
test_session.commit()
def update_channel_config(conf: ChannelsConfig, source_id, d):
# Creat a copy of the old config, replace the data of the provided Channel.
old_config = conf._config.copy()
for c in old_config['channels']:
if c['source_id'] == source_id:
c.update(d)
conf.channels = old_config['channels']
conf.save()
# Two Channels, but neither have Downloads.
save_channels_config()
await await_switches()
# Import after config is saved.
import_channels_config()
assert not channel1.downloads
assert not channel2.downloads
assert len(test_session.query(Channel).all()) == 2
assert test_session.query(Download).count() == 0
# Add a frequency to `channel1`.
channels_config = get_channels_config()
update_channel_config(channels_config, 'foo',
{'downloads': [
{'url': 'https://example.com/channel1', 'frequency': DownloadFrequency.weekly.value}
]})
await await_switches()
# Download record is created on import.
import_channels_config()
assert channel1.downloads
assert len(test_session.query(Channel).all()) == 2, 'Both Channels should still exist'
assert test_session.query(Download).count() == 1, 'One Channel has a Download'
download: Download = test_session.query(Download).one()
assert download.url == channel1.url
assert download.frequency
assert download.downloader == 'video_channel'
# Download.next_download was not deleted.
next_download = str(download.next_download)
import_channels_config()
download: Download = test_session.query(Download).one()
assert next_download == str(download.next_download)
# Creating Download that matches Channel2's URL means they are related. Delete it and it should be re-created.
channel2.get_or_create_download(test_session, channel2.url, 60)
save_channels_config()
Download.find_by_url(test_session, channel2.url).delete(add_to_skip_list=False)
test_session.commit()
await await_switches()
# Missing Download is re-created on import.
import_channels_config()
channel2 = Channel.get_by_id(test_session, channel2.id)
downloads = test_session.query(Download).all()
assert len(downloads) == 1, downloads
assert len(channel1.downloads) == 1
assert len(channel2.downloads) == 0
assert downloads[0].downloader == 'video_channel'
# Add a Download to Channel2 which does not match Channel.url.
channel2.get_or_create_download(test_session, 'https://example.org', 60)
channel2.get_or_create_download(test_session, 'https://example.com/channel2', 60)
test_session.commit()
save_channels_config()
await await_switches()
# Check config is written to match new URLs.
config = get_channels_config()
assert len(config.channels) == 2
for channel_config in config.channels:
if channel_config['source_id'] == channel2.source_id:
assert channel_config['source_id'] == 'bar'
assert len(channel_config['downloads']) == 2
assert {i['url'] for i in channel_config['downloads']} \
== {'https://example.com/channel2', 'https://example.org'}
else:
assert channel_config['source_id'] == 'foo'
# Get Channels with their Downloads.
channels_backup = copy(get_channels_config().channels)
# Reset Downloads. Downloads should be recreated from the channels config file.
[i.delete(add_to_skip_list=False) for i in test_session.query(Download).all()]
# Write config with Channel Downloads now that the delete() has removed them from the config.
get_channels_config().channels = channels_backup
import_channels_config()
channel1, channel2 = test_session.query(Channel).order_by(Channel.url).all()
assert test_session.query(Download).count() == 3
assert channel1.url == 'https://example.com/channel1'
assert channel2.url == 'https://example.com/channel2'
assert {i.url for i in channel1.downloads} == {'https://example.com/channel1'}
assert {i.url for i in channel2.downloads} == {'https://example.com/channel2', 'https://example.org'}
# A Channel with a `tag_name` is tagged.
update_channel_config(get_channels_config(),
channel1.source_id,
{'tag_name': tag.name})
import_channels_config()
channel1, channel2 = test_session.query(Channel).order_by(Channel.url).all()
assert channel1.tag == tag and channel1.tag_id == tag.id
assert channel2.tag is None and channel2.tag_id is None
@pytest.mark.asyncio
async def test_import_channel_delete_missing_channels(await_switches, test_session, channel_factory,
test_channels_config):
"""The Channel import function deletes any Channels that are not in the config."""
# Create a DB and config with two Channels.
channel1 = channel_factory(source_id='foo')
channel2 = channel_factory(source_id='bar')
test_session.commit()
# Capture directory values before deletion (channels will be detached after deletion)
# Config stores relative paths for portability
channel1_dir = str(get_relative_to_media_directory(channel1.directory))
channel2_dir = str(get_relative_to_media_directory(channel2.directory))
# Write Channels to the config file.
save_channels_config()
test_session.delete(channel1)
test_session.delete(channel2)
test_session.commit()
await await_switches()
# Importing the config creates two Channels.
import_channels_config()
assert len(test_session.query(Channel).all()) == 2
assert channel1_dir in test_channels_config.read_text()
assert channel2_dir in test_channels_config.read_text()
# Delete channel2 from the config file.
config = get_channels_config()
config_dict = config.dict()
config_dict['channels'] = [i for i in config.channels if i['directory'] != channel2_dir]
config.update(config_dict)
await await_switches()
assert channel1_dir in test_channels_config.read_text()
assert channel2_dir not in test_channels_config.read_text()
# Importing the config deletes the Channel record.
import_channels_config()
assert len(test_session.query(Channel).all()) == 1
assert channel1_dir in test_channels_config.read_text()
assert channel2_dir not in test_channels_config.read_text()
# Saving and importing does not change anything.
save_channels_config()
import_channels_config()
assert channel1_dir in test_channels_config.read_text()
assert channel2_dir not in test_channels_config.read_text()
@pytest.mark.asyncio
async def test_import_channel_deletes_orphaned_collections(await_switches, test_session, channel_factory,
test_channels_config):
"""When a Channel is deleted from config, its associated Collection should also be deleted.
This prevents orphaned Collections (kind='channel') from appearing in the UI with null channel_id.
"""
# Create two channels (each creates a Collection with kind='channel')
channel1 = channel_factory(source_id='foo')
channel2 = channel_factory(source_id='bar')
test_session.commit()
# Verify both Collections exist
assert test_session.query(Collection).filter_by(kind='channel').count() == 2
# Capture directory values before deletion (config stores relative paths)
channel1_dir = str(get_relative_to_media_directory(channel1.directory))
channel2_dir = str(get_relative_to_media_directory(channel2.directory))
collection2_id = channel2.collection_id
# Write Channels to the config file
save_channels_config()
await await_switches()
# Remove channel2 from the config file
config = get_channels_config()
config_dict = config.dict()
config_dict['channels'] = [i for i in config.channels if i['directory'] != channel2_dir]
config.update(config_dict)
await await_switches()
# Import config - this should delete channel2 AND its Collection
import_channels_config()
# Verify only one Channel remains
assert test_session.query(Channel).count() == 1
# Verify the orphaned Collection was also deleted (this is the bug we're fixing)
assert test_session.query(Collection).filter_by(kind='channel').count() == 1
assert test_session.query(Collection).filter_by(id=collection2_id).count() == 0
@pytest.mark.asyncio
async def test_import_channel_cleans_up_preexisting_orphaned_collections(await_switches, test_session, channel_factory,
test_channels_config):
"""Pre-existing orphaned Collections (kind='channel') with no Channel should be deleted during import.
This handles the case where a Collection was orphaned before the cleanup fix was deployed.
"""
# Create a channel (which creates a Collection)
channel1 = channel_factory(source_id='foo')
test_session.commit()
# Create an orphaned Collection directly (simulating pre-existing orphan)
orphan_collection = Collection(
name='Orphaned Channel',
kind='channel',
directory=None,
)
test_session.add(orphan_collection)
test_session.commit()
orphan_id = orphan_collection.id
# Verify we have 2 Collections with kind='channel'
assert test_session.query(Collection).filter_by(kind='channel').count() == 2
# Write the valid channel to config
save_channels_config()
await await_switches()
# Import config - should clean up the pre-existing orphan
import_channels_config()
# Verify only one Collection remains (the one with a Channel)
assert test_session.query(Collection).filter_by(kind='channel').count() == 1
assert test_session.query(Collection).filter_by(id=orphan_id).count() == 0
@pytest.mark.asyncio
async def test_once_download_excluded_from_channel_config(await_switches, test_session, channel_factory,
test_channels_config):
"""A once-download (no frequency) associated with a Channel's Collection should not be saved to the channels
config. This prevents errors during import when a once-download has no frequency."""
channel = channel_factory(download_frequency=DownloadFrequency.weekly)
# Create a once-download associated with the channel's collection (simulates a video download that got
# associated with the channel via apply_yt_channel).
once_download = Download(url='https://www.youtube.com/watch?v=once_video', downloader='video',
collection_id=channel.collection_id)
test_session.add(once_download)
test_session.commit()
# The once-download is in the Collection, but Channel.downloads filters it out.
assert len(channel.collection.downloads) == 2
assert len(channel.downloads) == 1
save_channels_config()
await await_switches()
# The once-download should not appear in the config.
config_text = test_channels_config.read_text()
assert 'once_video' not in config_text
# The recurring download should still be there.
assert channel.url in config_text
# Importing should succeed without the "Refusing to create Download" error.
test_session.delete(once_download)
test_session.commit()
import_channels_config()
assert len(channel.downloads) == 1
@pytest.mark.asyncio
async def test_import_channel_download_comments(await_switches, test_session, channel_factory,
test_channels_config):
channel = channel_factory()
assert channel.download_missing_data is True
# download_missing_data is saved to the config.
save_channels_config()
await await_switches()
assert 'download_missing_data: true' in test_channels_config.read_text()
# change download_missing_data to False, channel should be updated on import.
contents = test_channels_config.read_text()
contents = contents.replace('download_missing_data: true', 'download_missing_data: false')
test_channels_config.write_text(contents)
import_channels_config()
assert channel.download_missing_data is False
@pytest.mark.asyncio
async def test_save_channels_config_does_not_wipe_config(await_switches, test_session, channel_factory,
test_channels_config):
"""Saving channels config when DB is empty must not overwrite an existing config file that has channels.
Regression test: a fresh DB (e.g. after repair) triggering save_channels_config would write channels: []
to the config file, permanently wiping the channel definitions.
"""
# Create a channel and save it to the config file.
channel = channel_factory()
test_session.commit()
save_channels_config()
await await_switches()
assert test_channels_config.is_file()
config_text = test_channels_config.read_text()
assert 'channels: []' not in config_text, 'Config should have a channel'
# Simulate a fresh DB by deleting all channels.
test_session.query(Channel).delete()
test_session.query(Collection).filter_by(kind='channel').delete()
test_session.commit()
assert test_session.query(Channel).count() == 0
# Saving with an empty DB should NOT wipe the config file.
save_channels_config()
await await_switches()
config_text = test_channels_config.read_text()
assert 'channels: []' not in config_text, 'Config was wiped by saving with empty DB!'
@pytest.mark.asyncio
async def test_ffprobe_json(async_client, video_file, corrupted_video_file):
content = await common.ffprobe_json(video_file)
assert not content['chapters']
assert content['format']['duration'] == '5.312000'
assert content['format']['size'] == '1056318'
assert content['streams']
assert content['streams'][0]['codec_name'] == 'h264'
with pytest.raises(RuntimeError):
await common.ffprobe_json(corrupted_video_file)
def test_read_write_ffprobe_json_file(test_directory):
"""Test reading and writing .ffprobe.json files."""
ffprobe_path = test_directory / 'video.ffprobe.json'
ffprobe_data = {'streams': [{'codec_name': 'h264'}], 'format': {'duration': '5.0'}}
# File doesn't exist, should return None
assert common.read_ffprobe_json_file(ffprobe_path) is None
assert common.read_ffprobe_json_file(None) is None
# Write the file
common.write_ffprobe_json_file(ffprobe_path, ffprobe_data)
assert ffprobe_path.is_file()
# File should be human-readable (indented)
contents = ffprobe_path.read_text()
assert '\n' in contents, 'ffprobe json should be formatted with newlines'
# Read it back
loaded = common.read_ffprobe_json_file(ffprobe_path)
assert loaded == ffprobe_data
# Invalid JSON should return None
ffprobe_path.write_text('not valid json')
assert common.read_ffprobe_json_file(ffprobe_path) is None
@pytest.mark.asyncio
async def test_video_ffprobe_json(async_client, test_session, video_file, refresh_files):
"""ffprobe data is extracted when a video is modeled."""
with mock.patch('modules.videos.lib.extract_video_duration') as mock_extract_video_duration:
mock_extract_video_duration.side_effect = Exception('duration should be from ffprobe json')
await refresh_files()
video = test_session.query(Video).one()
assert video.ffprobe_json
assert video.file_group.length
@pytest.mark.asyncio
async def test_video_ffprobe_json_caches_to_file(async_client, test_session, video_file, refresh_files):
"""ffprobe results are cached to .ffprobe.json file."""
await refresh_files()
video = test_session.query(Video).one()
# .ffprobe.json file should have been created during validation
ffprobe_path = video.ffprobe_json_path
assert ffprobe_path.is_file(), '.ffprobe.json file should have been created'
# File should contain the ffprobe data
cached_data = common.read_ffprobe_json_file(ffprobe_path)
assert cached_data is not None
assert 'streams' in cached_data
assert 'format' in cached_data
@pytest.mark.asyncio
async def test_video_ffprobe_json_reads_from_cache(async_client, test_session, video_file, refresh_files):
"""get_ffprobe_json() uses cached .ffprobe.json file instead of running ffprobe."""
await refresh_files()
video = test_session.query(Video).one()
ffprobe_path = video.ffprobe_json_path
# Clear the DB cache to simulate a fresh reindex
video.ffprobe_json = None
test_session.commit()
# Write a fake ffprobe cache file with a marker
fake_data = {'streams': [{'codec_name': 'cached_marker'}], 'format': {'duration': '999'}}
common.write_ffprobe_json_file(ffprobe_path, fake_data)
# get_ffprobe_json should read from the cached file, not call ffprobe
result = await video.get_ffprobe_json()
assert result['streams'][0]['codec_name'] == 'cached_marker', \
'Should have read cached file instead of running ffprobe'
assert video.ffprobe_json == fake_data, 'DB should be updated with cached data'
@pytest.mark.asyncio
async def test_video_ffprobe_json_returns_db_first(async_client, test_session, video_file, refresh_files):
"""get_ffprobe_json() returns DB data if already populated, without reading file."""
await refresh_files()
video = test_session.query(Video).one()
original_data = video.ffprobe_json.copy()
# Write different data to the file (simulating stale cache)
fake_data = {'streams': [{'codec_name': 'stale_data'}], 'format': {}}
common.write_ffprobe_json_file(video.ffprobe_json_path, fake_data)
# Should return DB data, not file data
result = await video.get_ffprobe_json()
assert result == original_data
assert result['streams'][0]['codec_name'] != 'stale_data'
def test_get_videos_directory(test_directory):
"""Default videos directory path"""
# Directory does not yet exist.
assert not (test_directory / 'videos').exists()
# Directory is created when first gotten.
assert common.get_videos_directory() == (test_directory / 'videos')
assert (test_directory / 'videos').is_dir()
def test_get_custom_videos_directory(test_directory, test_wrolpi_config):
"""Custom directory can be used for videos directory."""
config = get_wrolpi_config()
config.videos_destination = 'custom/directory/videos'
assert common.get_videos_directory() == (test_directory / 'custom/directory/videos')
assert (test_directory / 'custom/directory/videos').is_dir()
assert not (test_directory / 'videos').is_dir()
@pytest.mark.asyncio
async def test_video_modeler_does_not_hold_write_lock_during_ffprobe(async_client, test_session, video_factory):
"""Modeling must not hold the SQLite write lock while ffprobe runs.
`video_modeler` opened one write session per batch and `await`ed `get_ffprobe_json` -- an ffprobe
subprocess -- for up to 20 videos inside it. Every other writer on the box waits on that lock
and gives up after `busy_timeout` (30s). ffprobe belongs outside the transaction: read the
batch, probe the files, then write what was learned.
"""
import modules.videos as videos_module
from modules.videos import video_modeler
video = video_factory(with_video_file=True)
video.file_group.indexed = False
video.file_group.model = None
test_session.delete(video)
test_session.commit()
db_file = test_session.get_bind().url.database
lock_held_during_ffprobe = []
real_get_or_create_ffprobe_json = videos_module.get_or_create_ffprobe_json
async def probing_ffprobe(video_path):
lock_held_during_ffprobe.append(probe_write_lock_is_held(db_file))
return await real_get_or_create_ffprobe_json(video_path)
with production_like_sessions(test_session):
with mock.patch.object(videos_module, 'get_or_create_ffprobe_json', probing_ffprobe):
await video_modeler()
assert lock_held_during_ffprobe, 'ffprobe never ran, so the test proves nothing'
assert not any(lock_held_during_ffprobe), \
'the write lock was held while ffprobe ran; every other writer waits out busy_timeout'
Reference in a new issue View git blame Copy permalink