wheneverd 0.1.0

data/test/cli_deactivate_test.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_test_helpers"
+
+class CLIDeactivateSuccessTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_exits_zero
+    with_inited_project_dir do
+      status, _out, _err, _calls = run_deactivate_with_capture3_stub
+      assert_equal 0, status
+    end
+  end
+
+  def test_prints_timer_units
+    with_inited_project_dir do
+      status, out, err, _calls = run_deactivate_with_capture3_stub
+      assert_cli_success(status, err)
+      assert_includes out, expected_timer_basenames.fetch(0)
+    end
+  end
+
+  def test_runs_stop
+    with_inited_project_dir do
+      status, _out, err, calls = run_deactivate_with_capture3_stub
+      assert_cli_success(status, err)
+      assert_systemctl_call_starts_with(calls, 0, SYSTEMCTL_USER_PREFIX + ["stop"],
+                                        includes: expected_timer_basenames)
+    end
+  end
+
+  def test_runs_disable
+    with_inited_project_dir do
+      status, _out, err, calls = run_deactivate_with_capture3_stub
+      assert_cli_success(status, err)
+      assert_systemctl_call_starts_with(calls, 1, SYSTEMCTL_USER_PREFIX + ["disable"],
+                                        includes: expected_timer_basenames)
+    end
+  end
+end
+
+class CLIDeactivateScheduleMissingTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_exits_one
+    with_project_dir do
+      status, _out, _err = run_cli(["deactivate"])
+      assert_equal 1, status
+    end
+  end
+
+  def test_prints_error_message
+    with_project_dir do
+      _status, out, err = run_cli(["deactivate"])
+      assert_equal "", out
+      assert_includes err, "Schedule file not found"
+    end
+  end
+end
+
+class CLIDeactivateEmptyScheduleTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_makes_no_systemctl_calls
+    with_project_dir do
+      write_empty_schedule
+      status, _out, err, calls = run_deactivate_with_capture3_stub
+      assert_cli_success(status, err)
+      assert_equal [], calls
+    end
+  end
+
+  def test_prints_nothing
+    with_project_dir do
+      write_empty_schedule
+      status, out, err, _calls = run_deactivate_with_capture3_stub
+      assert_cli_success(status, err)
+      assert_equal "", out
+    end
+  end
+end
+
+class CLIDeactivateSystemctlFailureTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_exits_one
+    with_inited_project_dir do
+      status, _out, _err, _calls = run_deactivate_with_capture3_stub(exitstatus: 1,
+                                                                     stderr: "no bus\n")
+      assert_equal 1, status
+    end
+  end
+
+  def test_prints_systemctl_failed
+    with_inited_project_dir do
+      _status, _out, err, _calls = run_deactivate_with_capture3_stub(exitstatus: 1,
+                                                                     stderr: "no bus\n")
+      assert_includes err, "systemctl failed"
+    end
+  end
+
+  def test_only_calls_stop
+    with_inited_project_dir do
+      _status, _out, _err, calls = run_deactivate_with_capture3_stub(exitstatus: 1,
+                                                                     stderr: "no bus\n")
+      assert_equal 1, calls.length
+      assert_systemctl_call_starts_with(calls, 0, SYSTEMCTL_USER_PREFIX + ["stop"])
+    end
+  end
+end

