wheneverd 0.1.0

data/test/cli_test.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_test_helpers"
+
+class CLIHelpAndVersionTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_help_prints_usage_and_exits_zero
+    out, err = capture_io { Wheneverd::CLI.run("wheneverd", ["--help"]) }
+    assert_includes out, "Usage:"
+    assert_includes out, "wheneverd [OPTIONS]"
+    assert_equal "", err
+  end
+
+  def test_version_prints_version_and_exits_zero
+    status, out, err = run_cli(["--version"])
+    assert_equal 0, status
+    assert_includes out, Wheneverd::VERSION
+    assert_equal "", err
+  end
+
+  def test_no_args_exits_one_and_prints_help_to_stderr
+    status, out, err = run_cli([])
+    assert_equal 1, status
+    assert_equal "", out
+    assert_includes err, "Usage:"
+    assert_includes err, "wheneverd [OPTIONS]"
+  end
+
+  def test_invalid_option_exits_one_and_prints_error
+    out, err = capture_io do
+      exit_error = assert_raises(SystemExit) do
+        Wheneverd::CLI.run("wheneverd", ["--definitely-not-a-real-flag"])
+      end
+
+      assert_equal 1, exit_error.status
+    end
+
+    assert_equal "", out
+    assert_includes err, "ERROR:"
+    assert_includes err, "--definitely-not-a-real-flag"
+    assert_includes err, "See:"
+  end
+end
+
+class CLIInitTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_init_creates_schedule_file
+    with_project_dir do
+      status, out, err = run_cli(["init"])
+      assert_equal 0, status
+      assert_includes out, "Wrote schedule template"
+      assert_equal "", err
+      assert File.file?(File.join("config", "schedule.rb"))
+    end
+  end
+
+  def test_init_refuses_overwrite_without_force
+    with_project_dir do
+      path = File.join("config", "schedule.rb")
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, "# existing\n")
+
+      status, out, err = run_cli(["init"])
+      assert_equal 1, status
+      assert_equal "", out
+      assert_includes err, "already exists"
+    end
+  end
+
+  def test_init_overwrites_with_force
+    with_project_dir do
+      path = File.join("config", "schedule.rb")
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, "# existing\n")
+
+      status, out, err = run_cli(["init", "--force"])
+      assert_equal 0, status
+      assert_includes out, "Overwrote schedule template"
+      assert_equal "", err
+      assert_includes File.read(path), "every \"5m\""
+    end
+  end
+
+  def test_init_handles_filesystem_errors
+    with_project_dir do
+      FileUtils.mkdir_p("config")
+      status, out, err = run_cli(["init", "--schedule", "config", "--force"])
+      assert_equal 1, status
+      assert_equal "", out
+      assert_includes err, "Is a directory"
+    end
+  end
+
+  def test_init_verbose_includes_error_details
+    with_project_dir do
+      FileUtils.mkdir_p("config")
+      status, out, err = run_cli(["init", "--schedule", "config", "--force", "--verbose"])
+      assert_equal 1, status
+      assert_equal "", out
+      assert_includes err, "Is a directory"
+      assert_includes err, "lib/wheneverd/cli/init.rb"
+    end
+  end
+end
+
+class CLIShowTest < Minitest::Test
+  include CLITestHelpers
+
+  EXPECTED_SHOW_OUTPUT_SNIPPETS = [
+    "OnActiveSec=300",
+    "OnUnitActiveSec=300",
+    "OnCalendar=hourly",
+    "OnCalendar=*-*-27..31 00:00:00",
+    "ExecStart=echo hello"
+  ].freeze
+
+  def test_show_renders_units_to_stdout
+    with_project_dir do
+      assert_equal 0, run_cli(["init"]).first
+      status, out, err = run_cli(["show", "--identifier", "demo"])
+
+      assert_equal 0, status
+      assert_equal "", err
+      EXPECTED_SHOW_OUTPUT_SNIPPETS.each { |expected| assert_includes out, expected }
+    end
+  end
+
+  def test_show_reports_missing_schedule_file
+    with_project_dir do
+      status, out, err = run_cli(["show"])
+      assert_equal 1, status
+      assert_equal "", out
+      assert_includes err, "Schedule file not found"
+      assert_includes err, "config/schedule.rb"
+    end
+  end
+end
+
+class CLIWriteTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_write_creates_unit_files_in_unit_dir
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      assert_equal 0, run_cli(["init"]).first
+      status, out, err = run_write(unit_dir)
+
+      assert_cli_success(status, err)
+      assert_first_job_written(unit_dir, out)
+    end
+  end
+
+  def test_write_dry_run_does_not_create_files
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      assert_equal 0, run_cli(["init"]).first
+      status, out, err = run_write(unit_dir, "--dry-run")
+
+      assert_equal 0, status
+      assert_equal "", err
+      assert_includes out, File.join(unit_dir, expected_timer_basenames.fetch(0))
+      refute Dir.exist?(unit_dir)
+    end
+  end
+
+  def test_write_prunes_old_units_by_default
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      units1 = write_schedule_and_expected_units(schedule_with_two_jobs)
+      write_and_assert_success(unit_dir)
+      assert_unit_files_present(unit_dir, units1)
+      units2 = write_schedule_and_expected_units(schedule_with_one_job)
+      write_and_assert_success(unit_dir)
+      assert_unit_files_pruned(unit_dir, units_before: units1, units_after: units2)
+    end
+  end
+
+  def test_write_no_prune_keeps_old_units
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      units1 = write_schedule_and_expected_units(schedule_with_two_jobs)
+
+      status, _out, err = run_write(unit_dir)
+      assert_cli_success(status, err)
+
+      write_schedule(schedule_with_one_job)
+      status, _out, err = run_write(unit_dir, "--no-prune")
+      assert_cli_success(status, err)
+
+      assert_unit_files_present(unit_dir, units1)
+    end
+  end
+
+  def test_write_reports_missing_schedule_file
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      status, out, err = run_cli(["write", "--unit-dir", unit_dir])
+      assert_equal 1, status
+      assert_equal "", out
+      assert_includes err, "Schedule file not found"
+    end
+  end
+
+  def write_schedule(contents)
+    path = File.join("config", "schedule.rb")
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, contents)
+  end
+
+  def schedule_with_two_jobs
+    <<~RUBY
+      # frozen_string_literal: true
+
+      every "1m" do
+        command "echo a"
+      end
+
+      every "2m" do
+        command "echo b"
+      end
+    RUBY
+  end
+
+  def schedule_with_one_job
+    <<~RUBY
+      # frozen_string_literal: true
+
+      every "1m" do
+        command "echo a"
+      end
+    RUBY
+  end
+
+  private
+
+  def run_write(unit_dir, *extra_args)
+    run_cli(["write", "--identifier", "demo", "--unit-dir", unit_dir, *extra_args])
+  end
+
+  def assert_first_job_written(unit_dir, out)
+    assert_includes out, File.join(unit_dir, expected_service_basenames.fetch(0))
+    assert File.exist?(File.join(unit_dir, expected_timer_basenames.fetch(0)))
+  end
+
+  def write_schedule_and_expected_units(contents)
+    write_schedule(contents)
+    expected_units(identifier: "demo")
+  end
+
+  def assert_unit_files_present(unit_dir, units)
+    units.each { |unit| assert File.exist?(File.join(unit_dir, unit.path_basename)) }
+  end
+
+  def assert_unit_files_pruned(unit_dir, units_before:, units_after:)
+    keep = units_after.map(&:path_basename)
+    stale = units_before.map(&:path_basename) - keep
+
+    keep.each { |basename| assert File.exist?(File.join(unit_dir, basename)) }
+    stale.each { |basename| refute File.exist?(File.join(unit_dir, basename)) }
+  end
+
+  def write_and_assert_success(unit_dir, *extra_args)
+    status, _out, err = run_write(unit_dir, *extra_args)
+    assert_cli_success(status, err)
+  end
+end
+
+class CLIDeleteTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_delete_removes_units_for_identifier
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      init_template_schedule
+      write_demo_units(unit_dir)
+
+      status, out, err = delete_demo_units(unit_dir)
+      assert_cli_success(status, err)
+      assert_demo_timer_deleted(unit_dir, out)
+    end
+  end
+
+  def test_delete_reports_invalid_identifier
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      FileUtils.mkdir_p(unit_dir)
+
+      status, out, err = run_cli(["delete", "--identifier", "!!!", "--unit-dir", unit_dir])
+      assert_equal 1, status
+      assert_equal "", out
+      assert_includes err, "identifier must include at least one alphanumeric character"
+    end
+  end
+
+  private
+
+  def init_template_schedule
+    assert_equal 0, run_cli(["init"]).first
+  end
+
+  def write_demo_units(unit_dir)
+    assert_equal 0, run_cli(["write", "--identifier", "demo", "--unit-dir", unit_dir]).first
+  end
+
+  def delete_demo_units(unit_dir)
+    run_cli(["delete", "--identifier", "demo", "--unit-dir", unit_dir])
+  end
+
+  def assert_demo_timer_deleted(unit_dir, out)
+    expected_timer = expected_timer_basenames.fetch(0)
+    expected_timer_path = File.join(unit_dir, expected_timer)
+    assert_includes out, expected_timer_path
+    refute File.exist?(expected_timer_path)
+  end
+end
+
+class CLIVerboseTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_verbose_prints_error_details
+    with_project_dir do
+      status, out, err = run_cli(["show", "--verbose"])
+      assert_equal 1, status
+      assert_equal "", out
+      assert_includes err, "Schedule file not found"
+      assert_includes err, "lib/wheneverd/cli.rb"
+    end
+  end
+end

