wheneverd 0.2.0 → 0.3.0

data/lib/wheneverd/systemd/analyze.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Wheneverd
+  module Systemd
+    # Thin wrapper around `systemd-analyze`.
+    class Analyze
+      DEFAULT_SYSTEMD_ANALYZE = "systemd-analyze"
+
+      # Run `systemd-analyze calendar <value>`.
+      #
+      # @param value [String] an `OnCalendar=` value
+      # @param systemd_analyze [String] path to the `systemd-analyze` executable
+      # @return [Array(String, String)] stdout and stderr
+      # @raise [Wheneverd::Systemd::SystemdAnalyzeError]
+      def self.calendar(value, systemd_analyze: DEFAULT_SYSTEMD_ANALYZE)
+        run(systemd_analyze, "calendar", value.to_s)
+      end
+
+      # Run `systemd-analyze verify` for unit files.
+      #
+      # @param paths [Array<String>] unit file paths to verify
+      # @param user [Boolean] verify user units with `--user` (default: true)
+      # @param systemd_analyze [String] path to the `systemd-analyze` executable
+      # @return [Array(String, String)] stdout and stderr
+      # @raise [Wheneverd::Systemd::SystemdAnalyzeError]
+      def self.verify(paths, user: true, systemd_analyze: DEFAULT_SYSTEMD_ANALYZE)
+        run(systemd_analyze, "verify", *Array(paths).map(&:to_s), user: user)
+      end
+
+      def self.run(systemd_analyze, *args, user: false)
+        cmd = [systemd_analyze.to_s]
+        cmd << "--user" if user
+        cmd.concat(args.flatten.map(&:to_s))
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise SystemdAnalyzeError, format_error(cmd, status, stdout, stderr) unless status.success?
+
+        [stdout, stderr]
+      rescue Errno::ENOENT
+        raise SystemdAnalyzeError, "systemd-analyze not found (tried: #{systemd_analyze})"
+      end
+
+      def self.format_error(cmd, status, stdout, stderr)
+        details = []
+        details << "command: #{cmd.join(' ')}"
+        details << "status: #{status.exitstatus}"
+        details << "stdout: #{stdout.strip}" unless stdout.to_s.strip.empty?
+        details << "stderr: #{stderr.strip}" unless stderr.to_s.strip.empty?
+        "systemd-analyze failed (#{details.join(', ')})"
+      end
+      private_class_method :format_error
+    end
+  end
+end

data/lib/wheneverd/systemd/errors.rb

@@ -22,5 +22,8 @@ module Wheneverd
 
     # Raised when a `loginctl` invocation fails.
     class LoginctlError < Error; end
+
+    # Raised when a `systemd-analyze` invocation fails (or `systemd-analyze` is not available).
+    class SystemdAnalyzeError < Error; end
   end
 end

data/lib/wheneverd/systemd/unit_namer.rb

@@ -53,7 +53,7 @@ module Wheneverd
       def self.job_signature(job)
         case job
         when Wheneverd::Job::Command
-          "command:#{job.command}"
+          job.signature
         else
           raise ArgumentError, "Unsupported job type: #{job.class}"
         end

data/lib/wheneverd/version.rb

@@ -2,5 +2,5 @@
 
 module Wheneverd
   # Gem version.
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/wheneverd.rb

@@ -35,6 +35,7 @@ require_relative "wheneverd/systemd/cron_parser"
 require_relative "wheneverd/systemd/calendar_spec"
 require_relative "wheneverd/systemd/unit_namer"
 require_relative "wheneverd/systemd/renderer"
+require_relative "wheneverd/systemd/analyze"
 require_relative "wheneverd/systemd/systemctl"
 require_relative "wheneverd/systemd/loginctl"
 require_relative "wheneverd/systemd/unit_writer"