data/test/cli_end_to_end_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_subprocess_test_helpers"
+
+class CLIEndToEndTest < Minitest::Test
+  include CLISubprocessTestHelpers
+
+  def test_init_show_write_current_delete_workflow_via_exe
+    with_temp_project_dir do |project_dir|
+      init_schedule(project_dir)
+      show_units(project_dir)
+      unit_dir = File.join(project_dir, "tmp_units")
+      write_units(project_dir, unit_dir)
+      current_units(project_dir, unit_dir)
+      delete_units(project_dir, unit_dir)
+    end
+  end
+
+  private
+
+  def init_schedule(project_dir)
+    status, out, err = run_exe(["init"], chdir: project_dir)
+    assert_equal 0, status
+    assert_equal "", err
+    assert_includes out, "Wrote schedule template"
+    assert File.file?(File.join(project_dir, "config", "schedule.rb"))
+  end
+
+  def show_units(project_dir)
+    status, out, err = run_exe(["show", "--identifier", "demo"], chdir: project_dir)
+    assert_equal 0, status
+    assert_equal "", err
+    assert_includes out, "OnActiveSec=300"
+    assert_includes out, "OnUnitActiveSec=300"
+    assert_includes out, "ExecStart=echo hello"
+  end
+
+  def write_units(project_dir, unit_dir)
+    status, out, err = run_exe(
+      ["write", "--identifier", "demo", "--unit-dir", unit_dir],
+      chdir: project_dir
+    )
+    assert_equal 0, status
+    assert_equal "", err
+    assert_timer_unit_written(unit_dir, out)
+    assert_timer_unit_contents(unit_dir)
+  end
+
+  def current_units(project_dir, unit_dir)
+    status, out, err = run_exe(
+      ["current", "--identifier", "demo", "--unit-dir", unit_dir],
+      chdir: project_dir
+    )
+    assert_equal 0, status
+    assert_equal "", err
+    assert_match(/wheneverd-demo-[0-9a-f]{12}\.timer/, out)
+    assert_includes out, Wheneverd::Systemd::Renderer::MARKER_PREFIX
+  end
+
+  def delete_units(project_dir, unit_dir)
+    status, out, err = run_exe(
+      ["delete", "--identifier", "demo", "--unit-dir", unit_dir],
+      chdir: project_dir
+    )
+    assert_equal 0, status
+    assert_equal "", err
+    timer_path = out.lines.map(&:strip).find { |line| line.end_with?(".timer") }
+    assert timer_path, "expected delete to print at least one *.timer path"
+    assert_includes timer_path, unit_dir
+    refute File.exist?(timer_path)
+  end
+
+  def assert_timer_unit_written(unit_dir, out)
+    service_path = out.lines.map(&:strip).find { |line| line.end_with?(".service") }
+    timer_path = out.lines.map(&:strip).find { |line| line.end_with?(".timer") }
+    assert service_path, "expected write to print at least one *.service path"
+    assert timer_path, "expected write to print at least one *.timer path"
+    assert_includes service_path, unit_dir
+    assert_includes timer_path, unit_dir
+    assert File.exist?(timer_path)
+  end
+
+  def assert_timer_unit_contents(unit_dir)
+    timer_basenames = Dir.children(unit_dir).select { |b| b.end_with?(".timer") }
+    assert timer_basenames.any?, "expected unit_dir to contain at least one *.timer file"
+
+    timer_contents = timer_basenames.filter_map do |basename|
+      contents = File.read(File.join(unit_dir, basename))
+      contents if contents.include?("OnActiveSec=300")
+    end.first
+
+    assert timer_contents, "expected at least one interval timer with OnActiveSec=300"
+    assert_includes timer_contents, Wheneverd::Systemd::Renderer::MARKER_PREFIX
+    assert_includes timer_contents, "OnActiveSec=300"
+    assert_includes timer_contents, "OnUnitActiveSec=300"
+  end
+end

