from __future__ import annotations import os import pytest from schedls.backends.base import FileChange, Plan from schedls.backends.cron import CronBackend, CronPaths, CrontabDocument from schedls.errors import ConflictError, InvalidScheduleError, SafetyRefusalError from schedls.models import Backend, Command, JobSpec, Scope from schedls.renderers import cron as renderer def _make_paths(tmp_path) -> CronPaths: root = tmp_path / "etc" root.mkdir() return CronPaths( crontab=str(root / "crontab"), cron_d=str(root / "cron.d"), hourly=str(root / "cron.hourly"), daily=str(root / "cron.daily"), weekly=str(root / "cron.weekly"), monthly=str(root / "cron.monthly"), spool_crontabs=str(tmp_path / "var" / "spool" / "cron" / "crontabs"), spool=str(tmp_path / "var" / "spool" / "cron"), ) def _write(path, text: str, mode: int = 0o644): path.parent.mkdir(parents=True, exist_ok=True) path.write_text(text) path.chmod(mode) return path def test_available_without_crontab_uses_file_sources(tmp_path, fake_runner) -> None: paths = _make_paths(tmp_path) assert CronBackend(fake_runner, paths).available() is False _write(tmp_path / "etc/cron.d/backup", "0 2 * * * root /usr/bin/backup\n") assert CronBackend(fake_runner, paths).available() is True def test_discovers_system_crontabs(tmp_path, fake_runner) -> None: paths = _make_paths(tmp_path) _write( tmp_path / "etc/crontab", "SHELL=/bin/sh\n17 * * * * root /usr/bin/hourly\n@daily www-data /usr/bin/report\n", ) _write(tmp_path / "etc/cron.d/backup", "0 2 * * * root /usr/bin/backup\n") _write( tmp_path / "etc/cron.d/schedls-cleanup", renderer.render_system_file("cleanup", ["30 3 * * 0 deploy /usr/bin/cleanup"]), ) _write(tmp_path / "etc/cron.d/with.dot", "0 2 * * * root /usr/bin/ignored\n") _write(tmp_path / "etc/cron.d/.placeholder", "") jobs = CronBackend(fake_runner, paths).discover([Scope.SYSTEM]) by_name = {job.name: job for job in jobs} assert set(by_name) == {"crontab:2", "crontab:3", "backup:1", "cleanup"} assert by_name["crontab:2"].scope is Scope.SYSTEM assert by_name["crontab:2"].cron.user == "root" assert by_name["crontab:2"].command.raw == "/usr/bin/hourly" assert by_name["crontab:3"].cron.user == "www-data" assert by_name["backup:1"].managed is False assert by_name["backup:1"].schedule.expression == "0 2 * * *" assert by_name["backup:1"].source.path == paths.cron_d + "/backup" managed = by_name["cleanup"] assert managed.managed is True assert managed.cron.user == "deploy" assert managed.schedule.expression == "30 3 * * 0" assert managed.source.path == paths.cron_d + "/schedls-cleanup" def test_discovers_periodic_directories(tmp_path, fake_runner) -> None: paths = _make_paths(tmp_path) _write(tmp_path / "etc/cron.daily/logrotate", "#!/bin/sh\n", mode=0o755) _write(tmp_path / "etc/cron.daily/README", "text\n", mode=0o644) _write(tmp_path / "etc/cron.hourly/.hidden", "#!/bin/sh\n", mode=0o755) jobs = CronBackend(fake_runner, paths).discover([Scope.SYSTEM]) assert [job.name for job in jobs] == ["logrotate"] job = jobs[0] assert job.schedule.expression == "@daily" assert job.command.display() == paths.daily + "/logrotate" assert job.cron.user == "root" assert job.managed is False assert "cron.daily" in job.source.detail def test_spool_crontabs_require_root(tmp_path, fake_runner, monkeypatch) -> None: paths = _make_paths(tmp_path) _write(tmp_path / "var/spool/cron/crontabs/alice", "5 4 * * * /usr/bin/alice\n") _write(tmp_path / "var/spool/cron/crontabs/root", "5 4 * * * /usr/bin/root\n") backend = CronBackend(fake_runner, paths) monkeypatch.setattr(os, "geteuid", lambda: 1000) assert backend.discover([Scope.USER]) == [] monkeypatch.setattr(os, "geteuid", lambda: 0) monkeypatch.setattr(CronBackend, "_current_user", staticmethod(lambda: "root")) jobs = backend.discover([Scope.USER]) assert [job.name for job in jobs] == ["alice:1"] assert jobs[0].scope is Scope.USER assert jobs[0].cron.user == "alice" assert jobs[0].source.path.endswith("crontabs/alice") def test_spool_falls_back_to_flat_layout(tmp_path, fake_runner, monkeypatch) -> None: paths = _make_paths(tmp_path) _write(tmp_path / "var/spool/cron/alice", "5 4 * * * /usr/bin/alice\n") (tmp_path / "var/spool/cron/atjobs").mkdir(parents=True) monkeypatch.setattr(os, "geteuid", lambda: 0) monkeypatch.setattr(CronBackend, "_current_user", staticmethod(lambda: "root")) jobs = CronBackend(fake_runner, paths).discover([Scope.USER]) assert [job.name for job in jobs] == ["alice:1"] def test_malformed_drop_in_is_unmanaged(tmp_path, fake_runner) -> None: paths = _make_paths(tmp_path) _write(tmp_path / "etc/cron.d/schedls-broken", "0 2 * * * root /bin/true\n") jobs = CronBackend(fake_runner, paths).discover([Scope.SYSTEM]) assert [job.name for job in jobs] == ["schedls-broken:1"] assert jobs[0].managed is False assert jobs[0].warnings def _system_spec(**overrides) -> JobSpec: values = { "name": "backup", "backend": Backend.CRON, "scope": Scope.SYSTEM, "command": Command(argv=("/usr/bin/backup", "/srv/data")), "cron_expression": "0 2 * * *", "run_as": "www-data", } values.update(overrides) return JobSpec(**values) def test_plan_create_system_cron(tmp_path, fake_runner, monkeypatch) -> None: paths = _make_paths(tmp_path) (tmp_path / "etc/cron.d").mkdir(parents=True, exist_ok=True) monkeypatch.setattr(os, "geteuid", lambda: 0) monkeypatch.setattr("schedls.backends.cron.check_trusted_directory", lambda path, *, expected_uid: None) plan = CronBackend(fake_runner, paths).plan_create(_system_spec()) assert plan.payload["mode"] == "file" assert plan.payload["expected_uid"] == 0 assert not plan.commands change = plan.files[0] assert change.path == paths.cron_d + "/schedls-backup" assert "0 2 * * * www-data /usr/bin/backup /srv/data" in change.content assert "# schedls:begin name=backup" in change.content assert ("Run as", "www-data") in plan.summary def test_plan_create_system_cron_requires_root(tmp_path, fake_runner, monkeypatch) -> None: paths = _make_paths(tmp_path) monkeypatch.setattr(os, "geteuid", lambda: 1000) with pytest.raises(SafetyRefusalError): CronBackend(fake_runner, paths).plan_create(_system_spec()) def test_plan_create_system_cron_rejects_dotted_name(tmp_path, fake_runner, monkeypatch) -> None: paths = _make_paths(tmp_path) monkeypatch.setattr(os, "geteuid", lambda: 0) with pytest.raises(InvalidScheduleError): CronBackend(fake_runner, paths).plan_create(_system_spec(name="my.job")) def test_plan_create_system_cron_conflict(tmp_path, fake_runner, monkeypatch) -> None: paths = _make_paths(tmp_path) _write(tmp_path / "etc/cron.d/schedls-backup", "0 2 * * * root /bin/true\n") monkeypatch.setattr(os, "geteuid", lambda: 0) monkeypatch.setattr("schedls.backends.cron.check_trusted_directory", lambda path, *, expected_uid: None) with pytest.raises(ConflictError): CronBackend(fake_runner, paths).plan_create(_system_spec()) def test_update_user_cron_preserves_existing_command(tmp_path, fake_runner) -> None: document = CrontabDocument( "# unrelated comment\n" "# schedls:begin name=backup\n" "0 2 * * * /usr/bin/printf '50\\%s\\n'\n" "# schedls:end name=backup\n" ) state = {"text": document.text} def crontab(argv, input_text): if argv == ["crontab", "-l"]: return state["text"], "" if argv == ["crontab", "-"]: state["text"] = input_text or "" return "", "" return 1, "", "unsupported" fake_runner.available.add("crontab") fake_runner.handlers["crontab"] = crontab backend = CronBackend(fake_runner, _make_paths(tmp_path)) job = backend.discover([Scope.USER])[0] plan = backend.plan_update( job, JobSpec( name="backup", backend=Backend.CRON, scope=Scope.USER, command=job.command, cron_expression="30 3 * * *", ), ) assert plan.action == "update" assert "# unrelated comment" in plan.payload["new_text"] assert "30 3 * * * /usr/bin/printf '50\\%s\\n'" in plan.payload["new_text"] assert "50\\\\%" not in plan.payload["new_text"] state["text"] = state["text"].replace("0 2 * * *", "15 2 * * *") with pytest.raises(SafetyRefusalError, match="crontab changed"): backend.apply(plan) plan = backend.plan_update( job, JobSpec( name="backup", backend=Backend.CRON, scope=Scope.USER, command=job.command, cron_expression="30 3 * * *", ), ) result = backend.apply(plan) assert result.changed assert state["text"] == plan.payload["new_text"] def test_plan_update_system_cron_preserves_run_as_and_other_content(tmp_path, fake_runner, monkeypatch) -> None: paths = _make_paths(tmp_path) path = _write( tmp_path / "etc/cron.d/schedls-cleanup", "# unrelated comment\n" + renderer.render_system_file("cleanup", ["30 3 * * 0 root /usr/bin/cleanup"]), ) backend = CronBackend(fake_runner, paths) job = backend.discover([Scope.SYSTEM])[0] monkeypatch.setattr(os, "geteuid", lambda: 0) trusted_directories: list[tuple[str, int]] = [] def check_trusted_directory(path: str, *, expected_uid: int) -> None: trusted_directories.append((path, expected_uid)) monkeypatch.setattr("schedls.backends.cron.check_trusted_directory", check_trusted_directory) plan = backend.plan_update( job, _system_spec( name="cleanup", command=Command(argv=("/usr/bin/cleanup", "--full")), cron_expression="15 4 * * *", run_as="www-data", ), ) assert plan.action == "update" assert plan.files[0].path == str(path) assert "# unrelated comment" in plan.files[0].content assert "15 4 * * * root /usr/bin/cleanup --full" in plan.files[0].content assert "www-data" not in plan.files[0].content assert trusted_directories == [(paths.cron_d, 0)] def test_plan_update_system_cron_requires_root(tmp_path, fake_runner, monkeypatch) -> None: paths = _make_paths(tmp_path) _write( tmp_path / "etc/cron.d/schedls-cleanup", renderer.render_system_file("cleanup", ["30 3 * * 0 root /usr/bin/cleanup"]), ) backend = CronBackend(fake_runner, paths) job = backend.discover([Scope.SYSTEM])[0] monkeypatch.setattr(os, "geteuid", lambda: 1000) with pytest.raises(SafetyRefusalError): backend.plan_update(job, _system_spec(name="cleanup")) def test_apply_file_mode_create_and_remove(tmp_path, fake_runner) -> None: paths = _make_paths(tmp_path) (tmp_path / "etc/cron.d").mkdir(parents=True, exist_ok=True) backend = CronBackend(fake_runner, paths) uid = os.getuid() path = tmp_path / "etc/cron.d/schedls-backup" content = renderer.render_system_file("backup", ["0 2 * * * root /usr/bin/backup"]) create = Plan(backend="cron", action="create") create.files = [FileChange(path=str(path), content=content, mode=0o644, expected_uid=uid)] create.payload = { "mode": "file", "action": "create", "name": "backup", "path": str(path), "expected_uid": uid, "snapshots": {str(path): None}, } result = backend.apply(create) assert result.changed assert path.read_text() == content updated_content = renderer.render_system_file("backup", ["30 3 * * * root /usr/bin/backup --full"]) update = Plan(backend="cron", action="update") update.files = [FileChange(path=str(path), content=updated_content, mode=0o644, expected_uid=uid)] update.payload = { "mode": "file", "action": "update", "name": "backup", "path": str(path), "expected_uid": uid, "snapshots": {str(path): content}, "expected_line": "30 3 * * * root /usr/bin/backup --full", } result = backend.apply(update) assert result.changed assert result.messages == ["System cron drop-in updated."] assert path.read_text() == updated_content remove = Plan(backend="cron", action="remove") remove.files = [FileChange(path=str(path), content=None, expected_uid=uid)] remove.payload = { "mode": "file", "action": "remove", "name": "backup", "path": str(path), "expected_uid": uid, "snapshots": {str(path): updated_content}, } result = backend.apply(remove) assert result.changed assert not path.exists() def test_apply_file_update_refuses_changed_snapshot(tmp_path, fake_runner) -> None: paths = _make_paths(tmp_path) _write(tmp_path / "etc/cron.d/schedls-backup", "changed\n") backend = CronBackend(fake_runner, paths) path = tmp_path / "etc/cron.d/schedls-backup" plan = Plan(backend="cron", action="update") plan.files = [FileChange(path=str(path), content="new content\n", expected_uid=os.getuid())] plan.payload = { "mode": "file", "action": "update", "name": "backup", "path": str(path), "expected_uid": os.getuid(), "snapshots": {str(path): "expected\n"}, } with pytest.raises(SafetyRefusalError): backend.apply(plan) assert path.exists() def test_apply_file_mode_rolls_back_on_failure(tmp_path, fake_runner) -> None: paths = _make_paths(tmp_path) (tmp_path / "etc/cron.d").mkdir(parents=True, exist_ok=True) backend = CronBackend(fake_runner, paths) uid = os.getuid() first = tmp_path / "etc/cron.d/schedls-one" second = tmp_path / "etc/cron.d/schedls-two" _write(second, "conflict\n") plan = Plan(backend="cron", action="create") plan.files = [ FileChange(path=str(first), content=renderer.render_system_file("one", ["0 2 * * * root /bin/true"])), FileChange(path=str(second), content=renderer.render_system_file("two", ["0 3 * * * root /bin/true"])), ] plan.payload = { "mode": "file", "action": "create", "name": "one", "path": str(first), "expected_uid": uid, "snapshots": {str(first): None, str(second): None}, } with pytest.raises(SafetyRefusalError): backend.apply(plan) assert not first.exists() def test_plan_remove_system_cron(tmp_path, fake_runner, monkeypatch) -> None: paths = _make_paths(tmp_path) _write( tmp_path / "etc/cron.d/schedls-cleanup", renderer.render_system_file("cleanup", ["30 3 * * 0 root /usr/bin/cleanup"]), ) backend = CronBackend(fake_runner, paths) job = backend.discover([Scope.SYSTEM])[0] monkeypatch.setattr(os, "geteuid", lambda: 0) plan = backend.plan_remove(job) assert plan.payload["mode"] == "file" assert plan.files[0].path == paths.cron_d + "/schedls-cleanup" assert plan.files[0].content is None def test_plan_remove_system_cron_requires_root(tmp_path, fake_runner, monkeypatch) -> None: paths = _make_paths(tmp_path) _write( tmp_path / "etc/cron.d/schedls-cleanup", renderer.render_system_file("cleanup", ["30 3 * * 0 root /usr/bin/cleanup"]), ) backend = CronBackend(fake_runner, paths) job = backend.discover([Scope.SYSTEM])[0] monkeypatch.setattr(os, "geteuid", lambda: 1000) with pytest.raises(SafetyRefusalError): backend.plan_remove(job) def test_plan_remove_refuses_unmanaged(tmp_path, fake_runner) -> None: paths = _make_paths(tmp_path) _write(tmp_path / "etc/cron.d/backup", "0 2 * * * root /usr/bin/backup\n") backend = CronBackend(fake_runner, paths) job = backend.discover([Scope.SYSTEM])[0] with pytest.raises(SafetyRefusalError): backend.plan_remove(job)