data/test/cli_diff_test.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_test_helpers"
+
+class CLIDiffTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_exits_one_and_shows_added_diff_when_units_are_not_installed
+    with_inited_unit_dir("missing_units") do |unit_dir|
+      timer = first_timer
+      status, out, err = run_diff(unit_dir)
+      assert_diff_added(status, out, err, unit_dir, timer)
+    end
+  end
+
+  def test_exits_zero_when_no_differences
+    with_installed_units do |unit_dir|
+      status, out, err = run_diff(unit_dir)
+      assert_equal 0, status
+      assert_equal "", err
+      assert_equal "", out
+    end
+  end
+
+  def test_exits_one_and_shows_removed_lines_when_installed_unit_was_modified
+    with_installed_units do |unit_dir|
+      timer = first_timer
+      File.open(File.join(unit_dir, timer), "a") { |f| f.puts "# local edit" }
+      status, out, err = run_diff(unit_dir)
+      assert_diff_contains(status, out, err, timer, "-# local edit")
+    end
+  end
+
+  def test_exits_one_and_shows_added_lines_when_installed_unit_is_missing_lines
+    with_installed_units do |unit_dir|
+      timer = first_timer
+      remove_exact_line(File.join(unit_dir, timer), "Persistent=true\n")
+      status, out, err = run_diff(unit_dir)
+      assert_diff_contains(status, out, err, timer, "+Persistent=true")
+    end
+  end
+
+  def test_exits_one_and_shows_diff_for_stale_units_on_disk
+    with_installed_units do |unit_dir|
+      stale_timer = "wheneverd-demo-000000000000.timer"
+      stale_path = write_stale_timer(unit_dir, stale_timer)
+      status, out, err = run_diff(unit_dir)
+      assert_diff_removed(status, out, err, stale_timer, stale_path)
+    end
+  end
+
+  def test_returns_two_on_error
+    with_project_dir do
+      status, out, err = run_cli(["diff", "--schedule", "missing.rb"])
+      assert_equal 2, status
+      assert_equal "", out
+      assert_includes err, "Schedule file not found"
+    end
+  end
+
+  private
+
+  def with_inited_unit_dir(name)
+    with_inited_project_dir do |project_dir|
+      yield File.join(project_dir, name)
+    end
+  end
+
+  def with_installed_units
+    with_inited_unit_dir("tmp_units") do |unit_dir|
+      assert_equal 0, run_cli(["write", "--identifier", "demo", "--unit-dir", unit_dir]).first
+      yield unit_dir
+    end
+  end
+
+  def run_diff(unit_dir)
+    run_cli(["diff", "--identifier", "demo", "--unit-dir", unit_dir])
+  end
+
+  def first_timer
+    expected_timer_basenames(identifier: "demo").fetch(0)
+  end
+
+  def remove_exact_line(path, line)
+    File.write(path, File.read(path).lines.reject { |l| l == line }.join)
+  end
+
+  def write_stale_timer(unit_dir, basename)
+    path = File.join(unit_dir, basename)
+    File.write(path, "#{Wheneverd::Systemd::Renderer::MARKER_PREFIX} test\n# stale\n")
+    path
+  end
+
+  def assert_diff_added(status, out, err, unit_dir, timer)
+    assert_equal 1, status
+    assert_equal "", err
+    assert_includes out, "diff --wheneverd #{timer}"
+    assert_includes out, "--- /dev/null"
+    assert_includes out, "+++ #{File.join(File.expand_path(unit_dir), timer)}"
+  end
+
+  def assert_diff_contains(status, out, err, timer, expected_line)
+    assert_equal 1, status
+    assert_equal "", err
+    assert_includes out, "diff --wheneverd #{timer}"
+    assert_includes out, expected_line
+  end
+
+  def assert_diff_removed(status, out, err, timer, path)
+    assert_equal 1, status
+    assert_equal "", err
+    assert_includes out, "diff --wheneverd #{timer}"
+    assert_includes out, "--- #{path}"
+    assert_includes out, "+++ /dev/null"
+    assert_includes out, "-# stale"
+  end
+end

data/test/cli_init_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_test_helpers"
+
+class CLIInitTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_writes_template_with_shell_and_argv_examples
+    with_project_dir do |project_dir|
+      status, out, err = run_cli(["init"])
+      assert_equal 0, status
+      assert_equal "", err
+      assert_includes out, "Wrote schedule template to"
+
+      schedule_path = File.join(project_dir, "config", "schedule.rb")
+      schedule = File.read(schedule_path)
+      assert_includes schedule, "command [\"echo\", \"hello world\"]"
+      assert_includes schedule, "shell \"echo hello | sed -e s/hello/hi/\""
+    end
+  end
+
+  def test_refuses_to_overwrite_without_force
+    with_project_dir do
+      assert_equal 0, run_cli(["init"]).first
+
+      status, out, err = run_cli(["init"])
+      assert_equal 1, status
+      assert_equal "", out
+      assert_includes err, "already exists"
+      assert_includes err, "--force"
+    end
+  end
+
+  def test_overwrites_with_force
+    with_project_dir do |project_dir|
+      assert_equal 0, run_cli(["init"]).first
+
+      schedule_path = File.join(project_dir, "config", "schedule.rb")
+      File.write(schedule_path, "# custom\n")
+
+      status, out, err = run_cli(["init", "--force"])
+      assert_equal 0, status
+      assert_equal "", err
+      assert_includes out, "Overwrote schedule template to"
+      assert_includes File.read(schedule_path), "Supported `every` period forms:"
+    end
+  end
+end

