From da6e62ee4514a1a8024bcad8f63048a668fba8dd Mon Sep 17 00:00:00 2001 From: Roland Date: Mon, 9 Mar 2026 16:11:44 -0600 Subject: [PATCH] Backup configs can be restored in the UI. User can choose between Merge or Overwrite, the UI displays a comparison. Configs are compared when user opens the restore modal, configs which won't cause changes are marked. --- app/src/App.css | 6 + app/src/api.js | 29 + app/src/components/admin/Configs.js | 309 ++++++- controller/templates/index.html | 10 +- modules/archive/lib.py | 64 ++ modules/inventory/common.py | 55 ++ modules/videos/lib.py | 56 ++ modules/videos/test/test_common.py | 2 +- wrolpi/common.py | 67 +- wrolpi/config_api.py | 59 +- wrolpi/config_schema.py | 14 + wrolpi/downloader.py | 72 ++ wrolpi/tags.py | 105 +++ wrolpi/test/test_config_backup_import.py | 1033 ++++++++++++++++++++++ wrolpi/test/test_tags.py | 6 +- 15 files changed, 1870 insertions(+), 17 deletions(-) create mode 100644 wrolpi/test/test_config_backup_import.py diff --git a/app/src/App.css b/app/src/App.css index 3f46f9d3..69928256 100644 --- a/app/src/App.css +++ b/app/src/App.css @@ -382,6 +382,12 @@ tr.drag-deselecting td { -ms-user-select: none; } +@media only screen and (max-width: 700px) { + .hide-on-mobile { + display: none !important; + } +} + /* Ensure step icons are always visible, even when disabled */ .ui.steps .step.disabled > .icon, .ui.steps .step.disabled > i.icon, diff --git a/app/src/api.js b/app/src/api.js index eb31b199..fda9dc59 100644 --- a/app/src/api.js +++ b/app/src/api.js @@ -417,6 +417,35 @@ export async function getConfig(fileName) { return (await response.json())['config']; } +export async function getConfigBackups(fileName) { + const response = await apiGet(`${API_URI}/config/backups?file_name=${fileName}`); + if (response.ok) { + return await response.json(); + } + return {dates: []}; +} + +export async function postConfigBackupPreview(fileName, backupDate, mode) { + const body = {file_name: fileName, backup_date: backupDate, mode}; + const response = await apiPost(`${API_URI}/config/backup/preview`, body); + if (response.ok) { + return await response.json(); + } + const message = await getErrorMessage(response, 'Could not preview backup.'); + toast({type: 'error', title: 'Preview failed', description: message, time: 5000}); + return null; +} + +export async function postConfigBackupImport(fileName, backupDate, mode) { + const body = {file_name: fileName, backup_date: backupDate, mode}; + const response = await apiPost(`${API_URI}/config/backup/import`, body); + if (!response.ok) { + const message = await getErrorMessage(response, 'Could not import backup.'); + toast({type: 'error', title: 'Backup import failed', description: message, time: 5000}); + } + return response; +} + export async function fetchVideoDownloaderConfig() { return await getConfig('videos_downloader.yaml'); } diff --git a/app/src/components/admin/Configs.js b/app/src/components/admin/Configs.js index 89662a63..3bbfd0c8 100644 --- a/app/src/components/admin/Configs.js +++ b/app/src/components/admin/Configs.js @@ -1,9 +1,11 @@ import {APIButton} from "../Common"; -import {Icon, Popup, Table} from "../Theme"; -import React from "react"; +import {Button, Header, Icon, Loader, Modal, Popup, Table} from "../Theme"; +import React, {useContext, useEffect, useState} from "react"; import {TableBody, TableCell, TableHeader, TableHeaderCell, TableRow} from "semantic-ui-react"; import {TableRowPlaceholder} from "../Placeholder"; import {useNavigate} from "react-router"; +import {getConfigBackups, postConfigBackupImport, postConfigBackupPreview} from "../../api"; +import {ThemeContext} from "../../contexts/contexts"; function WarningIcon({ok}) { // null is empty, true is valid, false is invalid. @@ -15,9 +17,285 @@ function WarningIcon({ok}) { return } +const TYPE_LABELS = { + tag: 'Tags', + tag_file: 'Tag Files', + tag_zim: 'Tag Zims', + channel: 'Channels', + domain: 'Domains', + download: 'Downloads', + inventory: 'Inventories', +}; + +const TYPE_COLUMNS = { + tag: [{key: 'name', header: 'Name'}], + tag_file: [{key: 'tag', header: 'Tag'}, {key: 'path', header: 'Path'}], + tag_zim: [{key: 'tag', header: 'Tag'}, {key: 'zim', header: 'Zim'}, {key: 'entry', header: 'Entry'}], + channel: [{key: 'name', header: 'Name'}, {key: 'directory', header: 'Directory'}], + domain: [{key: 'name', header: 'Name'}, {key: 'directory', header: 'Directory'}], + download: [{key: 'url', header: 'URL'}, {key: 'downloader', header: 'Downloader'}], + inventory: [{key: 'name', header: 'Name'}], +}; + +function groupItemsByType(items) { + const groups = {}; + for (const item of items) { + if (!groups[item.type]) { + groups[item.type] = []; + } + groups[item.type].push(item); + } + return Object.entries(groups).map(([type, items]) => ({ + type, label: TYPE_LABELS[type] || type, items, + })); +} + +function PreviewItemTable({items, negative, inverted}) { + if (!items.length) return null; + const columns = TYPE_COLUMNS[items[0].type] || [{key: 'type', header: 'Item'}]; + return + + + {columns.map(col => {col.header})} + + + + {items.map((item, i) => + {columns.map(col => + {item[col.key] || ''} + )} + )} + +
; +} + +const formatDate = (d) => d ? `${d.substring(0, 4)}-${d.substring(4, 6)}-${d.substring(6, 8)}` : ''; + +function BackupDateRow({date, previews, previewsLoaded, onSelect}) { + const mergeLoaded = previewsLoaded?.merge; + const overwriteLoaded = previewsLoaded?.overwrite; + const mergePreview = previews?.merge; + const overwritePreview = previews?.overwrite; + + const hasChanges = (p) => p && (p.add.length > 0 || p.remove.length > 0); + const mergeHasChanges = hasChanges(mergePreview); + const overwriteHasChanges = hasChanges(overwritePreview); + + let mergeCell; + if (!mergeLoaded) { + mergeCell = ; + } else if (mergePreview === null) { + mergeCell = } content='Failed to load preview'/>; + } else if (mergeHasChanges) { + mergeCell = ; + } else { + mergeCell = No changes; + } + + let overwriteCell; + if (!overwriteLoaded) { + overwriteCell = ; + } else if (overwritePreview === null) { + overwriteCell = } content='Failed to load preview'/>; + } else if (overwriteHasChanges) { + overwriteCell = ; + } else { + overwriteCell = No changes; + } + + return + {formatDate(date)} + {mergeCell} + {overwriteCell} + ; +} + +function BackupsModal({open, onClose, fileName, fetchConfigs}) { + const {inverted} = useContext(ThemeContext); + const [dates, setDates] = useState([]); + const [datesLoading, setDatesLoading] = useState(true); + const [previews, setPreviews] = useState({}); + const [previewsLoaded, setPreviewsLoaded] = useState({}); + const [selectedAction, setSelectedAction] = useState(null); // {date, mode, preview} + const [applying, setApplying] = useState(false); + + // Fetch backup dates on open. + useEffect(() => { + if (!open) return; + let cancelled = false; + setDatesLoading(true); + setDates([]); + setPreviews({}); + setPreviewsLoaded({}); + setSelectedAction(null); + setApplying(false); + + getConfigBackups(fileName).then(result => { + if (cancelled) return; + setDates(result?.dates || []); + setDatesLoading(false); + }); + + return () => { cancelled = true; }; + }, [open, fileName]); + + // Progressively fetch previews for each date, newest first. + useEffect(() => { + if (!open || dates.length === 0) return; + let cancelled = false; + + const loadPreviews = async () => { + for (const date of dates) { + if (cancelled) break; + + const [mergeResult, overwriteResult] = await Promise.all([ + postConfigBackupPreview(fileName, date, 'merge'), + postConfigBackupPreview(fileName, date, 'overwrite'), + ]); + if (cancelled) break; + setPreviews(prev => ({ + ...prev, + [date]: {merge: mergeResult?.preview || null, overwrite: overwriteResult?.preview || null} + })); + setPreviewsLoaded(prev => ({...prev, [date]: {merge: true, overwrite: true}})); + } + }; + + loadPreviews(); + return () => { cancelled = true; }; + }, [open, dates, fileName]); + + const handleSelect = (date, mode, preview) => { + setSelectedAction({date, mode, preview}); + }; + + const handleApply = async () => { + if (!selectedAction) return; + setApplying(true); + await postConfigBackupImport(fileName, selectedAction.date, selectedAction.mode); + await fetchConfigs(); + setApplying(false); + handleClose(); + }; + + const handleBack = () => { + setSelectedAction(null); + }; + + const handleClose = () => { + onClose(); + }; + + // Confirmation view: show the diff for the selected action. + if (selectedAction) { + const {date, mode, preview} = selectedAction; + const modeLabel = mode === 'merge' ? 'Merge' : 'Overwrite'; + + return + + {modeLabel}: {fileName} ({formatDate(date)}) + + + {applying + ?
+ Applying backup... +
+ : <> + {preview.add.length > 0 && <> +
+ {preview.add.length} item{preview.add.length !== 1 ? 's' : ''} to add +
+
+ {groupItemsByType(preview.add).map(group => + +
{group.label}
+ +
+ )} +
+ } + + {preview.remove.length > 0 && <> +
+ {preview.remove.length} item{preview.remove.length !== 1 ? 's' : ''} to + remove +
+
+ {groupItemsByType(preview.remove).map(group => + +
{group.label}
+ +
+ )} +
+ } + +

{preview.unchanged} unchanged + item{preview.unchanged !== 1 ? 's' : ''}

+ + } +
+ + {!applying && <> + + + } + +
; + } + + // Backups list view. + return + Restore Backup: {fileName} + + {datesLoading + ?
+ Loading backups... +
+ : dates.length === 0 + ?

