wheneverd 0.1.0

data/test/dsl_loader_test.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "fileutils"
+require "tmpdir"
+
+module DSLLoaderTestHelpers
+  def setup
+    super
+    @tmpdir = Dir.mktmpdir("wheneverd-")
+  end
+
+  def teardown
+    FileUtils.rm_rf(@tmpdir) if @tmpdir
+    super
+  end
+
+  private
+
+  def load_schedule(source)
+    path = write_schedule(source)
+    Wheneverd::DSL::Loader.load_file(path)
+  end
+
+  def write_schedule(source)
+    path = File.join(@tmpdir, "schedule.rb")
+    File.write(path, source)
+    path
+  end
+end
+
+class DSLLoaderIntervalAndDurationTest < Minitest::Test
+  include DSLLoaderTestHelpers
+
+  def test_loads_interval_string_every_block
+    schedule = load_schedule(<<~RUBY)
+      every "5m" do
+        command "echo hello"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_instance_of Wheneverd::Trigger::Interval, entry.trigger
+    assert_equal 300, entry.trigger.seconds
+    assert_equal ["echo hello"], entry.jobs.map(&:command)
+  end
+
+  def test_loads_duration_with_at_as_calendar
+    schedule = load_schedule(<<~RUBY)
+      every 1.day, at: "4:30 am" do
+        command "echo four_thirty"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_instance_of Wheneverd::Trigger::Calendar, entry.trigger
+    assert_equal ["day@4:30 am"], entry.trigger.on_calendar
+    assert_equal ["echo four_thirty"], entry.jobs.map(&:command)
+  end
+
+  def test_loads_duration_without_at_as_interval
+    schedule = load_schedule(<<~RUBY)
+      every 1.day do
+        command "echo daily"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_instance_of Wheneverd::Trigger::Interval, entry.trigger
+    assert_equal 86_400, entry.trigger.seconds
+  end
+
+  def test_loads_duration_with_at_array_as_calendar
+    schedule = load_schedule(<<~RUBY)
+      every 1.day, at: ["4:30 am", "6:00 pm"] do
+        command "echo twice_daily"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_instance_of Wheneverd::Trigger::Calendar, entry.trigger
+    assert_equal ["day@4:30 am", "day@6:00 pm"], entry.trigger.on_calendar
+  end
+
+  def test_loads_cron_string_as_calendar_trigger
+    schedule = load_schedule(<<~RUBY)
+      every "0 0 27-31 * *" do
+        command "echo raw_cron"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_instance_of Wheneverd::Trigger::Calendar, entry.trigger
+    assert_equal ["cron:0 0 27-31 * *"], entry.trigger.on_calendar
+  end
+end
+
+class DSLLoaderSymbolPeriodsTest < Minitest::Test
+  include DSLLoaderTestHelpers
+
+  def test_loads_symbol_shortcut_hour
+    schedule = load_schedule(<<~RUBY)
+      every :hour do
+        command "echo hourly"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_instance_of Wheneverd::Trigger::Calendar, entry.trigger
+    assert_equal ["hour"], entry.trigger.on_calendar
+  end
+
+  def test_reboot_symbol_is_rejected
+    schedule_path = write_schedule(<<~RUBY)
+      every :reboot do
+        command "echo reboot"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, ":reboot"
+    assert_includes error.message, "not supported"
+  end
+
+  def test_loads_day_selector_symbol_with_at
+    schedule = load_schedule(<<~RUBY)
+      every :sunday, at: "12pm" do
+        command "echo weekly"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_instance_of Wheneverd::Trigger::Calendar, entry.trigger
+    assert_equal ["sunday@12pm"], entry.trigger.on_calendar
+  end
+
+  def test_loads_weekday_symbol
+    schedule = load_schedule(<<~RUBY)
+      every :weekday do
+        command "echo weekday"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_equal ["weekday"], entry.trigger.on_calendar
+  end
+
+  def test_loads_weekend_symbol
+    schedule = load_schedule(<<~RUBY)
+      every :weekend do
+        command "echo weekend"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_equal ["weekend"], entry.trigger.on_calendar
+  end
+
+  def test_loads_multiple_day_symbols_as_calendar_trigger
+    schedule = load_schedule(<<~RUBY)
+      every :tuesday, :wednesday, at: "12pm" do
+        command "echo midweek"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_instance_of Wheneverd::Trigger::Calendar, entry.trigger
+    assert_equal ["tuesday@12pm", "wednesday@12pm"], entry.trigger.on_calendar
+  end
+
+  def test_loads_period_symbol_array_as_calendar_trigger
+    schedule = load_schedule(<<~RUBY)
+      every %i[tuesday wednesday], at: "12pm" do
+        command "echo midweek"
+      end
+    RUBY
+
+    entry = schedule.entries.fetch(0)
+    assert_instance_of Wheneverd::Trigger::Calendar, entry.trigger
+    assert_equal ["tuesday@12pm", "wednesday@12pm"], entry.trigger.on_calendar
+  end
+
+  def test_loads_multiple_day_symbols_with_at_array_as_calendar_trigger
+    entry = load_schedule(<<~RUBY).entries.fetch(0)
+      every :tuesday, :wednesday, at: ["4:30 am", "6:00 pm"] do
+        command "echo twice_midweek"
+      end
+    RUBY
+
+    assert_instance_of Wheneverd::Trigger::Calendar, entry.trigger
+    assert_equal(
+      ["tuesday@4:30 am", "tuesday@6:00 pm", "wednesday@4:30 am", "wednesday@6:00 pm"],
+      entry.trigger.on_calendar
+    )
+  end
+end
+
+class DSLLoaderPeriodErrorsTest < Minitest::Test
+  include DSLLoaderTestHelpers
+
+  def test_invalid_interval_raises_error_with_path
+    schedule_path = write_schedule(<<~RUBY)
+      every "0m" do
+        command "echo no"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "Interval must be positive"
+  end
+
+  def test_interval_string_does_not_accept_at
+    schedule_path = write_schedule(<<~RUBY)
+      every "5m", at: "12pm" do
+        command "echo nope"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "interval periods"
+  end
+
+  def test_cron_string_does_not_accept_at
+    schedule_path = write_schedule(<<~RUBY)
+      every "0 0 27-31 * *", at: "12pm" do
+        command "echo nope"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "cron periods"
+  end
+
+  def test_duration_at_is_rejected_for_non_daily_durations
+    schedule_path = write_schedule(<<~RUBY)
+      every 2.days, at: "4:30 am" do
+        command "echo nope"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "at: is only supported"
+  end
+
+  def test_every_requires_a_block
+    schedule_path = write_schedule(<<~RUBY)
+      every "5m"
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "requires a block"
+  end
+
+  def test_every_rejects_unknown_period_type
+    schedule_path = write_schedule(<<~RUBY)
+      every Object.new do
+        command "echo nope"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "Unsupported period type"
+  end
+
+  def test_every_rejects_unrecognized_string_period
+    schedule_path = write_schedule(<<~RUBY)
+      every "not a schedule" do
+        command "echo nope"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "Unrecognized period"
+  end
+
+  def test_unknown_symbol_period_raises_error
+    schedule_path = write_schedule(<<~RUBY)
+      every :fortnight do
+        command "echo nope"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "Unknown period symbol"
+  end
+
+  def test_reboot_does_not_accept_at
+    schedule_path = write_schedule(<<~RUBY)
+      every :reboot, at: "12pm" do
+        command "echo nope"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, ":reboot"
+    assert_includes error.message, "not supported"
+  end
+end
+
+class DSLLoaderAtValidationErrorsTest < Minitest::Test
+  include DSLLoaderTestHelpers
+
+  def test_invalid_at_type_raises_error_with_path
+    schedule_path = write_schedule(<<~RUBY)
+      every 1.day, at: 123 do
+        command "echo nope"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidAtError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "at:"
+  end
+
+  def test_invalid_at_array_rejects_non_string
+    schedule_path = write_schedule(<<~RUBY)
+      every 1.day, at: ["4:30 am", 123] do
+        command "echo nope"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidAtError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "Array of Strings"
+  end
+
+  def test_invalid_at_array_rejects_empty
+    schedule_path = write_schedule(<<~RUBY)
+      every 1.day, at: [] do
+        command "echo nope"
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::InvalidAtError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "must not be empty"
+  end
+end
+
+class DSLLoaderCommandAndEvalErrorsTest < Minitest::Test
+  include DSLLoaderTestHelpers
+
+  def test_invalid_command_raises_error_with_path
+    schedule_path = write_schedule(<<~RUBY)
+      every "5m" do
+        command ""
+      end
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::LoadError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "Command must not be empty"
+  end
+
+  def test_command_outside_every_is_rejected
+    schedule_path = write_schedule(<<~RUBY)
+      command "echo nope"
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::LoadError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "inside every()"
+  end
+
+  def test_unknown_method_in_schedule_is_wrapped_as_load_error
+    schedule_path = write_schedule(<<~RUBY)
+      totally_unknown_dsl_method "nope"
+    RUBY
+
+    error = assert_raises(Wheneverd::DSL::LoadError) { Wheneverd::DSL::Loader.load_file(schedule_path) }
+    assert_includes error.message, schedule_path
+    assert_includes error.message, "totally_unknown_dsl_method"
+  end
+end

