wheneverd 0.1.0

data/test/systemd_renderer_errors_test.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class SystemdRendererErrorsTest < Minitest::Test
+  def test_rejects_empty_identifier
+    assert_raises(Wheneverd::Systemd::InvalidIdentifierError) do
+      Wheneverd::Systemd::Renderer.render(minimal_schedule, identifier: "  ")
+    end
+  end
+
+  def test_rejects_identifier_without_alphanumeric_chars
+    assert_raises(Wheneverd::Systemd::InvalidIdentifierError) do
+      Wheneverd::Systemd::Renderer.render(minimal_schedule, identifier: "!!!")
+    end
+  end
+
+  def test_sanitizes_identifier_into_unit_basename
+    units = Wheneverd::Systemd::Renderer.render(minimal_schedule, identifier: "my app!")
+    matched = units.map(&:path_basename).any? do |basename|
+      /\Awheneverd-my-app-[0-9a-f]{12}\.timer\z/.match?(basename)
+    end
+    assert matched
+  end
+
+  def test_rejects_invalid_schedule_type
+    assert_raises(ArgumentError) do
+      Wheneverd::Systemd::Renderer.render(Object.new, identifier: "demo")
+    end
+  end
+
+  def test_rejects_unsupported_trigger_type
+    assert_raises(ArgumentError) do
+      Wheneverd::Systemd::Renderer.render(schedule_with_trigger(Object.new), identifier: "demo")
+    end
+  end
+
+  def test_rejects_unsupported_job_type
+    schedule = schedule_with_job(Object.new)
+    assert_raises(ArgumentError) do
+      Wheneverd::Systemd::Renderer.render(schedule, identifier: "demo")
+    end
+  end
+
+  def test_timer_lines_for_rejects_unknown_trigger
+    assert_raises(ArgumentError) do
+      Wheneverd::Systemd::Renderer.send(:timer_lines_for, Object.new)
+    end
+  end
+
+  private
+
+  def minimal_schedule
+    Wheneverd::Schedule.new(
+      entries: [
+        Wheneverd::Entry.new(
+          trigger: Wheneverd::Trigger::Interval.new(seconds: 60),
+          jobs: [Wheneverd::Job::Command.new(command: "echo hi")]
+        )
+      ]
+    )
+  end
+
+  def schedule_with_trigger(trigger)
+    Wheneverd::Schedule.new(
+      entries: [
+        Wheneverd::Entry.new(
+          trigger: trigger,
+          jobs: [Wheneverd::Job::Command.new(command: "echo hi")]
+        )
+      ]
+    )
+  end
+
+  def schedule_with_job(job)
+    Wheneverd::Schedule.new(
+      entries: [
+        Wheneverd::Entry.new(
+          trigger: Wheneverd::Trigger::Interval.new(seconds: 60),
+          jobs: [job]
+        )
+      ]
+    )
+  end
+end