data/test/cli_reload_test.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_test_helpers"
+
+class CLIReloadSuccessTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_exits_zero
+    with_inited_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      status, _out, err, _calls = run_reload_with_capture3_stub(unit_dir: unit_dir)
+      assert_cli_success(status, err)
+    end
+  end
+
+  def test_writes_unit_files
+    with_inited_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      status, _out, err, _calls = run_reload_with_capture3_stub(unit_dir: unit_dir)
+      assert_cli_success(status, err)
+      assert File.exist?(File.join(unit_dir, expected_timer_basenames.fetch(0)))
+    end
+  end
+
+  def test_runs_daemon_reload
+    with_inited_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      status, _out, err, calls = run_reload_with_capture3_stub(unit_dir: unit_dir)
+      assert_cli_success(status, err)
+      assert_systemctl_call(calls, 0, SYSTEMCTL_USER_PREFIX + ["daemon-reload"])
+    end
+  end
+
+  def test_runs_restart
+    with_inited_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      status, _out, err, calls = run_reload_with_capture3_stub(unit_dir: unit_dir)
+      assert_cli_success(status, err)
+      assert_systemctl_call_starts_with(calls, 1, SYSTEMCTL_USER_PREFIX + ["restart"],
+                                        includes: expected_timer_basenames)
+    end
+  end
+end
+
+class CLIReloadScheduleMissingTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_exits_one
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      status, _out, _err = run_cli(["reload", "--unit-dir", unit_dir])
+      assert_equal 1, status
+    end
+  end
+
+  def test_prints_error_message
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      _status, out, err = run_cli(["reload", "--unit-dir", unit_dir])
+      assert_equal "", out
+      assert_includes err, "Schedule file not found"
+    end
+  end
+end
+
+class CLIReloadEmptyScheduleTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_makes_no_systemctl_calls
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      write_empty_schedule
+      status, _out, err, calls = run_reload_with_capture3_stub(unit_dir: unit_dir)
+      assert_cli_success(status, err)
+      assert_equal [], calls
+    end
+  end
+
+  def test_prints_nothing
+    with_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      write_empty_schedule
+      status, out, err, _calls = run_reload_with_capture3_stub(unit_dir: unit_dir)
+      assert_cli_success(status, err)
+      assert_equal "", out
+    end
+  end
+end
+
+class CLIReloadSystemctlFailureTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_exits_one
+    with_inited_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      status, _out, _err, _calls = run_reload_with_capture3_stub(unit_dir: unit_dir,
+                                                                 exitstatus: 1,
+                                                                 stderr: "no bus\n")
+      assert_equal 1, status
+    end
+  end
+
+  def test_prints_systemctl_failed
+    with_inited_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      _status, _out, err, _calls = run_reload_with_capture3_stub(unit_dir: unit_dir,
+                                                                 exitstatus: 1,
+                                                                 stderr: "no bus\n")
+      assert_includes err, "systemctl failed"
+    end
+  end
+
+  def test_only_calls_daemon_reload
+    with_inited_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      _status, _out, _err, calls = run_reload_with_capture3_stub(unit_dir: unit_dir,
+                                                                 exitstatus: 1,
+                                                                 stderr: "no bus\n")
+      assert_equal 1, calls.length
+      assert_systemctl_call(calls, 0, SYSTEMCTL_USER_PREFIX + ["daemon-reload"])
+    end
+  end
+
+  def test_writes_units_before_systemctl_failure
+    with_inited_project_dir do |project_dir|
+      unit_dir = File.join(project_dir, "tmp_units")
+      run_reload_with_capture3_stub(unit_dir: unit_dir, exitstatus: 1, stderr: "no bus\n")
+      assert File.exist?(File.join(unit_dir, expected_timer_basenames.fetch(0)))
+    end
+  end
+end