data/test/support/cli_subprocess_test_helpers.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rbconfig"
+require "tmpdir"
+
+module CLISubprocessTestHelpers
+  def with_temp_project_dir
+    Dir.mktmpdir("wheneverd-e2e-") do |tmp|
+      project_dir = File.join(tmp, "myapp")
+      FileUtils.mkdir_p(project_dir)
+      yield project_dir
+    end
+  end
+
+  def exe_path
+    File.expand_path("../../exe/wheneverd", __dir__)
+  end
+
+  def run_exe(args, chdir:, env: {})
+    stdout, stderr, status = Open3.capture3(env, RbConfig.ruby, exe_path, *args, chdir: chdir)
+    [status.exitstatus, stdout, stderr]
+  end
+
+  def write_schedule(project_dir, contents)
+    path = File.join(project_dir, "config", "schedule.rb")
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, contents)
+  end
+
+  def find_executable(name)
+    ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |dir|
+      candidate = File.join(dir, name)
+      return candidate if File.file?(candidate) && File.executable?(candidate)
+    end
+    nil
+  end
+end

data/test/support/cli_test_helpers.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+require "wheneverd/cli"
+
+module CLITestHelpers
+  SYSTEMCTL_USER_PREFIX = ["systemctl", "--user", "--no-pager"].freeze
+
+  def run_cli(args)
+    status = nil
+    out, err = capture_io { status = Wheneverd::CLI.run("wheneverd", args) }
+    [status, out, err]
+  end
+
+  def run_activate_with_capture3_stub(identifier: "demo", **kwargs)
+    run_cli_with_capture3_stub(["activate", "--identifier", identifier], **kwargs)
+  end
+
+  def run_deactivate_with_capture3_stub(identifier: "demo", **kwargs)
+    run_cli_with_capture3_stub(["deactivate", "--identifier", identifier], **kwargs)
+  end
+
+  def run_reload_with_capture3_stub(unit_dir:, identifier: "demo", **kwargs)
+    run_cli_with_capture3_stub(
+      ["reload", "--identifier", identifier, "--unit-dir", unit_dir],
+      **kwargs
+    )
+  end
+
+  def write_empty_schedule(path = File.join("config", "schedule.rb"))
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, "# frozen_string_literal: true\n")
+  end
+
+  def with_capture3_stub(exitstatus: 0, stdout: "", stderr: "")
+    calls = []
+    Thread.current[:open3_capture3_stub] = {
+      calls: calls,
+      stdout: stdout,
+      stderr: stderr,
+      exitstatus: exitstatus
+    }
+    yield calls
+  ensure
+    Thread.current[:open3_capture3_stub] = nil
+  end
+
+  def run_cli_with_capture3_stub(args, exitstatus: 0, stdout: "", stderr: "")
+    status = out = err = nil
+    calls = nil
+    with_capture3_stub(exitstatus: exitstatus, stdout: stdout, stderr: stderr) do |stub_calls|
+      calls = stub_calls
+      status, out, err = run_cli(args)
+    end
+    [status, out, err, calls]
+  end
+
+  def assert_cli_success(status, err)
+    assert_equal 0, status
+    assert_equal "", err
+  end
+
+  def assert_systemctl_call(calls, index, expected_args)
+    args, kwargs = calls.fetch(index)
+    assert_equal expected_args, args
+    assert_equal({}, kwargs)
+  end
+
+  def assert_systemctl_call_starts_with(calls, index, prefix, includes: nil)
+    args, kwargs = calls.fetch(index)
+    assert_equal prefix, args.take(prefix.length)
+    assert_equal({}, kwargs)
+    return if includes.nil?
+
+    Array(includes).each { |expected| assert_includes args, expected }
+  end
+
+  def with_project_dir
+    Dir.mktmpdir("wheneverd-project-") do |tmp|
+      project_dir = File.join(tmp, "myapp")
+      FileUtils.mkdir_p(project_dir)
+      Dir.chdir(project_dir) { yield project_dir }
+    end
+  end
+
+  def with_inited_project_dir
+    with_project_dir do |project_dir|
+      assert_equal 0, run_cli(["init"]).first
+      yield project_dir
+    end
+  end
+
+  def expected_units(identifier: "demo", schedule_path: File.join("config", "schedule.rb"))
+    schedule = Wheneverd::DSL::Loader.load_file(File.expand_path(schedule_path))
+    Wheneverd::Systemd::Renderer.render(schedule, identifier: identifier)
+  end
+
+  def expected_timer_basenames(identifier: "demo",
+                               schedule_path: File.join("config", "schedule.rb"))
+    expected_units(identifier: identifier, schedule_path: schedule_path)
+      .select { |unit| unit.kind == :timer }
+      .map(&:path_basename)
+      .uniq
+  end
+
+  def expected_service_basenames(identifier: "demo",
+                                 schedule_path: File.join("config", "schedule.rb"))
+    expected_units(identifier: identifier, schedule_path: schedule_path)
+      .select { |unit| unit.kind == :service }
+      .map(&:path_basename)
+      .uniq
+  end
+end