data/test/cli_status_test.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_test_helpers"
+
+class CLIStatusTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_runs_list_timers_and_status_for_each_installed_timer
+    with_installed_units do |unit_dir|
+      status, _out, err, calls = run_status(unit_dir)
+      assert_cli_success(status, err)
+      assert_status_calls(calls, expected_timer_units)
+    end
+  end
+
+  def test_returns_nonzero_when_systemctl_fails
+    with_installed_units do |unit_dir|
+      status, _out, err, calls = run_status(unit_dir, exitstatus: 1, stderr: "boom\n")
+      assert_equal 1, status
+      assert_includes err, "systemctl failed"
+      assert_includes err, "boom"
+      assert_includes calls.fetch(0).fetch(0), "list-timers"
+    end
+  end
+
+  def test_exits_zero_and_does_not_call_systemctl_when_no_timers_installed
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "empty_units")
+      FileUtils.mkdir_p(unit_dir)
+      status, out, err, calls = run_status(unit_dir)
+      assert_cli_success(status, err)
+      assert_equal "", out
+      assert_equal [], calls
+    end
+  end
+
+  private
+
+  def with_installed_units
+    with_inited_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      assert_equal 0, run_cli(["write", "--identifier", "demo", "--unit-dir", unit_dir]).first
+      yield unit_dir
+    end
+  end
+
+  def run_status(unit_dir, **kwargs)
+    run_cli_with_capture3_stub(["status", "--identifier", "demo", "--unit-dir", unit_dir], **kwargs)
+  end
+
+  def expected_timer_units
+    expected_timer_basenames(identifier: "demo").sort
+  end
+
+  def assert_status_calls(calls, expected_timers)
+    assert_list_timers_call(calls, expected_timers)
+    assert_status_unit_calls(calls, expected_timers)
+  end
+
+  def assert_list_timers_call(calls, expected_timers)
+    assert_systemctl_call_starts_with(
+      calls,
+      0,
+      SYSTEMCTL_USER_PREFIX + ["list-timers", "--all"],
+      includes: expected_timers
+    )
+  end
+
+  def assert_status_unit_calls(calls, expected_timers)
+    status_calls = calls.drop(1).map(&:first)
+    assert_equal expected_timers.length, status_calls.length
+    assert_equal expected_timers, status_calls.map(&:last).sort
+    status_calls.each { |args| assert_equal SYSTEMCTL_USER_PREFIX + ["status", args.last], args }
+  end
+end

data/test/cli_validate_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_test_helpers"
+
+class CLIValidateTest < Minitest::Test
+  include CLITestHelpers
+
+  DUP_HOURLY_SCHEDULE = <<~RUBY
+    # frozen_string_literal: true
+
+    every :hour do
+      command "echo a"
+    end
+
+    every :hour do
+      command "echo b"
+    end
+  RUBY
+
+  HOURLY_SCHEDULE = <<~RUBY
+    # frozen_string_literal: true
+
+    every :hour do
+      command "echo a"
+    end
+  RUBY
+
+  def test_validate_runs_systemd_analyze_calendar_for_each_unique_on_calendar
+    with_project_dir do
+      write_schedule(DUP_HOURLY_SCHEDULE)
+      status, out, err, calls = run_validate("--verbose")
+      assert_cli_success(status, err)
+      assert_includes out, "OK OnCalendar=hourly"
+      assert_equal 1, calls.length
+      assert_equal %w[systemd-analyze calendar hourly], calls.fetch(0).fetch(0)
+    end
+  end
+
+  def test_validate_prints_message_when_no_on_calendar_and_verbose
+    with_project_dir do
+      write_empty_schedule
+      status, out, err, calls = run_validate("--verbose")
+      assert_cli_success(status, err)
+      assert_includes out, "No OnCalendar= values found"
+      assert_equal [], calls
+    end
+  end
+
+  def test_validate_verify_runs_systemd_analyze_verify
+    with_project_dir do
+      write_schedule(HOURLY_SCHEDULE)
+      status, out, err, calls = run_validate("--verify", "--verbose")
+      assert_cli_success(status, err)
+      assert_includes out, "OK systemd-analyze --user verify"
+      assert_equal %w[systemd-analyze --user verify], calls.fetch(1).fetch(0).take(3)
+    end
+  end
+
+  def test_validate_returns_nonzero_when_systemd_analyze_calendar_fails
+    with_project_dir do
+      write_schedule(HOURLY_SCHEDULE)
+      status, _out, err, calls = run_validate(exitstatus: 1, stderr: "boom\n")
+      assert_equal 1, status
+      assert_includes err, "systemd-analyze failed"
+      assert_includes err, "boom"
+      assert_equal %w[systemd-analyze calendar hourly], calls.fetch(0).fetch(0)
+    end
+  end
+
+  private
+
+  def run_validate(*args, **kwargs)
+    run_cli_with_capture3_stub(["validate", *args], **kwargs)
+  end
+
+  def write_schedule(contents)
+    FileUtils.mkdir_p("config")
+    File.write(File.join("config", "schedule.rb"), contents)
+  end
+end

