wheneverd 0.3.0 → 0.5.0

data/test/domain_model_test.rb

@@ -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

@@ -15,6 +15,37 @@ class DSLContextShellTest < Minitest::Test
     assert_includes error.message, "shell() script must be a String"
   end
 
+  def test_service_accepts_shell_command
+    ctx = Wheneverd::DSL::Context.new(path: "/tmp/config/schedule.rb")
+    ctx.service("live-poller", shell: "bundle exec bin/live")
+
+    service = ctx.schedule.services.fetch(0)
+    assert_equal "live-poller", service.name
+    assert_equal ["/bin/bash", "-lc", "bundle exec bin/live"], service.command.argv
+  end
+
+  def test_service_requires_command_or_shell
+    ctx = Wheneverd::DSL::Context.new(path: "/tmp/config/schedule.rb")
+    error = assert_raises(Wheneverd::DSL::LoadError) { ctx.service("live-poller") }
+    assert_includes error.message, "service() requires command: or shell:"
+  end
+
+  def test_service_rejects_command_and_shell_together
+    ctx = Wheneverd::DSL::Context.new(path: "/tmp/config/schedule.rb")
+    error = assert_raises(Wheneverd::DSL::LoadError) do
+      ctx.service("live-poller", command: "bin/live", shell: "bin/live")
+    end
+    assert_includes error.message, "service() accepts command: or shell:, not both"
+  end
+
+  def test_service_wraps_validation_errors_as_load_errors
+    ctx = Wheneverd::DSL::Context.new(path: "/tmp/config/schedule.rb")
+    error = assert_raises(Wheneverd::DSL::LoadError) do
+      ctx.service("live-poller", command: "bin/live", service: { "Bad-Key" => "1" })
+    end
+    assert_includes error.message, "Invalid service setting name"
+  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("   ") } }

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

@@ -37,11 +37,84 @@ module SystemdRendererTestHelpers
     )
   end
 
+  def render_schedule(schedule, identifier: "demo")
+    Wheneverd::Systemd::Renderer.render(schedule, identifier: identifier)
+  end
+
   def marker
     "# Generated by wheneverd (wheneverd) #{Wheneverd::VERSION}; do not edit."
   end
 end
 
+class SystemdRendererServiceTest < Minitest::Test
+  include SystemdRendererTestHelpers
+
+  def test_standalone_service_contains_restart_and_extra_service_settings
+    service = Wheneverd::Service.new(
+      name: "live-poller",
+      command: ["/bin/bash", "-lc", "bundle exec bin/live"],
+      restart: "always",
+      restart_sec: "5s",
+      service: { "Nice" => "10", "CPUQuota" => "80%" }
+    )
+    units = render_schedule(Wheneverd::Schedule.new(services: [service]))
+    unit = units.fetch(0)
+
+    assert_equal :service, unit.kind
+    assert_equal :service, unit.activation
+    assert_includes unit.contents, marker
+    assert_includes unit.contents, "Description=wheneverd service #{unit.path_basename}"
+    assert_includes unit.contents, "Type=simple"
+    assert_includes unit.contents, 'ExecStart=/bin/bash -lc "bundle exec bin/live"'
+    assert_includes unit.contents, "Restart=always"
+    assert_includes unit.contents, "RestartSec=5s"
+    assert_includes unit.contents, "Nice=10"
+    assert_includes unit.contents, "CPUQuota=80%"
+    assert_includes unit.contents, "WantedBy=default.target"
+  end
+
+  def test_standalone_service_accepts_array_service_lines
+    service = Wheneverd::Service.new(
+      name: "live-poller",
+      command: "bin/live",
+      service: ["Environment=RAILS_ENV=production"]
+    )
+    unit = render_schedule(Wheneverd::Schedule.new(services: [service])).fetch(0)
+
+    assert_includes unit.contents, "Environment=RAILS_ENV=production"
+  end
+
+  def test_standalone_service_rejects_invalid_service_lines
+    assert_raises(Wheneverd::InvalidCommandError) do
+      Wheneverd::Service.new(name: "live-poller", command: "bin/live", service: ["NoEquals"])
+    end
+  end
+
+  def test_standalone_service_rejects_invalid_service_settings_collection
+    assert_raises(Wheneverd::InvalidCommandError) do
+      Wheneverd::Service.new(name: "live-poller", command: "bin/live", service: "Nice=10")
+    end
+  end
+
+  def test_standalone_service_rejects_newlines_in_setting_values
+    assert_raises(Wheneverd::InvalidCommandError) do
+      Wheneverd::Service.new(name: "live-poller", command: "bin/live",
+                             service: { "Environment" => "A=1\nB=2" })
+    end
+  end
+
+  def test_standalone_service_naming_is_stable
+    service = Wheneverd::Service.new(name: "worker", command: "bin/worker")
+    schedule = Wheneverd::Schedule.new(services: [service])
+
+    units1 = render_schedule(schedule)
+    units2 = render_schedule(schedule)
+
+    assert_equal units1.map(&:path_basename), units2.map(&:path_basename)
+    assert_match(/\Awheneverd-demo-[0-9a-f]{12}\.service\z/, units1.fetch(0).path_basename)
+  end
+end
+
 class SystemdRendererIntervalTest < Minitest::Test
   include SystemdRendererTestHelpers
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wheneverd
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - bigcurl
@@ -32,6 +32,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rubocop.yml"
+- ".ruby-version"
 - ".yardopts"
 - AGENTS.md
 - CHANGELOG.md
@@ -66,27 +67,40 @@ 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/service.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
@@ -142,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.4
+rubygems_version: 4.0.11
 specification_version: 4
 summary: Wheneverd is to systemd timers what whenever is to cron.
 test_files: []