data/test/domain_model_test.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class DomainModelTest < Minitest::Test
+  def test_interval_parses_supported_units
+    assert_equal 30, Wheneverd::Interval.parse("30s")
+    assert_equal 300, Wheneverd::Interval.parse("5m")
+    assert_equal 3600, Wheneverd::Interval.parse("1h")
+    assert_equal 86_400, Wheneverd::Interval.parse("1d")
+    assert_equal 604_800, Wheneverd::Interval.parse("1w")
+  end
+
+  def test_interval_rejects_invalid_inputs
+    error = assert_raises(Wheneverd::InvalidIntervalError) { Wheneverd::Interval.parse("abc") }
+    assert_includes error.message, "Invalid interval"
+
+    assert_raises(Wheneverd::InvalidIntervalError) { Wheneverd::Interval.parse("0m") }
+    assert_raises(Wheneverd::InvalidIntervalError) { Wheneverd::Interval.parse("-5m") }
+    assert_raises(Wheneverd::InvalidIntervalError) { Wheneverd::Interval.parse("5") }
+    assert_raises(Wheneverd::InvalidIntervalError) { Wheneverd::Interval.parse("5mm") }
+    assert_raises(Wheneverd::InvalidIntervalError) { Wheneverd::Interval.parse(nil) }
+  end
+
+  def test_duration_wraps_seconds
+    duration = Wheneverd::Duration.new(42)
+    assert_equal 42, duration.seconds
+    assert_equal 42, duration.to_i
+
+    assert_raises(ArgumentError) { Wheneverd::Duration.new(1.0) }
+    assert_raises(ArgumentError) { Wheneverd::Duration.new(0) }
+  end
+
+  def test_numeric_duration_helpers_singular
+    assert_equal 1, 1.second.to_i
+    assert_equal 60, 1.minute.to_i
+    assert_equal 3600, 1.hour.to_i
+    assert_equal 86_400, 1.day.to_i
+    assert_equal 604_800, 1.week.to_i
+  end
+
+  def test_numeric_duration_helpers_plural_seconds_and_minutes
+    assert_equal 2, 2.seconds.to_i
+    assert_equal 120, 2.minutes.to_i
+  end
+
+  def test_numeric_duration_helpers_plural_hours_days_weeks
+    assert_equal 7200, 2.hours.to_i
+    assert_equal 172_800, 2.days.to_i
+    assert_equal 1_209_600, 2.weeks.to_i
+
+    error = assert_raises(ArgumentError) { 1.5.hours }
+    assert_includes error.message, "Integer receiver"
+  end
+
+  def test_job_command_validates_command
+    command = Wheneverd::Job::Command.new(command: " echo hello ")
+    assert_equal "echo hello", command.command
+
+    assert_raises(Wheneverd::InvalidCommandError) { Wheneverd::Job::Command.new(command: "") }
+    assert_raises(Wheneverd::InvalidCommandError) { Wheneverd::Job::Command.new(command: "   ") }
+
+    error = assert_raises(Wheneverd::InvalidCommandError) { Wheneverd::Job::Command.new(command: 123) }
+    assert_includes error.message, "String"
+  end
+
+  def test_triggers_render_timer_lines
+    interval = Wheneverd::Trigger::Interval.new(seconds: 60)
+    assert_equal ["OnActiveSec=60", "OnUnitActiveSec=60"], interval.systemd_timer_lines
+
+    boot = Wheneverd::Trigger::Boot.new(seconds: 5)
+    assert_equal ["OnBootSec=5"], boot.systemd_timer_lines
+
+    calendar = Wheneverd::Trigger::Calendar.new(on_calendar: %w[hourly daily])
+    assert_equal ["OnCalendar=hourly", "OnCalendar=daily"], calendar.systemd_timer_lines
+  end
+
+  def test_trigger_validations
+    assert_raises(ArgumentError) { Wheneverd::Trigger::Interval.new(seconds: "60") }
+    assert_raises(ArgumentError) { Wheneverd::Trigger::Interval.new(seconds: 0) }
+
+    assert_raises(ArgumentError) { Wheneverd::Trigger::Boot.new(seconds: "1") }
+    assert_raises(ArgumentError) { Wheneverd::Trigger::Boot.new(seconds: 0) }
+
+    assert_raises(ArgumentError) { Wheneverd::Trigger::Calendar.new(on_calendar: []) }
+    assert_raises(ArgumentError) { Wheneverd::Trigger::Calendar.new(on_calendar: [" "]) }
+    assert_raises(ArgumentError) { Wheneverd::Trigger::Calendar.new(on_calendar: "hourly") }
+  end
+
+  def test_entry_is_an_ordered_container
+    entry = Wheneverd::Entry.new(trigger: Wheneverd::Trigger::Interval.new(seconds: 60))
+    assert_equal [], entry.jobs
+    entry.add_job(Wheneverd::Job::Command.new(command: "echo hi"))
+    assert_equal 1, entry.jobs.length
+  end
+
+  def test_schedule_is_an_ordered_container
+    schedule = Wheneverd::Schedule.new
+    assert_equal [], schedule.entries
+    entry = Wheneverd::Entry.new(trigger: Wheneverd::Trigger::Interval.new(seconds: 60))
+    schedule.add_entry(entry)
+    assert_equal [entry], schedule.entries
+  end
+
+  def test_entry_requires_a_trigger
+    assert_raises(ArgumentError) { Wheneverd::Entry.new(trigger: nil) }
+  end
+end