data/test/systemd_calendar_spec_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class SystemdCalendarSpecTest < Minitest::Test
+  def test_translates_base_calendar_specs
+    assert_equal "hourly", Wheneverd::Systemd::CalendarSpec.to_on_calendar("hour")
+    assert_equal "daily", Wheneverd::Systemd::CalendarSpec.to_on_calendar("day")
+    assert_equal "monthly", Wheneverd::Systemd::CalendarSpec.to_on_calendar("month")
+    assert_equal "yearly", Wheneverd::Systemd::CalendarSpec.to_on_calendar("year")
+  end
+
+  def test_translates_weekday_weekend_and_days_without_at_to_midnight
+    assert_equal "Mon..Fri *-*-* 00:00:00", Wheneverd::Systemd::CalendarSpec.to_on_calendar("weekday")
+    assert_equal "Sat,Sun *-*-* 00:00:00", Wheneverd::Systemd::CalendarSpec.to_on_calendar("weekend")
+    assert_equal "Mon *-*-* 00:00:00", Wheneverd::Systemd::CalendarSpec.to_on_calendar("monday")
+  end
+
+  def test_translates_calendar_specs_with_at
+    assert_equal "*-*-* 04:30:00", Wheneverd::Systemd::CalendarSpec.to_on_calendar("day@4:30 am")
+    assert_equal "Mon..Fri *-*-* 00:15:00", Wheneverd::Systemd::CalendarSpec.to_on_calendar("weekday@00:15")
+    assert_equal "Sat,Sun *-*-* 18:00:00",
+                 Wheneverd::Systemd::CalendarSpec.to_on_calendar("weekend@6:00 pm")
+  end
+
+  def test_rejects_invalid_calendar_specs
+    assert_raises(Wheneverd::Systemd::InvalidCalendarSpecError) do
+      Wheneverd::Systemd::CalendarSpec.to_on_calendar("")
+    end
+
+    assert_raises(Wheneverd::Systemd::InvalidCalendarSpecError) do
+      Wheneverd::Systemd::CalendarSpec.to_on_calendar("not-a-period")
+    end
+
+    assert_raises(Wheneverd::Systemd::InvalidCalendarSpecError) do
+      Wheneverd::Systemd::CalendarSpec.to_on_calendar("hour@12pm")
+    end
+  end
+
+  def test_rejects_calendar_specs_that_expand_to_multiple_on_calendar_values
+    assert_raises(Wheneverd::Systemd::InvalidCalendarSpecError) do
+      Wheneverd::Systemd::CalendarSpec.to_on_calendar("cron:0 0 1 * Mon")
+    end
+  end
+end