data/test/systemd_renderer_test.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module SystemdRendererTestHelpers
+  def render_units(entries, identifier: "demo")
+    Wheneverd::Systemd::Renderer.render(Wheneverd::Schedule.new(entries: entries),
+                                        identifier: identifier)
+  end
+
+  def timer_for(entry, identifier: "demo")
+    render_units([entry], identifier: identifier).find { |u| u.kind == :timer }
+  end
+
+  def service_for(entry, identifier: "demo")
+    render_units([entry], identifier: identifier).find { |u| u.kind == :service }
+  end
+
+  def interval_entry(seconds:, command:)
+    Wheneverd::Entry.new(
+      trigger: Wheneverd::Trigger::Interval.new(seconds: seconds),
+      jobs: [Wheneverd::Job::Command.new(command: command)]
+    )
+  end
+
+  def boot_entry(seconds:, command:)
+    Wheneverd::Entry.new(
+      trigger: Wheneverd::Trigger::Boot.new(seconds: seconds),
+      jobs: [Wheneverd::Job::Command.new(command: command)]
+    )
+  end
+
+  def calendar_entry(spec:, command:)
+    Wheneverd::Entry.new(
+      trigger: Wheneverd::Trigger::Calendar.new(on_calendar: [spec]),
+      jobs: [Wheneverd::Job::Command.new(command: command)]
+    )
+  end
+
+  def marker
+    "# Generated by wheneverd (wheneverd) #{Wheneverd::VERSION}; do not edit."
+  end
+end
+
+class SystemdRendererIntervalTest < Minitest::Test
+  include SystemdRendererTestHelpers
+
+  def test_interval_timer_contains_required_fields
+    timer = timer_for(interval_entry(seconds: 60, command: "echo hello"))
+    refute_nil timer
+    assert_includes timer.contents, marker
+    assert_includes timer.contents, "OnActiveSec=60"
+    assert_includes timer.contents, "OnUnitActiveSec=60"
+    assert_includes timer.contents, "Persistent=true"
+    assert_includes timer.contents, "WantedBy=timers.target"
+  end
+
+  def test_interval_service_contains_execstart
+    service = service_for(interval_entry(seconds: 60, command: "echo hello"))
+    refute_nil service
+    assert_includes service.contents, marker
+    assert_includes service.contents, "Type=oneshot"
+    assert_includes service.contents, "ExecStart=echo hello"
+  end
+end
+
+class SystemdRendererCalendarTest < Minitest::Test
+  include SystemdRendererTestHelpers
+
+  def test_calendar_hour_translates_to_hourly
+    timer = timer_for(calendar_entry(spec: "hour", command: "echo hourly"))
+    assert_includes timer.contents, "OnCalendar=hourly"
+  end
+
+  def test_calendar_day_at_translates_to_date_time
+    timer = timer_for(calendar_entry(spec: "day@4:30 am", command: "echo four_thirty"))
+    assert_includes timer.contents, "OnCalendar=*-*-* 04:30:00"
+  end
+
+  def test_calendar_sunday_at_translates_to_day_of_week
+    timer = timer_for(calendar_entry(spec: "sunday@12pm", command: "echo weekly"))
+    assert_includes timer.contents, "OnCalendar=Sun *-*-* 12:00:00"
+  end
+
+  def test_cron_example_translates_to_expected_on_calendar
+    timer = timer_for(calendar_entry(spec: "cron:0 0 27-31 * *", command: "echo raw_cron"))
+    assert_includes timer.contents, "OnCalendar=*-*-27..31 00:00:00"
+  end
+
+  def test_cron_with_day_of_month_and_day_of_week_expands_to_multiple_on_calendar_lines
+    timer = timer_for(calendar_entry(spec: "cron:0 0 1 * Mon", command: "echo raw_cron"))
+    assert_includes timer.contents, "OnCalendar=Mon *-*-* 00:00:00"
+    assert_includes timer.contents, "OnCalendar=*-*-1 00:00:00"
+  end
+end
+
+class SystemdRendererNamingTest < Minitest::Test
+  include SystemdRendererTestHelpers
+
+  def test_naming_is_deterministic
+    entries = entries_for_determinism
+    units1 = render_units(entries, identifier: "my-app")
+    units2 = render_units(entries, identifier: "my-app")
+    assert_equal units1.map(&:path_basename), units2.map(&:path_basename)
+    assert_equal units1.map(&:contents), units2.map(&:contents)
+  end
+
+  def test_units_keep_names_across_entry_reordering
+    entry_a = interval_entry(seconds: 60, command: "echo a")
+    entry_b = boot_entry(seconds: 60, command: "echo b")
+
+    units1 = render_units([entry_a, entry_b], identifier: "my-app").sort_by(&:path_basename)
+    units2 = render_units([entry_b, entry_a], identifier: "my-app").sort_by(&:path_basename)
+
+    assert_equal units1.map(&:path_basename), units2.map(&:path_basename)
+    assert_equal units1.map(&:contents), units2.map(&:contents)
+  end
+
+  def test_duplicate_jobs_get_disambiguated_unit_ids
+    timer_basenames = timer_basenames_for_entries([duplicate_job_entry], identifier: "my-app")
+    assert_equal 2, timer_basenames.length
+    assert_disambiguated_timer_basenames(timer_basenames)
+  end
+
+  private
+
+  def entries_for_determinism
+    [
+      Wheneverd::Entry.new(trigger: Wheneverd::Trigger::Interval.new(seconds: 60), jobs: jobs_a_b),
+      boot_entry(seconds: 60, command: "echo c")
+    ]
+  end
+
+  def jobs_a_b
+    [
+      Wheneverd::Job::Command.new(command: "echo a"),
+      Wheneverd::Job::Command.new(command: "echo b")
+    ]
+  end
+
+  def duplicate_job_entry
+    Wheneverd::Entry.new(
+      trigger: Wheneverd::Trigger::Interval.new(seconds: 60),
+      jobs: [
+        Wheneverd::Job::Command.new(command: "echo a"),
+        Wheneverd::Job::Command.new(command: "echo a")
+      ]
+    )
+  end
+
+  def timer_basenames_for_entries(entries, identifier:)
+    render_units(entries, identifier: identifier)
+      .map(&:path_basename)
+      .select { |b| b.end_with?(".timer") }
+  end
+
+  def assert_disambiguated_timer_basenames(timer_basenames)
+    assert(timer_basenames.any? { |b| /\Awheneverd-my-app-[0-9a-f]{12}-1\.timer\z/.match?(b) })
+    assert(timer_basenames.any? { |b| /\Awheneverd-my-app-[0-9a-f]{12}-2\.timer\z/.match?(b) })
+  end
+end