data/test/dsl_calendar_symbol_period_list_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class DSLCalendarSymbolPeriodListTest < Minitest::Test
+  def test_validate_raises_when_not_array
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) do
+      Wheneverd::DSL::CalendarSymbolPeriodList.validate(
+        "day",
+        allowed_symbols: [:day],
+        path: "x.rb"
+      )
+    end
+    assert_includes error.message, "non-empty Array"
+  end
+
+  def test_validate_raises_when_empty_array
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) do
+      Wheneverd::DSL::CalendarSymbolPeriodList.validate(
+        [],
+        allowed_symbols: [:day],
+        path: "x.rb"
+      )
+    end
+    assert_includes error.message, "non-empty Array"
+  end
+
+  def test_validate_raises_when_array_contains_non_symbols
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) do
+      Wheneverd::DSL::CalendarSymbolPeriodList.validate([:day, "hour"], allowed_symbols: [:day],
+                                                                        path: "x.rb")
+    end
+    assert_includes error.message, "must be Symbols"
+  end
+
+  def test_validate_raises_when_symbols_are_unknown
+    error = assert_raises(Wheneverd::DSL::InvalidPeriodError) do
+      Wheneverd::DSL::CalendarSymbolPeriodList.validate(%i[day nope nope], allowed_symbols: [:day],
+                                                                           path: "x.rb")
+    end
+    assert_includes error.message, "Unknown period symbol"
+    assert_includes error.message, ":nope"
+  end
+
+  def test_validate_returns_periods_when_valid
+    result = Wheneverd::DSL::CalendarSymbolPeriodList.validate(
+      %i[day day],
+      allowed_symbols: [:day],
+      path: "x.rb"
+    )
+    assert_equal %i[day day], result
+  end
+end