data/test/domain_model_test.rb

@@ -61,7 +61,7 @@ class DomainModelTest < Minitest::Test
     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"
+    assert_includes error.message, "String or an Array"
   end
 
   def test_triggers_render_timer_lines

data/test/dsl_context_shell_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class DSLContextShellTest < Minitest::Test
+  def test_shell_requires_every_block
+    ctx = Wheneverd::DSL::Context.new(path: "/tmp/config/schedule.rb")
+    error = assert_raises(Wheneverd::DSL::LoadError) { ctx.shell("echo hi") }
+    assert_includes error.message, "shell() must be called inside every() block"
+  end
+
+  def test_shell_requires_string_script
+    ctx = Wheneverd::DSL::Context.new(path: "/tmp/config/schedule.rb")
+    error = assert_raises(Wheneverd::DSL::LoadError) { ctx.every("1m") { shell(123) } }
+    assert_includes error.message, "shell() script must be a String"
+  end
+
+  def test_shell_rejects_empty_script
+    ctx = Wheneverd::DSL::Context.new(path: "/tmp/config/schedule.rb")
+    error = assert_raises(Wheneverd::DSL::LoadError) { ctx.every("1m") { shell("   ") } }
+    assert_includes error.message, "shell() script must not be empty"
+  end
+end

data/test/dsl_loader_test.rb

@@ -45,6 +45,29 @@ class DSLLoaderIntervalAndDurationTest < Minitest::Test
     assert_equal ["echo hello"], entry.jobs.map(&:command)
   end
 
+  def test_loads_argv_command
+    schedule = load_schedule(<<~RUBY)
+      every "5m" do
+        command ["echo", "hello world"]
+      end
+    RUBY
+
+    job = schedule.entries.fetch(0).jobs.fetch(0)
+    assert_equal ["echo", "hello world"], job.argv
+    assert_equal "echo \"hello world\"", job.command
+  end
+
+  def test_loads_shell_helper
+    schedule = load_schedule(<<~RUBY)
+      every "5m" do
+        shell "echo hello | sed -e s/hello/hi/"
+      end
+    RUBY
+
+    job = schedule.entries.fetch(0).jobs.fetch(0)
+    assert_equal ["/bin/bash", "-lc", "echo hello | sed -e s/hello/hi/"], job.argv
+  end
+
   def test_loads_duration_with_at_as_calendar
     schedule = load_schedule(<<~RUBY)
       every 1.day, at: "4:30 am" do

data/test/job_command_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class JobCommandTest < Minitest::Test
+  def test_accepts_argv_and_formats_execstart
+    command = Wheneverd::Job::Command.new(command: ["echo", "hello world"])
+    assert_equal ["echo", "hello world"], command.argv
+    assert_equal "echo \"hello world\"", command.command
+  end
+
+  def test_accepts_empty_argv_argument
+    command = Wheneverd::Job::Command.new(command: ["printf", "%s", ""])
+    assert_equal "printf %s \"\"", command.command
+  end
+
+  def test_rejects_invalid_argv
+    assert_raises(Wheneverd::InvalidCommandError) { Wheneverd::Job::Command.new(command: []) }
+    assert_raises(Wheneverd::InvalidCommandError) { Wheneverd::Job::Command.new(command: ["   "]) }
+    assert_raises(Wheneverd::InvalidCommandError) { Wheneverd::Job::Command.new(command: ["echo", 1]) }
+  end
+
+  def test_rejects_argv_with_newlines
+    error = assert_raises(Wheneverd::InvalidCommandError) do
+      Wheneverd::Job::Command.new(command: %W[echo hi\nthere])
+    end
+    assert_includes error.message, "must not include NUL or newlines"
+  end
+end

