wheneverd 0.2.1 → 0.4.0

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
@@ -105,4 +105,109 @@ class DomainModelTest < Minitest::Test
   def test_entry_requires_a_trigger
     assert_raises(ArgumentError) { Wheneverd::Entry.new(trigger: nil) }
   end
+
+  def test_trigger_base_module_raises_not_implemented
+    # Create a class that includes Base but doesn't implement the methods
+    test_trigger_class = Class.new do
+      include Wheneverd::Trigger::Base
+    end
+    trigger = test_trigger_class.new
+
+    error = assert_raises(NotImplementedError) { trigger.systemd_timer_lines }
+    assert_includes error.message, "must implement #systemd_timer_lines"
+
+    error = assert_raises(NotImplementedError) { trigger.signature }
+    assert_includes error.message, "must implement #signature"
+  end
+
+  def test_trigger_signatures
+    interval = Wheneverd::Trigger::Interval.new(seconds: 60)
+    assert_equal "interval:60", interval.signature
+
+    boot = Wheneverd::Trigger::Boot.new(seconds: 5)
+    assert_equal "boot:5", boot.signature
+
+    calendar = Wheneverd::Trigger::Calendar.new(on_calendar: %w[daily hourly])
+    assert_equal "calendar:daily|hourly", calendar.signature
+  end
+
+  def test_period_strategy_base_raises_not_implemented
+    # Create a class that inherits from Base but doesn't implement the methods
+    test_strategy_class = Class.new(Wheneverd::DSL::PeriodStrategy::Base)
+    strategy = test_strategy_class.new(path: "test")
+
+    error = assert_raises(NotImplementedError) { strategy.handles?(:anything) }
+    assert_includes error.message, "must implement #handles?"
+
+    error = assert_raises(NotImplementedError) { strategy.parse(:anything, at_times: []) }
+    assert_includes error.message, "must implement #parse"
+  end
+
+  def test_validation_type
+    # Valid type
+    assert_equal 42, Wheneverd::Validation.type(42, Integer, name: "value")
+
+    # Invalid type
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.type("string", Integer, name: "value")
+    end
+    assert_includes error.message, "value must be a Integer"
+  end
+
+  def test_validation_positive_integer
+    # Valid positive integer
+    assert_equal 5, Wheneverd::Validation.positive_integer(5, name: "count")
+
+    # Non-positive
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.positive_integer(0, name: "count")
+    end
+    assert_includes error.message, "must be positive"
+
+    # Non-integer
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.positive_integer("5", name: "count")
+    end
+    assert_includes error.message, "must be a Integer"
+  end
+
+  def test_validation_non_empty_string
+    # Valid non-empty string
+    assert_equal "hello", Wheneverd::Validation.non_empty_string("  hello  ", name: "text")
+
+    # Empty string
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.non_empty_string("  ", name: "text")
+    end
+    assert_includes error.message, "must not be empty"
+  end
+
+  def test_validation_non_empty_array
+    # Valid non-empty array
+    arr = [1, 2, 3]
+    assert_equal arr, Wheneverd::Validation.non_empty_array(arr, name: "items")
+
+    # Empty array
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.non_empty_array([], name: "items")
+    end
+    assert_includes error.message, "must not be empty"
+
+    # Non-array
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.non_empty_array("not an array", name: "items")
+    end
+    assert_includes error.message, "must be a Array"
+  end
+
+  def test_validation_in_range
+    # Valid in range
+    assert_equal 5, Wheneverd::Validation.in_range(5, 1..10, name: "value")
+
+    # Out of range
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.in_range(15, 1..10, name: "value")
+    end
+    assert_includes error.message, "must be in 1..10"
+  end
 end

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_cron_parser_test.rb

@@ -38,28 +38,51 @@ class SystemdCronParserTest < Minitest::Test
     end
   end
 
-  def test_private_helpers_reject_empty_numeric_field
-    assert_private_unsupported(
-      :parse_mapped_numeric_expression,
-      "",
-      0..59,
-      field: "minute",
-      input: "x",
-      names: {}
-    )
+  def test_field_parser_rejects_empty_numeric_field
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::FieldParser.parse_mapped(
+        "",
+        0..59,
+        field: "minute",
+        input: "x",
+        names: {}
+      )
+    end
   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")
+  def test_field_parser_rejects_invalid_numeric_tokens
+    # Empty token (just whitespace)
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::FieldParser.parse_mapped(
+        " ",
+        0..59,
+        field: "minute",
+        input: "x",
+        names: {}
+      )
+    end
   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")
+  def test_dow_parser_rejects_empty_and_invalid_tokens
+    # Empty day-of-week field
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::DowParser.parse("", input: "x")
+    end
+
+    # Out of range day-of-week value (8)
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::DowParser.parse("8", input: "x")
+    end
+
+    # Invalid step (non-numeric)
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::DowParser.parse("*/x", input: "x")
+    end
+
+    # Invalid step (zero)
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::DowParser.parse("*/0", input: "x")
+    end
   end
 
   def test_rejects_unsupported_cron_patterns
@@ -97,13 +120,6 @@ class SystemdCronParserTest < Minitest::Test
     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

data/test/systemd_renderer_errors_test.rb

@@ -44,7 +44,7 @@ class SystemdRendererErrorsTest < Minitest::Test
 
   def test_timer_lines_for_rejects_unknown_trigger
     assert_raises(ArgumentError) do
-      Wheneverd::Systemd::Renderer.send(:timer_lines_for, Object.new)
+      Wheneverd::Systemd::UnitContentBuilder.timer_lines_for(Object.new)
     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.1
+  version: 0.4.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
@@ -63,41 +66,61 @@ files:
 - lib/wheneverd/dsl/errors.rb
 - lib/wheneverd/dsl/loader.rb
 - lib/wheneverd/dsl/period_parser.rb
+- lib/wheneverd/dsl/period_strategy.rb
+- lib/wheneverd/dsl/period_strategy/array_strategy.rb
+- lib/wheneverd/dsl/period_strategy/base.rb
+- lib/wheneverd/dsl/period_strategy/duration_strategy.rb
+- lib/wheneverd/dsl/period_strategy/string_strategy.rb
+- lib/wheneverd/dsl/period_strategy/symbol_strategy.rb
 - lib/wheneverd/duration.rb
 - lib/wheneverd/entry.rb
 - lib/wheneverd/errors.rb
 - 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/cron_parser/dow_parser.rb
+- lib/wheneverd/systemd/cron_parser/field_parser.rb
 - lib/wheneverd/systemd/errors.rb
 - lib/wheneverd/systemd/loginctl.rb
 - lib/wheneverd/systemd/renderer.rb
 - lib/wheneverd/systemd/systemctl.rb
 - lib/wheneverd/systemd/time_parser.rb
+- lib/wheneverd/systemd/unit_content_builder.rb
 - lib/wheneverd/systemd/unit_deleter.rb
 - lib/wheneverd/systemd/unit_lister.rb
 - lib/wheneverd/systemd/unit_namer.rb
+- lib/wheneverd/systemd/unit_path_utils.rb
 - lib/wheneverd/systemd/unit_writer.rb
+- lib/wheneverd/trigger/base.rb
 - lib/wheneverd/trigger/boot.rb
 - lib/wheneverd/trigger/calendar.rb
 - lib/wheneverd/trigger/interval.rb
+- lib/wheneverd/validation.rb
 - lib/wheneverd/version.rb
 - 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 +154,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: []