data/test/cli_systemctl_integration_test.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_subprocess_test_helpers"
+
+class CLISystemctlIntegrationTest < Minitest::Test
+  include CLISubprocessTestHelpers
+
+  def test_reload_invokes_systemctl_via_path_injection
+    with_temp_project_dir { |project_dir| assert_reload_invokes_systemctl(project_dir) }
+  end
+
+  private
+
+  def assert_reload_invokes_systemctl(project_dir)
+    init_schedule(project_dir)
+    with_fake_systemctl(project_dir) do |env, log_path|
+      run_reload(project_dir, env)
+      assert_systemctl_log_includes_expected_calls(log_path)
+    end
+  end
+
+  def run_reload(project_dir, env)
+    unit_dir = File.join(project_dir, "tmp_units")
+    status, _out, err = run_exe(
+      ["reload", "--identifier", "demo", "--unit-dir", unit_dir],
+      chdir: project_dir,
+      env: env
+    )
+    assert_equal 0, status
+    assert_equal "", err
+  end
+
+  def init_schedule(project_dir)
+    status, out, err = run_exe(["init"], chdir: project_dir)
+    assert_equal 0, status
+    assert_equal "", err
+    assert_includes out, "Wrote schedule template"
+  end
+
+  def with_fake_systemctl(project_dir)
+    bin_dir = File.join(project_dir, "tmp_bin")
+    FileUtils.mkdir_p(bin_dir)
+    log_path = File.join(project_dir, "systemctl.log")
+
+    write_fake_systemctl(File.join(bin_dir, "systemctl"))
+
+    env = {
+      "PATH" => [bin_dir, ENV.fetch("PATH", "")].join(File::PATH_SEPARATOR),
+      "SYSTEMCTL_LOG" => log_path
+    }
+    yield env, log_path
+  end
+
+  def write_fake_systemctl(path)
+    File.write(
+      path,
+      <<~RUBY
+        #!/usr/bin/env ruby
+        # frozen_string_literal: true
+
+        log_path = ENV.fetch("SYSTEMCTL_LOG")
+        File.open(log_path, "a") { |f| f.puts(ARGV.join(" ")) }
+        exit 0
+      RUBY
+    )
+    FileUtils.chmod(0o755, path)
+  end
+
+  def assert_systemctl_log_includes_expected_calls(log_path)
+    log = File.read(log_path)
+    assert_includes log, "--user --no-pager daemon-reload"
+    assert_includes log, "--user --no-pager restart"
+    assert_match(/wheneverd-demo-[0-9a-f]{12}\.timer/, log)
+  end
+end

data/test/cli_systemd_analyze_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_subprocess_test_helpers"
+
+class CLISystemdAnalyzeTest < Minitest::Test
+  include CLISubprocessTestHelpers
+
+  def test_rendered_on_calendar_values_parse_with_systemd_analyze_calendar
+    analyze = require_executable!("systemd-analyze")
+    true_bin = absolute_true_path || "true"
+
+    with_temp_project_dir { |project_dir| assert_calendars_ok(analyze, project_dir, true_bin) }
+  end
+
+  private
+
+  def assert_calendars_ok(analyze, project_dir, true_bin)
+    write_schedule(project_dir, schedule_contents(true_bin))
+    status, out, err = run_exe(["show", "--identifier", "demo"], chdir: project_dir)
+    assert_equal 0, status
+    assert_equal "", err
+
+    values = on_calendar_values(out)
+    refute_empty values
+    values.each { |value| assert_systemd_analyze_calendar_ok(analyze, value) }
+  end
+
+  def require_executable!(name)
+    path = find_executable(name)
+    skip "#{name} not available" unless path
+    path
+  end
+
+  def schedule_contents(true_bin)
+    <<~RUBY
+      # frozen_string_literal: true
+
+      every :hour do
+        command "#{true_bin}"
+      end
+
+      every 1.day, at: "4:30 am" do
+        command "#{true_bin}"
+      end
+    RUBY
+  end
+
+  def absolute_true_path
+    %w[/usr/bin/true /bin/true].find { |p| File.file?(p) && File.executable?(p) }
+  end
+
+  def on_calendar_values(output)
+    output.lines
+          .grep(/\AOnCalendar=/)
+          .map { |line| line.delete_prefix("OnCalendar=").strip }
+          .uniq
+  end
+
+  def assert_systemd_analyze_calendar_ok(analyze, value)
+    _stdout, stderr, status = Open3.capture3(analyze, "calendar", value)
+    assert_equal 0, status.exitstatus, stderr
+  end
+end