data/test/systemd_analyze_test.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class SystemdAnalyzeTest < 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_calendar_builds_command_and_returns_output
+    with_capture3_stub(exitstatus: 0, stdout: "ok\n", stderr: "") do |calls|
+      out, err = Wheneverd::Systemd::Analyze.calendar("hourly")
+      assert_equal "ok\n", out
+      assert_equal "", err
+      assert_equal [%w[systemd-analyze calendar hourly], {}], calls.fetch(0)
+    end
+  end
+
+  def test_verify_builds_user_verify_command
+    with_capture3_stub(exitstatus: 0) do |calls|
+      Wheneverd::Systemd::Analyze.verify(["/tmp/a.timer", "/tmp/a.service"], user: true)
+      assert_equal(
+        [["systemd-analyze", "--user", "verify", "/tmp/a.timer", "/tmp/a.service"], {}],
+        calls.fetch(0)
+      )
+    end
+  end
+
+  def test_calendar_raises_systemd_analyze_error_on_failure_with_details
+    with_capture3_stub(exitstatus: 1, stdout: "oops\n", stderr: "nope\n") do
+      error = assert_raises(Wheneverd::Systemd::SystemdAnalyzeError) do
+        Wheneverd::Systemd::Analyze.calendar("hourly")
+      end
+      assert_includes error.message, "status: 1"
+      assert_includes error.message, "stdout: oops"
+      assert_includes error.message, "stderr: nope"
+    end
+  end
+
+  def test_calendar_raises_systemd_analyze_error_when_missing
+    error = assert_raises(Wheneverd::Systemd::SystemdAnalyzeError) do
+      Wheneverd::Systemd::Analyze.calendar("hourly", systemd_analyze: "/no/such/systemd-analyze")
+    end
+    assert_includes error.message, "systemd-analyze not found"
+  end
+end

data/test/systemd_renderer_test.rb

@@ -62,6 +62,12 @@ class SystemdRendererIntervalTest < Minitest::Test
     assert_includes service.contents, "Type=oneshot"
     assert_includes service.contents, "ExecStart=echo hello"
   end
+
+  def test_interval_service_contains_execstart_for_argv
+    entry = interval_entry(seconds: 60, command: ["echo", "hello world"])
+    service = service_for(entry)
+    assert_includes service.contents, "ExecStart=echo \"hello world\""
+  end
 end
 
 class SystemdRendererCalendarTest < Minitest::Test

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wheneverd
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - bigcurl
@@ -50,11 +50,14 @@ files:
 - lib/wheneverd/cli/current.rb
 - lib/wheneverd/cli/deactivate.rb
 - lib/wheneverd/cli/delete.rb
+- lib/wheneverd/cli/diff.rb
 - lib/wheneverd/cli/help.rb
 - lib/wheneverd/cli/init.rb
 - lib/wheneverd/cli/linger.rb
 - lib/wheneverd/cli/reload.rb
 - lib/wheneverd/cli/show.rb
+- lib/wheneverd/cli/status.rb
+- lib/wheneverd/cli/validate.rb
 - lib/wheneverd/cli/write.rb
 - lib/wheneverd/core_ext/numeric_duration.rb
 - lib/wheneverd/dsl/at_normalizer.rb
@@ -69,6 +72,7 @@ files:
 - lib/wheneverd/interval.rb
 - lib/wheneverd/job/command.rb
 - lib/wheneverd/schedule.rb
+- lib/wheneverd/systemd/analyze.rb
 - lib/wheneverd/systemd/calendar_spec.rb
 - lib/wheneverd/systemd/cron_parser.rb
 - lib/wheneverd/systemd/errors.rb
@@ -87,17 +91,24 @@ files:
 - test/cli_activate_test.rb
 - test/cli_current_test.rb
 - test/cli_deactivate_test.rb
+- test/cli_diff_test.rb
 - test/cli_end_to_end_test.rb
+- test/cli_init_test.rb
 - test/cli_linger_test.rb
 - test/cli_reload_test.rb
+- test/cli_status_test.rb
 - test/cli_systemctl_integration_test.rb
 - test/cli_systemd_analyze_test.rb
 - test/cli_test.rb
+- test/cli_validate_test.rb
 - test/domain_model_test.rb
 - test/dsl_calendar_symbol_period_list_test.rb
+- test/dsl_context_shell_test.rb
 - test/dsl_loader_test.rb
+- test/job_command_test.rb
 - test/support/cli_subprocess_test_helpers.rb
 - test/support/cli_test_helpers.rb
+- test/systemd_analyze_test.rb
 - test/systemd_calendar_spec_test.rb
 - test/systemd_cron_parser_test.rb
 - test/systemd_renderer_errors_test.rb
@@ -131,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.4
 specification_version: 4
 summary: Wheneverd is to systemd timers what whenever is to cron.
 test_files: []