data/test/systemd_cron_parser_test.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class SystemdCronParserTest < Minitest::Test
+  def test_translates_simple_cron_to_single_value
+    assert_values("0 0 * * *", ["*-*-* 00:00:00"])
+    assert_values("59 23 5 * *", ["*-*-5 23:59:00"])
+    assert_values("0 0 27-31 * *", ["*-*-27..31 00:00:00"])
+  end
+
+  def test_translates_months_and_steps
+    assert_values("0 0 * 1 *", ["*-1-* 00:00:00"])
+    assert_values("0 0 * Jan *", ["*-1-* 00:00:00"])
+    assert_values("*/15 9-17 * * *", ["*-*-* 09..17:00/15:00"])
+  end
+
+  def test_translates_lists_and_steps
+    assert_values("0,30 8,16 * * *", ["*-*-* 08,16:00,30:00"])
+    assert_values("0 0 */2 * *", ["*-*-1/2 00:00:00"])
+    assert_values("0 0 * */2 *", ["*-1/2-* 00:00:00"])
+  end
+
+  def test_translates_day_of_week_variants
+    assert_values("0 0 * * Mon", ["Mon *-*-* 00:00:00"])
+    assert_values("0 0 * * 1-5", ["Mon..Fri *-*-* 00:00:00"])
+    assert_values("0 0 * * */2", ["Tue,Thu,Sat..Sun *-*-* 00:00:00"])
+    assert_values("0 0 * * Fri-Mon", ["Mon,Fri..Sun *-*-* 00:00:00"])
+  end
+
+  def test_dom_and_dow_or_semantics_expands_to_multiple_values
+    assert_values("0 0 1 * Mon", ["Mon *-*-* 00:00:00", "*-*-1 00:00:00"])
+  end
+
+  def test_to_on_calendar_rejects_multiple_values
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser.to_on_calendar("0 0 1 * Mon")
+    end
+  end
+
+  def test_private_helpers_reject_empty_numeric_field
+    assert_private_unsupported(
+      :parse_mapped_numeric_expression,
+      "",
+      0..59,
+      field: "minute",
+      input: "x",
+      names: {}
+    )
+  end
+
+  def test_private_helpers_reject_invalid_numeric_tokens
+    common = { field: "minute", input: "x", names: {} }
+    assert_private_unsupported(:parse_mapped_value, " ", 0..59, **common)
+    assert_private_unsupported(:parse_positive_int, "x", field: "minute", input: "x", label: "step")
+  end
+
+  def test_private_helpers_reject_empty_dow_and_invalid_tokens
+    assert_private_unsupported(:parse_dow_set, "", input: "x")
+    assert_private_unsupported(:apply_dow_part, Array.new(7, false), "", input: "x")
+    assert_private_unsupported(:parse_dow_value, "", input: "x")
+    assert_private_unsupported(:parse_dow_value, "8", input: "x")
+  end
+
+  def test_rejects_unsupported_cron_patterns
+    assert_unsupported(
+      "0 0",
+      "x 0 * * *",
+      "60 0 * * *",
+      "0 0 0 * *",
+      "0 0 10 13 *"
+    )
+  end
+
+  def test_rejects_unsupported_cron_tokens
+    assert_unsupported(
+      "0 0 31-27 * *",
+      "0 0 * * Funday",
+      "0 0 */0 * *",
+      "0 0 ? * *"
+    )
+  end
+
+  def test_rejects_empty_tokens_and_invalid_steps
+    assert_unsupported(
+      "0,,15 0 * * *",
+      "*/x 0 * * *",
+      "0 0 * * Mon,,Tue",
+      "0 0 * * Mon-",
+      "0 0 * * 8"
+    )
+  end
+
+  private
+
+  def assert_values(cron, expected)
+    assert_equal expected, Wheneverd::Systemd::CronParser.to_on_calendar_values(cron)
+  end
+
+  def assert_private_unsupported(method, *args, **kwargs)
+    parser = Wheneverd::Systemd::CronParser
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      parser.send(method, *args, **kwargs)
+    end
+  end
+
+  def assert_unsupported(*crons)
+    crons.each do |cron|
+      assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+        Wheneverd::Systemd::CronParser.to_on_calendar_values(cron)
+      end
+    end
+  end
+end