Files
cardputerzero-sync/device-daemon/tests/test_store_and_config.py

304 lines
12 KiB
Python

"""Unit tests for device-daemon configuration and SQLite WAL queue store."""
from __future__ import annotations
import json
import os
import sqlite3
import tempfile
import unittest
from pathlib import Path
from unittest import mock
from cp0_syncd.config import (
DaemonConfig,
WatchedFolder,
add_watched_folder,
default_config_path,
load_daemon_config,
remove_watched_folder,
save_daemon_config,
)
from cp0_syncd.store import (
SyncStore,
compute_sha256,
default_db_path,
is_media_file,
)
class TestDaemonConfig(unittest.TestCase):
def test_first_run_creates_default_camera_folder_and_theme(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
home = Path(tmp) / "home"
cfg_path = Path(tmp) / "config.json"
cfg = load_daemon_config(cfg_path, home_dir=home)
self.assertEqual(cfg.theme, "dark")
self.assertEqual(cfg.target_port, 8765)
self.assertEqual(cfg.target_host, "")
self.assertEqual(len(cfg.watched_folders), 1)
self.assertEqual(
cfg.watched_folders[0].path,
str(home / "Pictures" / "DCIM" / "Camera"),
)
self.assertEqual(cfg.watched_folders[0].label, "Camera")
self.assertTrue(cfg.watched_folders[0].enabled)
self.assertFalse(hasattr(cfg, "auth_token"))
def test_corrupt_config_falls_back_to_defaults(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
cfg_path = Path(tmp) / "config.json"
cfg_path.write_text("{corrupt", encoding="utf-8")
with self.assertLogs("cp0_syncd.config", level="WARNING"):
cfg = load_daemon_config(cfg_path, home_dir=Path(tmp))
self.assertEqual(cfg.theme, "dark")
self.assertEqual(cfg.target_port, 8765)
self.assertEqual(len(cfg.watched_folders), 1)
self.assertEqual(cfg_path.read_text(encoding="utf-8"), "{corrupt")
def test_save_and_load_roundtrip_preserves_empty_folders_and_theme(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
cfg_path = Path(tmp) / "nested" / "config.json"
original = DaemonConfig(
target_host="my-mac.tailnet.ts.net",
target_port=9000,
theme="light",
watched_folders=[],
)
save_daemon_config(original, cfg_path)
raw = json.loads(cfg_path.read_text(encoding="utf-8"))
self.assertNotIn("auth_token", raw)
loaded = load_daemon_config(cfg_path, home_dir=Path(tmp))
self.assertEqual(loaded.target_host, "my-mac.tailnet.ts.net")
self.assertEqual(loaded.target_port, 9000)
self.assertEqual(loaded.theme, "light")
self.assertEqual(loaded.watched_folders, [])
def test_env_overrides_default_paths(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
cfg_override = str(Path(tmp) / "custom-config.json")
db_override = str(Path(tmp) / "custom-state.db")
with mock.patch.dict(
os.environ,
{"CP0_SYNC_CONFIG": cfg_override, "CP0_SYNC_DB": db_override},
clear=False,
):
self.assertEqual(default_config_path(), Path(cfg_override))
self.assertEqual(default_db_path(), Path(db_override))
def test_overlap_rejected_and_duplicate_labels_disambiguated(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
d1 = Path(tmp) / "a" / "Camera"
d2 = Path(tmp) / "b" / "Camera"
d3 = Path(tmp) / "c" / "Camera"
child = d1 / "sub"
parent = Path(tmp) / "a"
d1.mkdir(parents=True)
d2.mkdir(parents=True)
d3.mkdir(parents=True)
child.mkdir()
cfg = DaemonConfig(watched_folders=[])
cfg, wf1 = add_watched_folder(cfg, str(d1))
cfg, wf2 = add_watched_folder(cfg, str(d2))
cfg, wf3 = add_watched_folder(cfg, str(d3))
self.assertEqual(wf1.label, "Camera")
self.assertEqual(wf2.label, "Camera-2")
self.assertEqual(wf3.label, "Camera-3")
with self.assertRaises(ValueError):
add_watched_folder(cfg, str(child))
with self.assertRaises(ValueError):
add_watched_folder(cfg, str(parent))
with self.assertRaises(ValueError):
add_watched_folder(cfg, str(d1))
symlink_d1 = Path(tmp) / "cam-link"
symlink_d1.symlink_to(d1)
with self.assertRaises(ValueError):
add_watched_folder(cfg, str(symlink_d1))
def test_add_nonexistent_or_file_raises_and_remove_folder(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
missing = Path(tmp) / "missing"
not_dir = Path(tmp) / "file.txt"
not_dir.write_text("hi", encoding="utf-8")
valid = Path(tmp) / "Screenshots"
valid.mkdir()
cfg = DaemonConfig(watched_folders=[])
with self.assertRaises(ValueError):
add_watched_folder(cfg, str(missing))
with self.assertRaises(ValueError):
add_watched_folder(cfg, str(not_dir))
cfg, wf = add_watched_folder(cfg, str(valid), label="Shots")
self.assertEqual(wf.label, "Shots")
self.assertEqual(len(cfg.watched_folders), 1)
cfg = remove_watched_folder(cfg, wf.id)
self.assertEqual(cfg.watched_folders, [])
class TestSyncStore(unittest.TestCase):
def test_dedup_zero_byte_skip_and_log_cap(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
db = SyncStore(Path(tmp) / "state.db")
try:
img = Path(tmp) / "IMG_0001.jpg"
img.write_bytes(b"photo-bytes")
zero = Path(tmp) / "empty.jpg"
zero.write_bytes(b"")
cfg = DaemonConfig()
self.assertTrue(is_media_file(img, cfg))
with self.assertLogs("cp0_syncd.store", level="WARNING"):
self.assertFalse(is_media_file(zero, cfg))
sha = compute_sha256(img)
self.assertEqual(
db.enqueue_file("cam", str(img), "IMG_0001.jpg", 11, 1, sha),
"enqueued",
)
self.assertEqual(
db.enqueue_file("cam", str(img), "IMG_0001.jpg", 11, 1, sha),
"already_queued",
)
row = db.next_pending()
self.assertIsNotNone(row)
assert row is not None
db.mark_synced(row["id"])
self.assertEqual(
db.enqueue_file("cam", str(img), "IMG_0001.jpg", 11, 1, sha),
"already_synced",
)
# Different content at same path should enqueue cleanly
img.write_bytes(b"updated-photo-bytes")
sha2 = compute_sha256(img)
self.assertEqual(
db.enqueue_file("cam", str(img), "IMG_0001.jpg", 19, 2, sha2),
"enqueued",
)
for i in range(550):
db.log("INFO", f"msg {i}")
self.assertEqual(db.log_count(), 500)
recent = db.list_logs(limit=10)
self.assertEqual(len(recent), 10)
self.assertEqual(recent[0]["message"], "msg 549")
finally:
db.close()
def test_wal_mode_and_enqueue_zero_byte_logs_warn(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
db_path = Path(tmp) / "state.db"
db = SyncStore(db_path)
try:
conn = sqlite3.connect(str(db_path))
mode = conn.execute("PRAGMA journal_mode;").fetchone()[0]
conn.close()
self.assertEqual(mode.lower(), "wal")
status = db.enqueue_file("cam", "/tmp/zero.jpg", "zero.jpg", 0, 1, "0" * 64)
self.assertEqual(status, "skipped_empty")
logs = db.list_logs(limit=5)
self.assertEqual(len(logs), 1)
self.assertEqual(logs[0]["level"], "WARN")
finally:
db.close()
def test_media_filtering_rules(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
cfg = DaemonConfig()
for name, expected in [
("IMG_1.JPEG", True),
("clip.mp4", True),
(".hidden.jpg", False),
("~temp.png", False),
("photo.jpg.part", False),
("photo.jpg.tmp", False),
("photo.jpg.crdownload", False),
("notes.txt", False),
]:
p = Path(tmp) / name
p.write_bytes(b"abc")
self.assertEqual(is_media_file(p, cfg), expected, msg=name)
subdir = Path(tmp) / "sub.jpg"
subdir.mkdir()
self.assertFalse(is_media_file(subdir, cfg))
self.assertFalse(is_media_file(Path(tmp) / "nonexistent.jpg", cfg))
def test_queue_lifecycle_meta_and_status_snapshot(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
cam_dir = Path(tmp) / "Camera"
cam_dir.mkdir()
missing_dir = Path(tmp) / "SDCard"
db = SyncStore(Path(tmp) / "state.db")
try:
db.enqueue_file("cam", str(cam_dir / "a.jpg"), "a.jpg", 100, 10, "a" * 64)
db.enqueue_file("cam", str(cam_dir / "b.jpg"), "b.jpg", 200, 20, "b" * 64)
db.enqueue_file("sd", str(missing_dir / "c.jpg"), "c.jpg", 300, 30, "c" * 64)
first = db.next_pending()
assert first is not None
self.assertEqual(first["rel_path"], "a.jpg")
db.mark_uploading(first["id"])
db.mark_retry(first["id"], "timeout")
# Re-fetch after retry: still PENDING with retry_count == 1
again = db.next_pending()
assert again is not None
self.assertEqual(again["id"], first["id"])
self.assertEqual(again["retry_count"], 1)
self.assertEqual(again["last_error"], "timeout")
db.mark_synced(again["id"])
second = db.next_pending()
assert second is not None
self.assertEqual(second["rel_path"], "b.jpg")
db.mark_failed(second["id"], "413 too large")
# Meta roundtrip
self.assertIsNone(db.get_meta("mac_online"))
db.set_meta("mac_online", "true")
db.set_meta("mac_online", "false")
self.assertEqual(db.get_meta("mac_online"), "false")
folders = [
WatchedFolder(id="cam", path=str(cam_dir), label="Camera"),
WatchedFolder(id="sd", path=str(missing_dir), label="SDCard"),
]
snap = db.get_status_snapshot(folders)
self.assertEqual(snap["counts"]["synced"], 1)
self.assertEqual(snap["counts"]["failed"], 1)
self.assertEqual(snap["counts"]["pending"], 1)
self.assertEqual(snap["counts"]["pending_bytes"], 300)
self.assertEqual(snap["meta"]["mac_online"], "false")
self.assertEqual(len(snap["folders"]), 2)
self.assertTrue(snap["folders"][0]["exists"])
self.assertFalse(snap["folders"][1]["exists"])
self.assertEqual(snap["folders"][0]["synced"], 1)
self.assertEqual(snap["folders"][0]["failed"], 1)
self.assertEqual(snap["folders"][1]["pending"], 1)
# retry_all_failed flips FAILED -> PENDING
self.assertEqual(db.retry_all_failed(), 1)
# purge_pending_for_folder deletes pending for sd without touching cam
self.assertEqual(db.purge_pending_for_folder("sd"), 1)
# delete_file removes remaining pending b.jpg
rem = db.next_pending()
assert rem is not None
self.assertEqual(rem["rel_path"], "b.jpg")
db.delete_file(rem["id"])
self.assertIsNone(db.next_pending())
finally:
db.close()
if __name__ == "__main__":
unittest.main()