data/test/systemd_systemctl_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class SystemdSystemctlTest < Minitest::Test
+  def with_capture3_stub(exitstatus:, 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 test_run_builds_user_systemctl_command_and_returns_output
+    with_capture3_stub(exitstatus: 0, stdout: "ok\n", stderr: "") do |calls|
+      out, err = Wheneverd::Systemd::Systemctl.run("daemon-reload")
+      assert_equal "ok\n", out
+      assert_equal "", err
+      assert_equal [["systemctl", "--user", "--no-pager", "daemon-reload"], {}], calls.fetch(0)
+    end
+  end
+
+  def test_run_omits_user_flag_when_user_false
+    with_capture3_stub(exitstatus: 0) do |calls|
+      Wheneverd::Systemd::Systemctl.run("daemon-reload", user: false)
+      refute_includes calls.fetch(0).fetch(0), "--user"
+    end
+  end
+
+  def test_run_raises_systemctl_error_on_failure_with_details
+    with_capture3_stub(exitstatus: 1, stdout: "oops\n", stderr: "nope\n") do
+      error = assert_raises(Wheneverd::Systemd::SystemctlError) do
+        Wheneverd::Systemd::Systemctl.run("daemon-reload")
+      end
+
+      assert_includes error.message, "status: 1"
+      assert_includes error.message, "stdout: oops"
+      assert_includes error.message, "stderr: nope"
+    end
+  end
+end

data/test/systemd_time_parser_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class SystemdTimeParserTest < Minitest::Test
+  def test_parses_12h_times
+    assert_equal "04:30:00", Wheneverd::Systemd::TimeParser.parse("4:30 am")
+    assert_equal "18:00:00", Wheneverd::Systemd::TimeParser.parse("6:00 pm")
+    assert_equal "12:00:00", Wheneverd::Systemd::TimeParser.parse("12pm")
+    assert_equal "00:00:00", Wheneverd::Systemd::TimeParser.parse("12 am")
+  end
+
+  def test_parses_24h_times
+    assert_equal "00:15:00", Wheneverd::Systemd::TimeParser.parse("00:15")
+    assert_equal "23:59:59", Wheneverd::Systemd::TimeParser.parse("23:59:59")
+  end
+
+  def test_rejects_invalid_times
+    assert_raises(Wheneverd::Systemd::InvalidTimeError) { Wheneverd::Systemd::TimeParser.parse("") }
+    assert_raises(Wheneverd::Systemd::InvalidTimeError) { Wheneverd::Systemd::TimeParser.parse("25:00") }
+    assert_raises(Wheneverd::Systemd::InvalidTimeError) { Wheneverd::Systemd::TimeParser.parse("12:99") }
+    assert_raises(Wheneverd::Systemd::InvalidTimeError) { Wheneverd::Systemd::TimeParser.parse("0pm") }
+    assert_raises(Wheneverd::Systemd::InvalidTimeError) { Wheneverd::Systemd::TimeParser.parse("nope") }
+  end
+end

data/test/systemd_unit_deleter_test.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "tmpdir"
+
+class SystemdUnitDeleterTest < Minitest::Test
+  def test_delete_rejects_invalid_identifier
+    Dir.mktmpdir("wheneverd-") do |dir|
+      assert_raises(Wheneverd::Systemd::InvalidIdentifierError) do
+        Wheneverd::Systemd::UnitDeleter.delete(identifier: "!!!", unit_dir: dir)
+      end
+    end
+  end
+
+  def test_delete_deletes_only_generated_files_for_identifier
+    with_written_units do |unit_dir, written_paths|
+      create_non_generated_match(unit_dir, "demo")
+      deleted = Wheneverd::Systemd::UnitDeleter.delete(identifier: "demo", unit_dir: unit_dir)
+      assert_equal written_paths.sort, deleted.sort
+      written_paths.each { |p| refute File.exist?(p) }
+      assert File.exist?(File.join(unit_dir, "wheneverd-demo-000000000000.timer"))
+    end
+  end
+
+  def test_delete_does_not_delete_other_identifier_or_non_matching_files
+    with_written_units do |unit_dir, _written_paths|
+      create_generated_different_identifier(unit_dir)
+      File.write(File.join(unit_dir, "other.timer"), "#{marker_line}\n")
+      Wheneverd::Systemd::UnitDeleter.delete(identifier: "demo", unit_dir: unit_dir)
+      assert File.exist?(File.join(unit_dir, "wheneverd-other-000000000000.timer"))
+      assert File.exist?(File.join(unit_dir, "other.timer"))
+    end
+  end
+
+  def test_delete_dry_run_does_not_remove_files
+    with_written_units do |unit_dir, written_paths|
+      deleted = Wheneverd::Systemd::UnitDeleter.delete(identifier: "demo", unit_dir: unit_dir,
+                                                       dry_run: true)
+      assert_equal written_paths.sort, deleted.sort
+      written_paths.each { |p| assert File.exist?(p) }
+    end
+  end
+
+  private
+
+  def with_written_units
+    Dir.mktmpdir("wheneverd-") do |dir|
+      unit_dir = File.join(dir, "systemd", "user")
+      written_paths = Wheneverd::Systemd::UnitWriter.write(demo_units, unit_dir: unit_dir)
+      yield unit_dir, written_paths
+    end
+  end
+
+  def demo_units
+    Wheneverd::Systemd::Renderer.render(schedule_with_interval_job("echo hello"),
+                                        identifier: "demo")
+  end
+
+  def schedule_with_interval_job(command)
+    Wheneverd::Schedule.new(
+      entries: [
+        Wheneverd::Entry.new(
+          trigger: Wheneverd::Trigger::Interval.new(seconds: 60),
+          jobs: [Wheneverd::Job::Command.new(command: command)]
+        )
+      ]
+    )
+  end
+
+  def marker_line
+    "#{Wheneverd::Systemd::Renderer::MARKER_PREFIX} #{Wheneverd::VERSION}; do not edit."
+  end
+
+  def create_non_generated_match(unit_dir, identifier)
+    path = File.join(unit_dir, "wheneverd-#{identifier}-000000000000.timer")
+    File.write(path, "[Timer]\nOnCalendar=daily\n")
+  end
+
+  def create_generated_different_identifier(unit_dir)
+    path = File.join(unit_dir, "wheneverd-other-000000000000.timer")
+    File.write(path, "#{marker_line}\n[Timer]\nOnCalendar=daily\n")
+  end
+end

data/test/systemd_unit_writer_prune_test.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "tmpdir"
+
+class SystemdUnitWriterPruneTest < Minitest::Test
+  def test_write_prune_rejects_invalid_identifier
+    with_unit_dir do |unit_dir|
+      assert_raises(Wheneverd::Systemd::InvalidIdentifierError) do
+        Wheneverd::Systemd::UnitWriter.write(
+          [],
+          unit_dir: unit_dir,
+          prune: true,
+          identifier: "!!!"
+        )
+      end
+    end
+  end
+
+  def test_write_prune_removes_stale_units
+    with_unit_dir do |unit_dir|
+      units1 = rendered_units_for_commands(["echo a", "echo b"])
+      write_units(unit_dir, units1, prune: true)
+
+      units2 = rendered_units_for_commands(["echo a"])
+      write_units(unit_dir, units2, prune: true)
+
+      assert_unit_files_pruned(unit_dir, units_before: units1, units_after: units2)
+    end
+  end
+
+  def test_write_no_prune_keeps_stale_units
+    with_unit_dir do |unit_dir|
+      units1 = rendered_units_for_commands(["echo a", "echo b"])
+      Wheneverd::Systemd::UnitWriter.write(units1, unit_dir: unit_dir)
+
+      units2 = rendered_units_for_commands(["echo a"])
+      write_units(unit_dir, units2, prune: false)
+
+      assert_unit_files_present(unit_dir, units1)
+    end
+  end
+
+  private
+
+  def rendered_units_for_commands(commands)
+    schedule = Wheneverd::Schedule.new(
+      entries: commands.map do |command|
+        Wheneverd::Entry.new(
+          trigger: Wheneverd::Trigger::Interval.new(seconds: 60),
+          jobs: [Wheneverd::Job::Command.new(command: command)]
+        )
+      end
+    )
+    Wheneverd::Systemd::Renderer.render(schedule, identifier: "demo")
+  end
+
+  def write_units(unit_dir, units, prune:)
+    Wheneverd::Systemd::UnitWriter.write(
+      units,
+      unit_dir: unit_dir,
+      prune: prune,
+      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 with_unit_dir
+    Dir.mktmpdir("wheneverd-") do |dir|
+      unit_dir = File.join(dir, "systemd", "user")
+      yield unit_dir
+    end
+  end
+end

data/test/systemd_unit_writer_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "tmpdir"
+
+class SystemdUnitWriterTest < Minitest::Test
+  def test_write_creates_directory
+    with_unit_dir do |unit_dir|
+      refute Dir.exist?(unit_dir)
+      Wheneverd::Systemd::UnitWriter.write(demo_units, unit_dir: unit_dir)
+      assert Dir.exist?(unit_dir)
+    end
+  end
+
+  def test_write_returns_full_paths_in_unit_order
+    with_unit_dir do |unit_dir|
+      units = demo_units
+      paths = Wheneverd::Systemd::UnitWriter.write(units, unit_dir: unit_dir)
+      assert_equal expected_paths(unit_dir, units), paths
+    end
+  end
+
+  def test_write_writes_expected_contents
+    with_unit_dir do |unit_dir|
+      units = demo_units
+      Wheneverd::Systemd::UnitWriter.write(units, unit_dir: unit_dir)
+      units.each { |u| assert_equal u.contents, File.read(File.join(unit_dir, u.path_basename)) }
+    end
+  end
+
+  def test_write_dry_run_does_not_create_dir_or_files
+    with_unit_dir do |unit_dir|
+      paths = Wheneverd::Systemd::UnitWriter.write(units, unit_dir: unit_dir, dry_run: true)
+      assert_equal expected_paths(unit_dir, units), paths
+      refute Dir.exist?(unit_dir)
+    end
+  end
+
+  private
+
+  def units
+    @units ||= demo_units
+  end
+
+  def demo_units
+    Wheneverd::Systemd::Renderer.render(schedule_with_interval_job("echo hello"),
+                                        identifier: "demo")
+  end
+
+  def schedule_with_interval_job(command)
+    Wheneverd::Schedule.new(
+      entries: [
+        Wheneverd::Entry.new(
+          trigger: Wheneverd::Trigger::Interval.new(seconds: 60),
+          jobs: [Wheneverd::Job::Command.new(command: command)]
+        )
+      ]
+    )
+  end
+
+  def with_unit_dir
+    Dir.mktmpdir("wheneverd-") do |dir|
+      unit_dir = File.join(dir, "systemd", "user")
+      yield unit_dir
+    end
+  end
+
+  def expected_paths(unit_dir, units)
+    units.map { |u| File.join(unit_dir, u.path_basename) }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "simplecov"
+require "open3"
+
+SimpleCov.start do
+  add_filter "/test/"
+  minimum_coverage ENV.fetch("MINIMUM_COVERAGE", "100").to_i
+end
+
+module Open3Capture3TestStub
+  Status = Struct.new(:exitstatus) do
+    def success?
+      exitstatus.zero?
+    end
+  end
+
+  def capture3(*cmd, **kwargs)
+    stub = Thread.current[:open3_capture3_stub]
+    return super unless stub
+
+    stub.fetch(:calls) << [cmd, kwargs]
+    [
+      stub.fetch(:stdout, ""),
+      stub.fetch(:stderr, ""),
+      Status.new(stub.fetch(:exitstatus, 0))
+    ]
+  end
+end
+
+Open3.singleton_class.prepend(Open3Capture3TestStub)
+
+require "minitest/autorun"
+require "wheneverd"

data/test/wheneverd_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class WheneverdTest < Minitest::Test
+  def test_has_a_version_number
+    refute_nil ::Wheneverd::VERSION
+  end
+end

data/wheneverd.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "lib/wheneverd/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "wheneverd"
+  spec.version = Wheneverd::VERSION
+  spec.authors = ["Dr. Samuel Goebert"]
+  spec.email = ["maintainers@example.com"]
+
+  spec.summary = "Wheneverd is to systemd timers what whenever is to cron."
+  spec.description =
+    "Generates systemd timer/service units from a Ruby DSL, similar in spirit " \
+    "to the whenever gem for cron."
+  spec.homepage = "https://github.com/bigcurl/wheneverd"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files =
+    begin
+      Dir.chdir(__dir__) { `git ls-files -z`.split("\x0").reject(&:empty?) }
+    rescue StandardError
+      Dir.glob("{bin,exe,lib,test}/**/*", File::FNM_DOTMATCH).reject { |f| File.directory?(f) }
+    end
+
+  spec.bindir = "exe"
+  spec.executables = ["wheneverd"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "clamp", "~> 1.3"
+end