No backups available for this config.

+ :
+ + + + Date + Merge + Overwrite + + + + {dates.map(date => + + )} + +
+
+ } +
+ + + +
; +} + function ConfigTableRow({config, importConfig, saveConfig, fetchConfigs}) { - const {file_name, rel_path, valid, successful_import} = config; + const {file_name, rel_path, valid, successful_import, has_backup_import} = config; const navigate = useNavigate(); + const [backupsModalOpen, setBackupsModalOpen] = useState(false); const localImportConfig = async () => { await importConfig(file_name); @@ -57,25 +335,39 @@ function ConfigTableRow({config, importConfig, saveConfig, fetchConfigs}) { navigate(`?preview=${rel_path}`)}>{file_name} + + {has_backup_import + ? + : null + } + {importButton} {saveButton} + {backupsModalOpen && setBackupsModalOpen(false)} + fileName={file_name} + fetchConfigs={fetchConfigs} + />} } export function ConfigsTable({configs, loading, importConfig, saveConfig, fetchConfigs}) { let body = - + if (loading) { // Configs are being fetched again. } else if (configs === undefined) { body = - Failed to fetch configs + Failed to fetch configs ; } else if (configs && Object.keys(configs).length === 0) { body = - No configs exist. Try tagging some files. + No configs exist. Try tagging some files. ; } else if (configs) { body = Object.entries(configs).map(([key, value]) => @@ -89,12 +381,13 @@ export function ConfigsTable({configs, loading, importConfig, saveConfig, fetchC ); } - return + return
- File Name + File Name Imported Valid + Restore Import Save diff --git a/controller/templates/index.html b/controller/templates/index.html index 59e51f73..e0b1a973 100644 --- a/controller/templates/index.html +++ b/controller/templates/index.html @@ -1893,7 +1893,10 @@ } const checkUpgradeComplete = async () => { try { - const resp = await fetch('/api/ready', { + // WARNING: This must be a relative URL (no leading slash) so it resolves to + // /controller/api/ready behind Caddy, or /api/ready when accessed directly. + // An absolute '/api/ready' would be routed to Sanic by Caddy, not the Controller. + const resp = await fetch('api/ready', { method: 'GET', headers: {'Accept': 'application/json'}, signal: AbortSignal.timeout(5000) @@ -1936,7 +1939,10 @@ // Poll controller's readiness endpoint (same-origin, avoids CORS/cert issues). const checkMainApp = async () => { try { - const resp = await fetch('/api/ready', { + // WARNING: This must be a relative URL (no leading slash) so it resolves to + // /controller/api/ready behind Caddy, or /api/ready when accessed directly. + // An absolute '/api/ready' would be routed to Sanic by Caddy, not the Controller. + const resp = await fetch('api/ready', { method: 'GET', headers: {'Accept': 'application/json'}, signal: AbortSignal.timeout(5000) diff --git a/modules/archive/lib.py b/modules/archive/lib.py index 10092c4b..184d9310 100644 --- a/modules/archive/lib.py +++ b/modules/archive/lib.py @@ -180,6 +180,70 @@ class DomainsConfig(ConfigFile): logger.info(f'Dumping {len(collections_data)} domain collections to config') self.save(file, send_events, overwrite) + def preview_backup_import(self, backup_date: str, mode: str) -> dict: + backup_file = self._get_backup_file(backup_date) + backup_data = self.read_config_file(backup_file) + current_data = self.read_config_file() if self.get_file().is_file() else dict(collections=[], version=0) + + backup_collections = backup_data.get('collections', []) + current_collections = current_data.get('collections', []) + + # Identity key for domains is the directory (if present) or name + def get_key(c): + return c.get('directory') or c.get('name', '') + + current_keys = {get_key(c) for c in current_collections} + backup_keys = {get_key(c) for c in backup_collections} + + add = [] + remove = [] + unchanged = 0 + + for c in backup_collections: + key = get_key(c) + if key not in current_keys: + add.append(dict(type='domain', name=c.get('name', ''), directory=c.get('directory', ''))) + else: + unchanged += 1 + if mode == 'overwrite': + current_key_to_coll = {get_key(c): c for c in current_collections} + for key in sorted(current_keys - backup_keys): + c = current_key_to_coll[key] + remove.append(dict(type='domain', name=c.get('name', ''), directory=c.get('directory', ''))) + + return dict(mode=mode, add=add, remove=remove, unchanged=unchanged) + + def import_backup(self, backup_date: str, mode: str, send_events: bool = False): + self._preserve_current_config() + import shutil + backup_file = self._get_backup_file(backup_date) + config_file = self.get_file() + + if mode == 'overwrite': + config_file.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(backup_file, config_file) + elif mode == 'merge': + backup_data = self.read_config_file(backup_file) + current_data = self.read_config_file() if config_file.is_file() else dict(collections=[], version=0) + + def get_key(c): + return c.get('directory') or c.get('name', '') + + current_keys = {get_key(c) for c in current_data.get('collections', [])} + merged_collections = list(current_data.get('collections', [])) + for c in backup_data.get('collections', []): + if get_key(c) not in current_keys: + merged_collections.append(c) + + merged_data = dict( + collections=merged_collections, + version=current_data.get('version', 0) + 1, + ) + config_file.parent.mkdir(parents=True, exist_ok=True) + self.write_config_data(merged_data, config_file) + + self.import_config(send_events=send_events) + # Global instance domains_config = DomainsConfig() diff --git a/modules/inventory/common.py b/modules/inventory/common.py index 9d0d3073..2a26236e 100644 --- a/modules/inventory/common.py +++ b/modules/inventory/common.py @@ -212,6 +212,61 @@ class InventoriesConfig(ConfigFile): Events.send_config_import_failed(message) raise + def preview_backup_import(self, backup_date: str, mode: str) -> dict: + backup_file = self._get_backup_file(backup_date) + backup_data = self.read_config_file(backup_file) + current_data = self.read_config_file() if self.get_file().is_file() else dict(inventories=[], version=0) + + backup_inventories = backup_data.get('inventories', []) + current_inventories = current_data.get('inventories', []) + + current_names = {inv.get('name') for inv in current_inventories if inv.get('name')} + backup_names = {inv.get('name') for inv in backup_inventories if inv.get('name')} + + add = [] + remove = [] + unchanged = 0 + + for inv in backup_inventories: + name = inv.get('name') + if name and name not in current_names: + add.append(dict(type='inventory', name=name)) + elif name: + unchanged += 1 + if mode == 'overwrite': + for name in sorted(current_names - backup_names): + remove.append(dict(type='inventory', name=name)) + + return dict(mode=mode, add=add, remove=remove, unchanged=unchanged) + + def import_backup(self, backup_date: str, mode: str, send_events: bool = False): + self._preserve_current_config() + import shutil + backup_file = self._get_backup_file(backup_date) + config_file = self.get_file() + + if mode == 'overwrite': + config_file.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(backup_file, config_file) + elif mode == 'merge': + backup_data = self.read_config_file(backup_file) + current_data = self.read_config_file() if config_file.is_file() else dict(inventories=[], version=0) + + current_names = {inv.get('name') for inv in current_data.get('inventories', []) if inv.get('name')} + merged_inventories = list(current_data.get('inventories', [])) + for inv in backup_data.get('inventories', []): + if inv.get('name') and inv['name'] not in current_names: + merged_inventories.append(inv) + + merged_data = dict( + inventories=merged_inventories, + version=current_data.get('version', 0) + 1, + ) + config_file.parent.mkdir(parents=True, exist_ok=True) + self.write_config_data(merged_data, config_file) + + self.import_config(send_events=send_events) + INVENTORIES_CONFIG: InventoriesConfig = InventoriesConfig() TEST_INVENTORIES_CONFIG: InventoriesConfig = None diff --git a/modules/videos/lib.py b/modules/videos/lib.py index 3f28b5af..09285e0a 100644 --- a/modules/videos/lib.py +++ b/modules/videos/lib.py @@ -452,6 +452,62 @@ class ChannelsConfig(ConfigFile): channel_import_logger.info(f'Dumping {len(channels_data)} channels to config') self.save(file, send_events, overwrite) + def preview_backup_import(self, backup_date: str, mode: str) -> dict: + backup_file = self._get_backup_file(backup_date) + backup_data = self.read_config_file(backup_file) + current_data = self.read_config_file() if self.get_file().is_file() else dict(channels=[], version=0) + + backup_channels = backup_data.get('channels', []) + current_channels = current_data.get('channels', []) + + current_dirs = {ch.get('directory') for ch in current_channels if ch.get('directory')} + backup_dirs = {ch.get('directory') for ch in backup_channels if ch.get('directory')} + + add = [] + remove = [] + unchanged = 0 + + for ch in backup_channels: + d = ch.get('directory') + if d and d not in current_dirs: + add.append(dict(type='channel', name=ch.get('name', ''), directory=d)) + elif d: + unchanged += 1 + if mode == 'overwrite': + backup_dir_to_name = {ch.get('directory'): ch.get('name', '') for ch in current_channels} + for d in sorted(current_dirs - backup_dirs): + remove.append(dict(type='channel', name=backup_dir_to_name.get(d, ''), directory=d)) + + return dict(mode=mode, add=add, remove=remove, unchanged=unchanged) + + def import_backup(self, backup_date: str, mode: str, send_events: bool = False): + self._preserve_current_config() + import shutil + backup_file = self._get_backup_file(backup_date) + config_file = self.get_file() + + if mode == 'overwrite': + config_file.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(backup_file, config_file) + elif mode == 'merge': + backup_data = self.read_config_file(backup_file) + current_data = self.read_config_file() if config_file.is_file() else dict(channels=[], version=0) + + current_dirs = {ch.get('directory') for ch in current_data.get('channels', []) if ch.get('directory')} + merged_channels = list(current_data.get('channels', [])) + for ch in backup_data.get('channels', []): + if ch.get('directory') and ch['directory'] not in current_dirs: + merged_channels.append(ch) + + merged_data = dict( + channels=merged_channels, + version=current_data.get('version', 0) + 1, + ) + config_file.parent.mkdir(parents=True, exist_ok=True) + self.write_config_data(merged_data, config_file) + + self.import_config(send_events=send_events) + CHANNELS_CONFIG: ChannelsConfig = ChannelsConfig() TEST_CHANNELS_CONFIG: ChannelsConfig = None diff --git a/modules/videos/test/test_common.py b/modules/videos/test/test_common.py index 2d32d3b0..d8f35acb 100644 --- a/modules/videos/test/test_common.py +++ b/modules/videos/test/test_common.py @@ -173,7 +173,7 @@ async def test_import_channel_downloads(await_switches, test_session, channel_fa channels_config = get_channels_config() update_channel_config(channels_config, 'foo', {'downloads': [ - {'url': 'https://example.com/channel1', 'frequency': DownloadFrequency.weekly} + {'url': 'https://example.com/channel1', 'frequency': DownloadFrequency.weekly.value} ]}) await await_switches() diff --git a/wrolpi/common.py b/wrolpi/common.py index f48eeefc..d67b08b2 100644 --- a/wrolpi/common.py +++ b/wrolpi/common.py @@ -449,6 +449,9 @@ def get_media_directory() -> Path: return MEDIA_DIRECTORY +DB_CONFIG_FILE_NAMES = {'tags.yaml', 'channels.yaml', 'domains.yaml', 'download_manager.yaml', 'inventories.yaml'} + + class ConfigFile: """ This is used to keep the DB and config files in sync. Importing the config reads the config from file, then @@ -491,11 +494,13 @@ class ConfigFile: return f'<{self.__class__.__name__} file={self.get_file()}>' def config_status(self) -> dict: + has_backup_import = self.file_name in DB_CONFIG_FILE_NAMES d = dict( file_name=self.file_name, rel_path=get_relative_to_media_directory(self.get_file()), successful_import=self.successful_import, valid=self.is_valid(), + has_backup_import=has_backup_import, ) return d @@ -532,7 +537,7 @@ class ConfigFile: def read_config_file(self, file: pathlib.Path = None) -> dict: file = file or self.get_file() with file.open('rt') as fh: - config_data = yaml.load(fh, Loader=yaml.Loader) + config_data = yaml.load(fh, Loader=yaml.CSafeLoader) if not isinstance(config_data, dict): raise InvalidConfig(f'Config file is invalid: {file}') return config_data @@ -546,6 +551,53 @@ class ConfigFile: path = path.with_name(name) return path + def get_backup_dates(self) -> list: + """Scan config/backup/ for backup files matching this config, return sorted dates (newest first).""" + backup_dir = get_media_directory() / 'config/backup' + if not backup_dir.is_dir(): + return [] + stem = pathlib.Path(self.file_name).stem + suffix = pathlib.Path(self.file_name).suffix + dates = [] + for f in backup_dir.iterdir(): + if f.is_file() and f.name.startswith(f'{stem}-') and f.name.endswith(suffix): + # Extract date string between stem- and suffix + date_str = f.name[len(stem) + 1:-len(suffix)] + if len(date_str) == 8 and date_str.isdigit(): + dates.append(date_str) + dates.sort(reverse=True) + return dates + + def _get_backup_file(self, backup_date: str) -> pathlib.Path: + """Return path to a specific backup file.""" + stem = pathlib.Path(self.file_name).stem + suffix = pathlib.Path(self.file_name).suffix + return get_media_directory() / f'config/backup/{stem}-{backup_date}{suffix}' + + + def preview_backup_import(self, backup_date: str, mode: str) -> dict: + """Preview what a backup import would do. Subclasses override this.""" + raise NotImplementedError(f'{self.__class__.__name__} does not support backup import') + + def _preserve_current_config(self): + """Back up the current config file to today's backup slot before a restore overwrites it. + + This ensures the user can undo a backup restore by restoring today's backup. + If today's backup already exists (from an earlier save), it is not overwritten. + """ + config_file = self.get_file() + if not config_file.is_file(): + return + todays_backup = self._get_backup_filename() + if todays_backup.is_file(): + return + todays_backup.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(config_file, todays_backup) + + def import_backup(self, backup_date: str, mode: str, send_events: bool = False): + """Import a backup file. Subclasses override this.""" + raise NotImplementedError(f'{self.__class__.__name__} does not support backup import') + def save(self, file: pathlib.Path = None, send_events: bool = False, overwrite: bool = False): """ Write this config to its file. @@ -612,8 +664,19 @@ class ConfigFile: raise e def write_config_data(self, config: dict, config_file: pathlib.Path): + from decimal import Decimal + + class _ConfigDumper(yaml.CSafeDumper): + """CSafeDumper that converts Decimal to str. All other Python objects are rejected.""" + pass + + _ConfigDumper.add_representer(Decimal, lambda dumper, data: dumper.represent_str(str(data))) + with config_file.open('wt') as fh: - yaml.dump(config, fh, width=self.width, sort_keys=True) + try: + yaml.dump(config, fh, Dumper=_ConfigDumper, width=self.width, sort_keys=True) + except yaml.representer.RepresenterError as e: + raise ValueError(f'Config contains a Python object that cannot be serialized: {e}') from e # Wait for data to be written before releasing lock. fh.flush() os.fsync(fh.fileno()) diff --git a/wrolpi/config_api.py b/wrolpi/config_api.py index 0a71c92a..357e8f93 100644 --- a/wrolpi/config_api.py +++ b/wrolpi/config_api.py @@ -4,7 +4,7 @@ from sanic_ext.extensions.openapi import openapi from wrolpi import config_schema from wrolpi.api_utils import json_response -from wrolpi.common import get_all_configs, get_config_by_file_name +from wrolpi.common import get_all_configs, get_config_by_file_name, DB_CONFIG_FILE_NAMES from wrolpi.common import logger from wrolpi.errors import InvalidConfig @@ -70,3 +70,60 @@ def post_config_dump(_: Request, body: config_schema.ConfigsRequest): raise InvalidConfig(f'Failed to dump config {body.file_name}') return response.empty() + + +@config_bp.get('/backups') +@openapi.description('Get available backup dates for a config file.') +@openapi.parameter('file_name', str, location='query') +def get_config_backups(request: Request): + file_name = request.args.get('file_name') + if not file_name: + raise InvalidConfig('file_name is required') + config = get_config_by_file_name(file_name) + if file_name not in DB_CONFIG_FILE_NAMES: + raise InvalidConfig(f'{file_name} does not support backup import') + dates = config.get_backup_dates() + return json_response(dict(dates=dates)) + + +@config_bp.post('/backup/preview') +@openapi.definition( + description='Preview what a backup import would change.', + body=config_schema.ConfigBackupPreviewRequest, + validate=True, +) +def post_config_backup_preview(_: Request, body: config_schema.ConfigBackupPreviewRequest): + if body.mode not in ('merge', 'overwrite'): + raise InvalidConfig('mode must be "merge" or "overwrite"') + config = get_config_by_file_name(body.file_name) + if body.file_name not in DB_CONFIG_FILE_NAMES: + raise InvalidConfig(f'{body.file_name} does not support backup import') + backup_file = config._get_backup_file(body.backup_date) + if not backup_file.is_file(): + raise InvalidConfig(f'Backup file not found for date {body.backup_date}') + preview = config.preview_backup_import(body.backup_date, body.mode) + return json_response(dict(preview=preview)) + + +@config_bp.post('/backup/import') +@openapi.definition( + description='Import a backup config file.', + body=config_schema.ConfigBackupImportRequest, + validate=True, +) +def post_config_backup_import(_: Request, body: config_schema.ConfigBackupImportRequest): + if body.mode not in ('merge', 'overwrite'): + raise InvalidConfig('mode must be "merge" or "overwrite"') + config = get_config_by_file_name(body.file_name) + if body.file_name not in DB_CONFIG_FILE_NAMES: + raise InvalidConfig(f'{body.file_name} does not support backup import') + backup_file = config._get_backup_file(body.backup_date) + if not backup_file.is_file(): + raise InvalidConfig(f'Backup file not found for date {body.backup_date}') + try: + config.import_backup(body.backup_date, body.mode, send_events=True) + except Exception as e: + logger.error(f'Failed to import backup: {body.file_name} {body.backup_date}', exc_info=e) + raise InvalidConfig(f'Failed to import backup {body.file_name}') + + return response.empty() diff --git a/wrolpi/config_schema.py b/wrolpi/config_schema.py index f713c8df..f23a7644 100644 --- a/wrolpi/config_schema.py +++ b/wrolpi/config_schema.py @@ -20,3 +20,17 @@ class ConfigsRequest: @dataclass class ConfigUpdateRequest: config: dict + + +@dataclass +class ConfigBackupPreviewRequest: + file_name: str + backup_date: str + mode: str + + +@dataclass +class ConfigBackupImportRequest: + file_name: str + backup_date: str + mode: str diff --git a/wrolpi/downloader.py b/wrolpi/downloader.py index cf997570..a9c07615 100644 --- a/wrolpi/downloader.py +++ b/wrolpi/downloader.py @@ -1552,6 +1552,78 @@ class DownloadManagerConfig(ConfigFile): self.successful_import = True + def preview_backup_import(self, backup_date: str, mode: str) -> dict: + backup_file = self._get_backup_file(backup_date) + backup_data = self.read_config_file(backup_file) + current_data = self.read_config_file() if self.get_file().is_file() else dict(downloads=[], version=0) + + backup_downloads = backup_data.get('downloads', []) + current_downloads = current_data.get('downloads', []) + + current_urls = {dl.get('url') for dl in current_downloads if dl.get('url')} + backup_urls = {dl.get('url') for dl in backup_downloads if dl.get('url')} + + add = [] + remove = [] + unchanged = 0 + + for dl in backup_downloads: + url = dl.get('url') + if not url: + continue + # In merge mode, skip once-downloads (no frequency) + if mode == 'merge' and not dl.get('frequency'): + continue + if url not in current_urls: + add.append(dict(type='download', url=url, downloader=dl.get('downloader', ''))) + else: + unchanged += 1 + if mode == 'overwrite': + current_url_to_dl = {dl.get('url'): dl for dl in current_downloads} + for url in sorted(current_urls - backup_urls): + dl = current_url_to_dl[url] + remove.append(dict(type='download', url=url, downloader=dl.get('downloader', ''))) + + return dict(mode=mode, add=add, remove=remove, unchanged=unchanged) + + def import_backup(self, backup_date: str, mode: str, send_events: bool = False): + self._preserve_current_config() + import shutil + backup_file = self._get_backup_file(backup_date) + config_file = self.get_file() + + if mode == 'overwrite': + config_file.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(backup_file, config_file) + elif mode == 'merge': + backup_data = self.read_config_file(backup_file) + current_data = self.read_config_file() if config_file.is_file() else dict(downloads=[], skip_urls=[], version=0) + + current_urls = {dl.get('url') for dl in current_data.get('downloads', []) if dl.get('url')} + merged_downloads = list(current_data.get('downloads', [])) + for dl in backup_data.get('downloads', []): + url = dl.get('url') + # Only merge recurring downloads + if url and url not in current_urls and dl.get('frequency'): + merged_downloads.append(dl) + + # Merge skip_urls + current_skip = set(current_data.get('skip_urls', [])) + merged_skip = list(current_data.get('skip_urls', [])) + for url in backup_data.get('skip_urls', []): + if url not in current_skip: + merged_skip.append(url) + + merged_data = dict( + downloads=merged_downloads, + skip_urls=merged_skip, + version=current_data.get('version', 0) + 1, + ) + config_file.parent.mkdir(parents=True, exist_ok=True) + self.write_config_data(merged_data, config_file) + + self.import_config(send_events=send_events) + DOWNLOAD_MANAGER_CONFIG: DownloadManagerConfig = DownloadManagerConfig() TEST_DOWNLOAD_MANAGER_CONFIG: DownloadManagerConfig = None diff --git a/wrolpi/tags.py b/wrolpi/tags.py index adb9de66..3111b120 100644 --- a/wrolpi/tags.py +++ b/wrolpi/tags.py @@ -514,6 +514,111 @@ class TagsConfig(ConfigFile): Events.send_config_import_failed(message) raise + def preview_backup_import(self, backup_date: str, mode: str) -> dict: + backup_file = self._get_backup_file(backup_date) + backup_data = self.read_config_file(backup_file) + current_data = self.read_config_file() if self.get_file().is_file() else dict(tags={}, tag_files=[], tag_zims=[]) + + backup_tags = backup_data.get('tags', {}) + current_tags = current_data.get('tags', {}) + backup_tag_files = backup_data.get('tag_files', []) + current_tag_files = current_data.get('tag_files', []) + backup_tag_zims = backup_data.get('tag_zims', []) + current_tag_zims = current_data.get('tag_zims', []) + + # Build identity sets + current_tag_names = set(current_tags.keys()) + current_tf_keys = {(tf[0], tf[1]) for tf in current_tag_files if len(tf) >= 2} + current_tz_keys = {(tz[0], tz[1], tz[2]) for tz in current_tag_zims if len(tz) >= 3} + + backup_tag_names = set(backup_tags.keys()) + backup_tf_keys = {(tf[0], tf[1]) for tf in backup_tag_files if len(tf) >= 2} + backup_tz_keys = {(tz[0], tz[1], tz[2]) for tz in backup_tag_zims if len(tz) >= 3} + + add = [] + remove = [] + unchanged = 0 + + # Tags + for name in sorted(backup_tag_names): + if name not in current_tag_names: + add.append(dict(type='tag', name=name)) + else: + unchanged += 1 + if mode == 'overwrite': + for name in sorted(current_tag_names - backup_tag_names): + remove.append(dict(type='tag', name=name)) + + # Tag files + for tf in backup_tag_files: + if len(tf) >= 2: + key = (tf[0], tf[1]) + if key not in current_tf_keys: + add.append(dict(type='tag_file', tag=tf[0], path=tf[1])) + else: + unchanged += 1 + if mode == 'overwrite': + for key in sorted(current_tf_keys - backup_tf_keys): + remove.append(dict(type='tag_file', tag=key[0], path=key[1])) + + # Tag zims + for tz in backup_tag_zims: + if len(tz) >= 3: + key = (tz[0], tz[1], tz[2]) + if key not in current_tz_keys: + add.append(dict(type='tag_zim', tag=tz[0], zim=tz[1], entry=tz[2])) + else: + unchanged += 1 + if mode == 'overwrite': + for key in sorted(current_tz_keys - backup_tz_keys): + remove.append(dict(type='tag_zim', tag=key[0], zim=key[1], entry=key[2])) + + return dict(mode=mode, add=add, remove=remove, unchanged=unchanged) + + def import_backup(self, backup_date: str, mode: str, send_events: bool = False): + self._preserve_current_config() + import shutil + backup_file = self._get_backup_file(backup_date) + config_file = self.get_file() + + if mode == 'overwrite': + config_file.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(backup_file, config_file) + elif mode == 'merge': + backup_data = self.read_config_file(backup_file) + current_data = self.read_config_file() if config_file.is_file() else dict(tags={}, tag_files=[], tag_zims=[], version=0) + + # Merge tags: add missing tags only + merged_tags = dict(current_data.get('tags', {})) + for name, value in backup_data.get('tags', {}).items(): + if name not in merged_tags: + merged_tags[name] = value + + # Merge tag_files: add missing by (tag_name, path) + current_tf_keys = {(tf[0], tf[1]) for tf in current_data.get('tag_files', []) if len(tf) >= 2} + merged_tag_files = list(current_data.get('tag_files', [])) + for tf in backup_data.get('tag_files', []): + if len(tf) >= 2 and (tf[0], tf[1]) not in current_tf_keys: + merged_tag_files.append(tf) + + # Merge tag_zims: add missing by (tag_name, zim_path, entry) + current_tz_keys = {(tz[0], tz[1], tz[2]) for tz in current_data.get('tag_zims', []) if len(tz) >= 3} + merged_tag_zims = list(current_data.get('tag_zims', [])) + for tz in backup_data.get('tag_zims', []): + if len(tz) >= 3 and (tz[0], tz[1], tz[2]) not in current_tz_keys: + merged_tag_zims.append(tz) + + merged_data = dict( + tags=merged_tags, + tag_files=merged_tag_files, + tag_zims=merged_tag_zims, + version=current_data.get('version', 0) + 1, + ) + config_file.parent.mkdir(parents=True, exist_ok=True) + self.write_config_data(merged_data, config_file) + + self.import_config(send_events=send_events) + TAGS_CONFIG: TagsConfig = TagsConfig() TEST_TAGS_CONFIG: TagsConfig = None # noqa diff --git a/wrolpi/test/test_config_backup_import.py b/wrolpi/test/test_config_backup_import.py new file mode 100644 index 00000000..53285372 --- /dev/null +++ b/wrolpi/test/test_config_backup_import.py @@ -0,0 +1,1033 @@ +"""Tests for the backup config import feature.""" +import pathlib +from http import HTTPStatus + +import pytest +import yaml + +from wrolpi.common import get_media_directory + + +def _write_yaml(path: pathlib.Path, data: dict): + path.parent.mkdir(parents=True, exist_ok=True) + with path.open('wt') as fh: + yaml.dump(data, fh) + + +def _make_backup(test_directory, file_name, backup_date, data): + stem = pathlib.Path(file_name).stem + suffix = pathlib.Path(file_name).suffix + backup_dir = test_directory / 'config' / 'backup' + backup_dir.mkdir(parents=True, exist_ok=True) + backup_file = backup_dir / f'{stem}-{backup_date}{suffix}' + _write_yaml(backup_file, data) + return backup_file + + +class TestGetBackupDates: + + def test_get_backup_dates(self, test_directory, test_tags_config): + from wrolpi.tags import get_tags_config + config = get_tags_config() + + # No backup directory yet + assert config.get_backup_dates() == [] + + # Create some backups + backup_dir = test_directory / 'config' / 'backup' + backup_dir.mkdir(parents=True, exist_ok=True) + (backup_dir / 'tags-20260101.yaml').write_text('tags: {}\nversion: 1') + (backup_dir / 'tags-20260305.yaml').write_text('tags: {}\nversion: 2') + (backup_dir / 'tags-20260201.yaml').write_text('tags: {}\nversion: 3') + # Other config backup should be ignored + (backup_dir / 'channels-20260101.yaml').write_text('channels: []\nversion: 1') + + dates = config.get_backup_dates() + assert dates == ['20260305', '20260201', '20260101'] + + def test_get_backup_dates_empty_dir(self, test_directory, test_tags_config): + from wrolpi.tags import get_tags_config + config = get_tags_config() + (test_directory / 'config' / 'backup').mkdir(parents=True, exist_ok=True) + assert config.get_backup_dates() == [] + + +class TestTagsBackupImport: + + def test_preview_merge(self, test_directory, test_tags_config): + from wrolpi.tags import get_tags_config + config = get_tags_config() + + # Write current config + current = dict( + tags={'news': {'color': '#FF0000'}, 'tech': {'color': '#00FF00'}}, + tag_files=[['news', 'videos/ep1.mp4', '2026-01-01T00:00:00']], + tag_zims=[['news', 'wiki.zim', '/A/Test', '2026-01-01T00:00:00']], + version=1, + ) + _write_yaml(config.get_file(), current) + + # Write backup with extra items + backup = dict( + tags={'news': {'color': '#0000FF'}, 'survival': {'color': '#AABB00'}}, + tag_files=[ + ['news', 'videos/ep1.mp4', '2026-01-01T00:00:00'], + ['survival', 'videos/ep2.mp4', '2026-02-01T00:00:00'], + ], + tag_zims=[ + ['news', 'wiki.zim', '/A/Test', '2026-01-01T00:00:00'], + ['survival', 'wiki.zim', '/A/Other', '2026-02-01T00:00:00'], + ], + version=1, + ) + _make_backup(test_directory, 'tags.yaml', '20260301', backup) + + preview = config.preview_backup_import('20260301', 'merge') + assert preview['mode'] == 'merge' + assert len(preview['add']) == 3 # tag:survival, tag_file:survival/ep2, tag_zim:survival/Other + assert preview['remove'] == [] + assert preview['unchanged'] == 3 # tag:news, tag_file:news/ep1, tag_zim:news/wiki/Test + + # Verify specific items + add_types = {(i['type'], i.get('name', i.get('tag', ''))) for i in preview['add']} + assert ('tag', 'survival') in add_types + assert ('tag_file', 'survival') in add_types + assert ('tag_zim', 'survival') in add_types + + def test_preview_overwrite(self, test_directory, test_tags_config): + from wrolpi.tags import get_tags_config + config = get_tags_config() + + current = dict( + tags={'news': {'color': '#FF0000'}, 'tech': {'color': '#00FF00'}}, + tag_files=[], + tag_zims=[], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + tags={'news': {'color': '#0000FF'}}, + tag_files=[], + tag_zims=[], + version=1, + ) + _make_backup(test_directory, 'tags.yaml', '20260301', backup) + + preview = config.preview_backup_import('20260301', 'overwrite') + assert preview['mode'] == 'overwrite' + assert preview['add'] == [] + assert len(preview['remove']) == 1 # tech tag removed + assert preview['remove'][0] == {'type': 'tag', 'name': 'tech'} + assert preview['unchanged'] == 1 # news + + @pytest.mark.asyncio + async def test_import_merge(self, test_directory, test_tags_config, test_session, async_client): + from wrolpi.tags import get_tags_config, Tag + config = get_tags_config() + + # Write current config with one tag + current = dict(tags={'news': {'color': '#FF0000'}}, tag_files=[], tag_zims=[], version=1) + _write_yaml(config.get_file(), current) + + # Write backup with two tags + backup = dict( + tags={'news': {'color': '#0000FF'}, 'survival': {'color': '#AABB00'}}, + tag_files=[], tag_zims=[], version=1, + ) + _make_backup(test_directory, 'tags.yaml', '20260301', backup) + + config.import_backup('20260301', 'merge') + + # Read the merged config file - should have both tags + merged = config.read_config_file() + assert 'news' in merged['tags'] + assert 'survival' in merged['tags'] + # Merge doesn't change existing tag colors + assert merged['tags']['news']['color'] == '#FF0000' + + @pytest.mark.asyncio + async def test_import_overwrite(self, test_directory, test_tags_config, test_session, async_client): + from wrolpi.tags import get_tags_config, Tag + config = get_tags_config() + + # Write current config with two tags + current = dict( + tags={'news': {'color': '#FF0000'}, 'tech': {'color': '#00FF00'}}, + tag_files=[], tag_zims=[], version=1, + ) + _write_yaml(config.get_file(), current) + + # Write backup with only one tag + backup = dict(tags={'news': {'color': '#0000FF'}}, tag_files=[], tag_zims=[], version=1) + _make_backup(test_directory, 'tags.yaml', '20260301', backup) + + config.import_backup('20260301', 'overwrite') + + # Config file should be exact copy of backup + overwritten = config.read_config_file() + assert list(overwritten['tags'].keys()) == ['news'] + assert overwritten['tags']['news']['color'] == '#0000FF' + + +class TestDownloadsBackupImport: + + def test_preview_overwrite(self, test_directory, test_download_manager_config): + from wrolpi.downloader import get_download_manager_config + config = get_download_manager_config() + + current = dict( + downloads=[ + dict(url='http://existing.com/feed', downloader='rss', frequency=86400, status='complete'), + dict(url='http://other.com/feed', downloader='video_channel', frequency=2592000, status='new'), + ], + skip_urls=['http://skip.com'], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + downloads=[ + dict(url='http://existing.com/feed', downloader='rss', frequency=86400, status='complete'), + ], + skip_urls=[], + version=1, + ) + _make_backup(test_directory, 'download_manager.yaml', '20260301', backup) + + preview = config.preview_backup_import('20260301', 'overwrite') + assert preview['mode'] == 'overwrite' + assert len(preview['remove']) == 1 + assert preview['remove'][0]['url'] == 'http://other.com/feed' + assert preview['unchanged'] == 1 + assert preview['add'] == [] + + def test_import_overwrite(self, test_directory, test_download_manager_config, async_client): + from wrolpi.downloader import get_download_manager_config + config = get_download_manager_config() + + _dl = lambda url, freq=None, **kw: dict( + url=url, downloader='rss', frequency=freq, status='new', + destination=None, sub_downloader=None, settings=None, + tag_names=None, last_successful_download=None, next_download=None, **kw, + ) + + current = dict( + downloads=[_dl('http://existing.com/feed', 86400), _dl('http://other.com/feed', 2592000)], + skip_urls=['http://skip.com'], + version=5, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + downloads=[_dl('http://existing.com/feed', 86400)], + skip_urls=[], + version=3, + ) + _make_backup(test_directory, 'download_manager.yaml', '20260301', backup) + + config.import_backup('20260301', 'overwrite') + + overwritten = config.read_config_file() + assert len(overwritten['downloads']) == 1 + assert overwritten['downloads'][0]['url'] == 'http://existing.com/feed' + assert overwritten['skip_urls'] == [] + + def test_preview_merge_skips_once_downloads(self, test_directory, test_download_manager_config): + from wrolpi.downloader import get_download_manager_config + config = get_download_manager_config() + + current = dict(downloads=[], skip_urls=[], version=1) + _write_yaml(config.get_file(), current) + + backup = dict( + downloads=[ + dict(url='http://example.com/feed', downloader='rss', frequency=86400, status='complete'), + dict(url='http://example.com/once', downloader='archive', status='complete'), + ], + skip_urls=[], version=1, + ) + _make_backup(test_directory, 'download_manager.yaml', '20260301', backup) + + preview = config.preview_backup_import('20260301', 'merge') + # Only the recurring download should show + assert len(preview['add']) == 1 + assert preview['add'][0]['url'] == 'http://example.com/feed' + + @pytest.mark.asyncio + async def test_import_merge(self, test_directory, test_download_manager_config, async_client): + from wrolpi.downloader import get_download_manager_config + config = get_download_manager_config() + + _dl = lambda url, freq=None, **kw: dict( + url=url, downloader='rss', frequency=freq, status='new', + destination=None, sub_downloader=None, settings=None, + tag_names=None, last_successful_download=None, next_download=None, **kw, + ) + + current = dict(downloads=[_dl('http://existing.com', 86400)], skip_urls=[], version=1) + _write_yaml(config.get_file(), current) + + backup = dict( + downloads=[ + _dl('http://new.com/feed', 86400), + _dl('http://once.com'), + ], + skip_urls=['http://skip.com'], version=1, + ) + _make_backup(test_directory, 'download_manager.yaml', '20260301', backup) + + config.import_backup('20260301', 'merge') + + merged = config.read_config_file() + urls = [dl['url'] for dl in merged['downloads']] + assert 'http://existing.com' in urls + assert 'http://new.com/feed' in urls + # Once-download should not be merged + assert 'http://once.com' not in urls + assert 'http://skip.com' in merged['skip_urls'] + + +class TestChannelsBackupImport: + + def test_preview_overwrite(self, test_directory, test_channels_config): + from modules.videos.lib import get_channels_config + config = get_channels_config() + + current = dict( + channels=[ + dict(name='Channel A', directory='videos/channel_a', download_frequency=86400), + dict(name='Channel B', directory='videos/channel_b', download_frequency=86400), + ], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + channels=[dict(name='Channel A', directory='videos/channel_a', download_frequency=86400)], + version=1, + ) + _make_backup(test_directory, 'channels.yaml', '20260301', backup) + + preview = config.preview_backup_import('20260301', 'overwrite') + assert preview['mode'] == 'overwrite' + assert len(preview['remove']) == 1 + assert preview['remove'][0]['directory'] == 'videos/channel_b' + assert preview['unchanged'] == 1 + assert preview['add'] == [] + + def test_import_overwrite(self, test_directory, test_channels_config, async_client, test_download_manager_config): + from modules.videos.lib import get_channels_config + config = get_channels_config() + + current = dict( + channels=[ + dict(name='Channel A', directory='videos/channel_a', download_frequency=86400), + dict(name='Channel B', directory='videos/channel_b', download_frequency=86400), + ], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + channels=[dict(name='Channel A', directory='videos/channel_a', download_frequency=86400)], + version=1, + ) + _make_backup(test_directory, 'channels.yaml', '20260301', backup) + + config.import_backup('20260301', 'overwrite') + + overwritten = config.read_config_file() + assert len(overwritten['channels']) == 1 + assert overwritten['channels'][0]['directory'] == 'videos/channel_a' + + def test_preview_merge(self, test_directory, test_channels_config): + from modules.videos.lib import get_channels_config + config = get_channels_config() + + current = dict( + channels=[dict(name='Channel A', directory='videos/channel_a', download_frequency=86400)], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + channels=[ + dict(name='Channel A', directory='videos/channel_a', download_frequency=86400), + dict(name='Channel B', directory='videos/channel_b', download_frequency=86400), + ], + version=1, + ) + _make_backup(test_directory, 'channels.yaml', '20260301', backup) + + preview = config.preview_backup_import('20260301', 'merge') + assert len(preview['add']) == 1 + assert preview['add'][0]['directory'] == 'videos/channel_b' + assert preview['unchanged'] == 1 + + @pytest.mark.asyncio + async def test_import_merge(self, test_directory, test_channels_config, async_client, test_download_manager_config): + from modules.videos.lib import get_channels_config + config = get_channels_config() + + current = dict( + channels=[dict(name='Channel A', directory='videos/channel_a', download_frequency=86400)], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + channels=[ + dict(name='Channel B', directory='videos/channel_b', download_frequency=86400), + ], + version=1, + ) + _make_backup(test_directory, 'channels.yaml', '20260301', backup) + + config.import_backup('20260301', 'merge') + + merged = config.read_config_file() + dirs = [ch['directory'] for ch in merged['channels']] + assert 'videos/channel_a' in dirs + assert 'videos/channel_b' in dirs + + +class TestDomainsBackupImport: + + def test_preview_merge(self, test_directory): + from modules.archive.lib import get_domains_config + config = get_domains_config() + + current = dict( + collections=[dict(name='example.com', kind='domain')], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + collections=[ + dict(name='example.com', kind='domain'), + dict(name='newsite.org', kind='domain'), + ], + version=1, + ) + _make_backup(get_media_directory(), 'domains.yaml', '20260301', backup) + + preview = config.preview_backup_import('20260301', 'merge') + assert preview['mode'] == 'merge' + assert len(preview['add']) == 1 + assert preview['add'][0]['name'] == 'newsite.org' + assert preview['remove'] == [] + assert preview['unchanged'] == 1 + + @pytest.mark.asyncio + async def test_import_merge(self, test_directory, test_session, async_client): + from modules.archive.lib import get_domains_config + config = get_domains_config() + + current = dict( + collections=[dict(name='example.com', kind='domain')], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + collections=[ + dict(name='example.com', kind='domain'), + dict(name='newsite.org', kind='domain'), + ], + version=1, + ) + _make_backup(get_media_directory(), 'domains.yaml', '20260301', backup) + + config.import_backup('20260301', 'merge') + + merged = config.read_config_file() + names = [c['name'] for c in merged['collections']] + assert 'example.com' in names + assert 'newsite.org' in names + + @pytest.mark.asyncio + async def test_import_overwrite(self, test_directory, test_session, async_client): + from modules.archive.lib import get_domains_config + config = get_domains_config() + + current = dict( + collections=[ + dict(name='example.com', kind='domain'), + dict(name='test.org', kind='domain'), + ], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + collections=[dict(name='example.com', kind='domain')], + version=1, + ) + _make_backup(get_media_directory(), 'domains.yaml', '20260301', backup) + + config.import_backup('20260301', 'overwrite') + + overwritten = config.read_config_file() + assert len(overwritten['collections']) == 1 + assert overwritten['collections'][0]['name'] == 'example.com' + + def test_preview_overwrite(self, test_directory): + from modules.archive.lib import get_domains_config + config = get_domains_config() + + current = dict( + collections=[ + dict(name='example.com', kind='domain'), + dict(name='test.org', kind='domain'), + ], + version=1, + ) + config_file = config.get_file() + _write_yaml(config_file, current) + + backup = dict( + collections=[dict(name='example.com', kind='domain')], + version=1, + ) + _make_backup(get_media_directory(), 'domains.yaml', '20260301', backup) + + preview = config.preview_backup_import('20260301', 'overwrite') + assert len(preview['remove']) == 1 + assert preview['remove'][0]['name'] == 'test.org' + assert preview['unchanged'] == 1 + + +class TestInventoriesBackupImport: + + def test_preview_overwrite(self, test_directory): + from modules.inventory.common import get_inventories_config + config = get_inventories_config() + + current = dict( + inventories=[ + dict(name='Food', created_at='2026-01-01', deleted_at=None, items=[]), + dict(name='Tools', created_at='2026-01-01', deleted_at=None, items=[]), + ], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + inventories=[dict(name='Food', created_at='2026-01-01', deleted_at=None, items=[])], + version=1, + ) + _make_backup(get_media_directory(), 'inventories.yaml', '20260301', backup) + + preview = config.preview_backup_import('20260301', 'overwrite') + assert preview['mode'] == 'overwrite' + assert len(preview['remove']) == 1 + assert preview['remove'][0]['name'] == 'Tools' + assert preview['unchanged'] == 1 + assert preview['add'] == [] + + @pytest.mark.asyncio + async def test_import_merge(self, test_directory, test_session, async_client): + from modules.inventory.common import get_inventories_config + config = get_inventories_config() + + current = dict( + inventories=[dict(id=1, name='Food', created_at='2026-01-01', deleted_at=None, items=[])], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + inventories=[ + dict(id=1, name='Food', created_at='2026-01-01', deleted_at=None, items=[]), + dict(id=2, name='Medical', created_at='2026-01-01', deleted_at=None, items=[]), + ], + version=1, + ) + _make_backup(get_media_directory(), 'inventories.yaml', '20260301', backup) + + config.import_backup('20260301', 'merge') + + merged = config.read_config_file() + names = [inv['name'] for inv in merged['inventories']] + assert 'Food' in names + assert 'Medical' in names + + @pytest.mark.asyncio + async def test_import_overwrite(self, test_directory, test_session, async_client): + from modules.inventory.common import get_inventories_config + config = get_inventories_config() + + current = dict( + inventories=[ + dict(id=1, name='Food', created_at='2026-01-01', deleted_at=None, items=[]), + dict(id=2, name='Tools', created_at='2026-01-01', deleted_at=None, items=[]), + ], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + inventories=[dict(id=1, name='Food', created_at='2026-01-01', deleted_at=None, items=[])], + version=1, + ) + _make_backup(get_media_directory(), 'inventories.yaml', '20260301', backup) + + config.import_backup('20260301', 'overwrite') + + overwritten = config.read_config_file() + assert len(overwritten['inventories']) == 1 + assert overwritten['inventories'][0]['name'] == 'Food' + + def test_preview_merge(self, test_directory): + from modules.inventory.common import get_inventories_config + config = get_inventories_config() + + current = dict( + inventories=[dict(name='Food', created_at='2026-01-01', deleted_at=None, items=[])], + version=1, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + inventories=[ + dict(name='Food', created_at='2026-01-01', deleted_at=None, items=[]), + dict(name='Medical', created_at='2026-01-01', deleted_at=None, items=[]), + ], + version=1, + ) + _make_backup(get_media_directory(), 'inventories.yaml', '20260301', backup) + + preview = config.preview_backup_import('20260301', 'merge') + assert len(preview['add']) == 1 + assert preview['add'][0]['name'] == 'Medical' + assert preview['unchanged'] == 1 + + +class TestImportBackupPreservesCurrentConfig: + """Restoring a backup should preserve the current config as today's backup so the user can undo the restore.""" + + @pytest.mark.asyncio + async def test_import_preserves_current_config(self, test_directory, test_tags_config, test_session, async_client): + from wrolpi.tags import get_tags_config + config = get_tags_config() + + current = dict( + tags={'news': {'color': '#FF0000'}, 'tech': {'color': '#00FF00'}}, + tag_files=[], tag_zims=[], version=5, + ) + _write_yaml(config.get_file(), current) + + backup = dict(tags={'news': {'color': '#0000FF'}}, tag_files=[], tag_zims=[], version=3) + _make_backup(test_directory, 'tags.yaml', '20260101', backup) + + todays_backup = config._get_backup_filename() + assert not todays_backup.is_file() + + # Overwrite should create today's backup with the original config. + config.import_backup('20260101', 'overwrite') + assert todays_backup.is_file() + preserved = yaml.safe_load(todays_backup.read_text()) + assert 'tech' in preserved['tags'] + assert preserved['version'] == 5 + + # A second import should not clobber today's backup. + backup2 = dict(tags={'survival': {'color': '#AABB00'}}, tag_files=[], tag_zims=[], version=1) + _make_backup(test_directory, 'tags.yaml', '20260102', backup2) + config.import_backup('20260102', 'overwrite') + preserved = yaml.safe_load(todays_backup.read_text()) + assert 'tech' in preserved['tags'], 'Today\'s backup should still contain the original config' + assert preserved['version'] == 5 + + + +class TestConfigStatusIncludesBackupInfo: + + def test_db_config_has_backup_info(self, test_directory, test_tags_config): + from wrolpi.tags import get_tags_config + config = get_tags_config() + status = config.config_status() + assert status['has_backup_import'] is True + assert 'backup_dates' not in status + + def test_non_db_config_no_backup_info(self, test_directory, test_wrolpi_config): + from wrolpi.common import get_wrolpi_config + config = get_wrolpi_config() + status = config.config_status() + assert status['has_backup_import'] is False + assert 'backup_dates' not in status + + +class TestNotImplementedForNonDBConfigs: + + def test_preview_raises(self, test_directory, test_wrolpi_config): + from wrolpi.common import get_wrolpi_config + config = get_wrolpi_config() + with pytest.raises(NotImplementedError): + config.preview_backup_import('20260301', 'merge') + + def test_import_raises(self, test_directory, test_wrolpi_config): + from wrolpi.common import get_wrolpi_config + config = get_wrolpi_config() + with pytest.raises(NotImplementedError): + config.import_backup('20260301', 'merge') + + +@pytest.mark.asyncio +class TestBackupAPIEndpoints: + + async def test_get_backups(self, async_client, test_directory, test_tags_config): + from wrolpi.tags import get_tags_config + backup_dir = test_directory / 'config' / 'backup' + backup_dir.mkdir(parents=True, exist_ok=True) + (backup_dir / 'tags-20260301.yaml').write_text('tags: {}\nversion: 1') + + request, response = await async_client.get('/api/config/backups?file_name=tags.yaml') + assert response.status_code == HTTPStatus.OK + assert '20260301' in response.json['dates'] + + async def test_preview_endpoint(self, async_client, test_directory, test_tags_config): + # Write current config + from wrolpi.tags import get_tags_config + config = get_tags_config() + _write_yaml(config.get_file(), dict(tags={'news': {'color': '#FF0000'}}, tag_files=[], tag_zims=[], version=1)) + + # Write backup + _make_backup(test_directory, 'tags.yaml', '20260301', + dict(tags={'news': {'color': '#FF0000'}, 'tech': {'color': '#00FF00'}}, + tag_files=[], tag_zims=[], version=1)) + + body = dict(file_name='tags.yaml', backup_date='20260301', mode='merge') + request, response = await async_client.post('/api/config/backup/preview', json=body) + assert response.status_code == HTTPStatus.OK + assert 'preview' in response.json + assert len(response.json['preview']['add']) == 1 + + async def test_import_endpoint(self, async_client, test_directory, test_tags_config, test_session): + from wrolpi.tags import get_tags_config + config = get_tags_config() + _write_yaml(config.get_file(), dict(tags={'news': {'color': '#FF0000'}}, tag_files=[], tag_zims=[], version=1)) + _make_backup(test_directory, 'tags.yaml', '20260301', + dict(tags={'news': {'color': '#FF0000'}, 'tech': {'color': '#00FF00'}}, + tag_files=[], tag_zims=[], version=1)) + + body = dict(file_name='tags.yaml', backup_date='20260301', mode='merge') + request, response = await async_client.post('/api/config/backup/import', json=body) + assert response.status_code == HTTPStatus.NO_CONTENT + + async def test_invalid_mode(self, async_client, test_directory, test_tags_config): + body = dict(file_name='tags.yaml', backup_date='20260301', mode='invalid') + request, response = await async_client.post('/api/config/backup/preview', json=body) + assert response.status_code == HTTPStatus.BAD_REQUEST + + async def test_non_db_config_rejected(self, async_client, test_directory, test_wrolpi_config): + body = dict(file_name='wrolpi.yaml', backup_date='20260301', mode='merge') + request, response = await async_client.post('/api/config/backup/preview', json=body) + assert response.status_code == HTTPStatus.BAD_REQUEST + + async def test_missing_backup_rejected(self, async_client, test_directory, test_tags_config): + body = dict(file_name='tags.yaml', backup_date='99990101', mode='merge') + request, response = await async_client.post('/api/config/backup/preview', json=body) + assert response.status_code == HTTPStatus.BAD_REQUEST + + async def test_config_status_includes_backup_fields(self, async_client, test_directory, test_tags_config): + request, response = await async_client.get('/api/config') + assert response.status_code == HTTPStatus.OK + tags_status = response.json['configs']['tags.yaml'] + assert 'has_backup_import' in tags_status + assert 'backup_dates' not in tags_status + + +class TestPreviewWithRealisticData: + """Test preview logic with data modeled after real production backup files.""" + + def test_tags_merge_old_backup_no_tag_files(self, test_directory, test_tags_config): + """Old backup has same tags but no tag_files/tag_zims. Merge should show no changes.""" + from wrolpi.tags import get_tags_config + config = get_tags_config() + + tag_defs = {'News': {'color': '#FF0000'}, 'Tech': {'color': '#00FF00'}, 'Medical': {'color': '#0000FF'}} + + current = dict( + tags=tag_defs, + tag_files=[['News', 'file1.mp4', '2026-01-01T00:00:00'], ['Tech', 'file2.mp4', '2026-01-01T00:00:00']], + tag_zims=[['News', 'wiki.zim', 'home', '2026-01-01T00:00:00']], + version=41, + ) + _write_yaml(config.get_file(), current) + + # Old backup: same tags, empty tag_files/tag_zims (like tags-20251120) + backup = dict(tags=tag_defs, tag_files=[], tag_zims=[], version=1) + _make_backup(test_directory, 'tags.yaml', '20251120', backup) + + preview = config.preview_backup_import('20251120', 'merge') + assert preview['mode'] == 'merge' + assert preview['add'] == [] # Backup has nothing new + assert preview['remove'] == [] # Merge never removes + assert preview['unchanged'] == 3 # 3 tags match + + def test_tags_overwrite_old_backup_removes_tag_files(self, test_directory, test_tags_config): + """Overwrite with old backup should remove tag_files and tag_zims that only exist in current.""" + from wrolpi.tags import get_tags_config + config = get_tags_config() + + tag_defs = {'News': {'color': '#FF0000'}, 'Tech': {'color': '#00FF00'}} + current = dict( + tags=tag_defs, + tag_files=[['News', 'file1.mp4', '2026-01-01T00:00:00'], ['Tech', 'file2.mp4', '2026-01-01T00:00:00']], + tag_zims=[['News', 'wiki.zim', 'home', '2026-01-01T00:00:00']], + version=41, + ) + _write_yaml(config.get_file(), current) + + backup = dict(tags=tag_defs, tag_files=[], tag_zims=[], version=1) + _make_backup(test_directory, 'tags.yaml', '20251120', backup) + + preview = config.preview_backup_import('20251120', 'overwrite') + assert preview['add'] == [] + assert len(preview['remove']) == 3 # 2 tag_files + 1 tag_zim + assert preview['unchanged'] == 2 # 2 tags match + + remove_types = [r['type'] for r in preview['remove']] + assert remove_types.count('tag_file') == 2 + assert remove_types.count('tag_zim') == 1 + + def test_tags_identical_backup(self, test_directory, test_tags_config): + """Recent identical backup should show no changes in either mode.""" + from wrolpi.tags import get_tags_config + config = get_tags_config() + + data = dict( + tags={'News': {'color': '#FF0000'}}, + tag_files=[['News', 'file1.mp4', '2026-01-01T00:00:00']], + tag_zims=[['News', 'wiki.zim', 'home', '2026-01-01T00:00:00']], + version=41, + ) + _write_yaml(config.get_file(), data) + _make_backup(test_directory, 'tags.yaml', '20260307', data) + + for mode in ('merge', 'overwrite'): + preview = config.preview_backup_import('20260307', mode) + assert preview['add'] == [], f'{mode}: unexpected adds' + assert preview['remove'] == [], f'{mode}: unexpected removes' + assert preview['unchanged'] == 3, f'{mode}: wrong unchanged count' + + def test_domains_overwrite_removes_new_domain(self, test_directory): + """Backup missing a domain that was recently added. Overwrite shows it as removal.""" + from modules.archive.lib import get_domains_config + config = get_domains_config() + + current = dict( + collections=[ + dict(name='crosswalk.com', kind='domain', directory='archive/crosswalk.com'), + dict(name='wrolpi.org', kind='domain', directory='archive/wrolpi.org'), + dict(name='zerohedge.com', kind='domain', directory='archive/zerohedge.com'), + ], + version=32, + ) + _write_yaml(config.get_file(), current) + + # Backup from before zerohedge was added + backup = dict( + collections=[ + dict(name='crosswalk.com', kind='domain', directory='archive/crosswalk.com'), + dict(name='wrolpi.org', kind='domain', directory='archive/wrolpi.org'), + ], + version=31, + ) + _make_backup(get_media_directory(), 'domains.yaml', '20260218', backup) + + preview = config.preview_backup_import('20260218', 'overwrite') + assert preview['add'] == [] + assert len(preview['remove']) == 1 + assert preview['remove'][0]['name'] == 'zerohedge.com' + assert preview['unchanged'] == 2 + + def test_domains_merge_no_changes(self, test_directory): + """Merge with backup that is a subset of current should show no changes.""" + from modules.archive.lib import get_domains_config + config = get_domains_config() + + current = dict( + collections=[ + dict(name='crosswalk.com', kind='domain', directory='archive/crosswalk.com'), + dict(name='wrolpi.org', kind='domain', directory='archive/wrolpi.org'), + dict(name='zerohedge.com', kind='domain', directory='archive/zerohedge.com'), + ], + version=32, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + collections=[ + dict(name='crosswalk.com', kind='domain', directory='archive/crosswalk.com'), + dict(name='wrolpi.org', kind='domain', directory='archive/wrolpi.org'), + ], + version=31, + ) + _make_backup(get_media_directory(), 'domains.yaml', '20260218', backup) + + preview = config.preview_backup_import('20260218', 'merge') + assert preview['add'] == [] + assert preview['remove'] == [] + assert preview['unchanged'] == 2 + + def test_download_manager_merge_skips_once_downloads(self, test_directory, test_download_manager_config): + """Merge mode skips once-downloads (no frequency). Like backup 20260308 vs current.""" + from wrolpi.downloader import get_download_manager_config + config = get_download_manager_config() + + current = dict( + downloads=[ + dict(url='https://example.com', downloader='video', frequency=None, status='failed'), + dict(url='https://youtube.com/channel/ABC', downloader='video_channel', frequency=2592000, status='complete'), + ], + skip_urls=['https://skip1.com'], + version=260, + ) + _write_yaml(config.get_file(), current) + + # Backup has same 2 + an extra once-download + backup = dict( + downloads=[ + dict(url='https://example.com', downloader='video', frequency=None, status='failed'), + dict(url='https://youtube.com/channel/ABC', downloader='video_channel', frequency=2592000, status='complete'), + dict(url='https://youtube.com/watch?v=TEST', downloader='video', frequency=None, status='new'), + ], + skip_urls=['https://skip1.com'], + version=259, + ) + _make_backup(test_directory, 'download_manager.yaml', '20260308', backup) + + preview = config.preview_backup_import('20260308', 'merge') + assert preview['add'] == [] # Once-download skipped in merge + assert preview['remove'] == [] + # Only the recurring download is counted (once-downloads are skipped entirely) + assert preview['unchanged'] == 1 + + def test_download_manager_overwrite_shows_extra_download(self, test_directory, test_download_manager_config): + """Overwrite mode includes once-downloads. Extra backup download should appear as add.""" + from wrolpi.downloader import get_download_manager_config + config = get_download_manager_config() + + current = dict( + downloads=[ + dict(url='https://example.com', downloader='video', frequency=None, status='failed'), + dict(url='https://youtube.com/channel/ABC', downloader='video_channel', frequency=2592000, status='complete'), + ], + skip_urls=[], + version=260, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + downloads=[ + dict(url='https://example.com', downloader='video', frequency=None, status='failed'), + dict(url='https://youtube.com/channel/ABC', downloader='video_channel', frequency=2592000, status='complete'), + dict(url='https://youtube.com/watch?v=TEST', downloader='video', frequency=None, status='new'), + ], + skip_urls=[], + version=259, + ) + _make_backup(test_directory, 'download_manager.yaml', '20260308', backup) + + preview = config.preview_backup_import('20260308', 'overwrite') + assert len(preview['add']) == 1 + assert preview['add'][0]['url'] == 'https://youtube.com/watch?v=TEST' + assert preview['remove'] == [] + assert preview['unchanged'] == 2 + + def test_channels_case_sensitive_directory(self, test_directory, test_channels_config): + """Directory comparison is case-sensitive. 'videos/wrolpi' != 'videos/WROLPi'.""" + from modules.videos.lib import get_channels_config + config = get_channels_config() + + current = dict( + channels=[ + dict(name='WROLPi', directory='videos/WROLPi', download_frequency=2592000), + dict(name="Maker's Muse", directory="videos/Maker's Muse"), + ], + version=42, + ) + _write_yaml(config.get_file(), current) + + # Old backup used lowercase directory + backup = dict( + channels=[dict(name='WROLPi', directory='videos/wrolpi', download_frequency=604800)], + version=1, + ) + _make_backup(test_directory, 'channels.yaml', '20251120', backup) + + preview = config.preview_backup_import('20251120', 'merge') + # Case difference means backup channel is treated as new + assert len(preview['add']) == 1 + assert preview['add'][0]['directory'] == 'videos/wrolpi' + assert preview['unchanged'] == 0 + + preview = config.preview_backup_import('20251120', 'overwrite') + assert len(preview['add']) == 1 # backup's videos/wrolpi + assert len(preview['remove']) == 2 # current's videos/WROLPi + Maker's Muse + assert preview['unchanged'] == 0 + + def test_channels_merge_backup_is_subset(self, test_directory, test_channels_config): + """When backup channels are already in current, merge shows no changes.""" + from modules.videos.lib import get_channels_config + config = get_channels_config() + + current = dict( + channels=[ + dict(name='WROLPi', directory='videos/WROLPi'), + dict(name='Talking Sasquach', directory='videos/Talking Sasquach'), + dict(name="Maker's Muse", directory="videos/Maker's Muse"), + ], + version=42, + ) + _write_yaml(config.get_file(), current) + + backup = dict( + channels=[ + dict(name='WROLPi', directory='videos/WROLPi'), + dict(name='Talking Sasquach', directory='videos/Talking Sasquach'), + ], + version=41, + ) + _make_backup(test_directory, 'channels.yaml', '20260222', backup) + + preview = config.preview_backup_import('20260222', 'merge') + assert preview['add'] == [] + assert preview['remove'] == [] + assert preview['unchanged'] == 2 + + +class TestWriteConfigData: + + def test_rejects_python_objects(self, test_directory, test_tags_config): + """write_config_data raises ValueError when config contains Python objects (e.g. Enums).""" + from enum import Enum + from wrolpi.tags import get_tags_config + + class Frequency(int, Enum): + weekly = 604800 + + config = get_tags_config() + config_file = config.get_file() + config_file.parent.mkdir(parents=True, exist_ok=True) + + with pytest.raises(ValueError, match='Python object'): + config.write_config_data({'tags': [{'frequency': Frequency.weekly}]}, config_file) + + def test_converts_decimal_to_str(self, test_directory, test_tags_config): + """write_config_data converts Decimal values to strings.""" + from decimal import Decimal + from wrolpi.tags import get_tags_config + + config = get_tags_config() + config_file = config.get_file() + config_file.parent.mkdir(parents=True, exist_ok=True) + + config.write_config_data({'count': Decimal('22.3')}, config_file) + + data = config.read_config_file(config_file) + assert data['count'] == '22.3' + assert isinstance(data['count'], str) diff --git a/wrolpi/test/test_tags.py b/wrolpi/test/test_tags.py index 65d9a5ef..99232680 100644 --- a/wrolpi/test/test_tags.py +++ b/wrolpi/test/test_tags.py @@ -237,8 +237,8 @@ async def test_import_tags_config(async_client, test_session, test_directory, te # Tag names can contain Unicode characters. tags={'🔫': {'color': '#123456'}}, tag_files=[ - ('🔫', str(example_singlefile.relative_to(test_directory)), '2000-01-01 01:01:01'), - ('🔫', 'does not exist', None), + ['🔫', str(example_singlefile.relative_to(test_directory)), '2000-01-01 01:01:01'], + ['🔫', 'does not exist', None], ], ) yaml.dump(data, fh) @@ -270,7 +270,7 @@ async def test_import_tags_config_missing_file(test_session, test_directory, tes # Tag names can contain Unicode characters. tags={'🦄': {'color': '#654321'}}, tag_files=[ - ('🦄', str(example_singlefile.relative_to(test_directory)), '2000-01-01 01:01:01'), + ['🦄', str(example_singlefile.relative_to(test_directory)), '2000-01-01 01:01:01'], ], ) yaml.dump(data, fh)