ruby_raider 4.1.0 → 4.2.0

data/spec/utilities/schedules/os/list_ids_spec.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require_relative '../../../../lib/utilities/schedules/adapter'
+require_relative '../../../../lib/utilities/schedules/schedule'
+
+# Every adapter's list_ids(prefix): the os_ids of one project's schedules of the adapter's Kind, found by
+# enumerating the OS scheduler. Only a fake runner and a temp home: nothing real is read or run.
+# rubocop:disable RSpec/MultipleMemoizedHelpers
+RSpec.describe 'Schedules adapters #list_ids' do
+  # Answers each command from a table keyed by its first words; never runs anything
+  let(:fake_runner_class) do
+    Class.new do
+      attr_reader :calls, :answers
+
+      def initialize
+        @calls = []
+        @answers = {}
+      end
+
+      def call(*argv, stdin_data: nil)
+        @calls << [argv, stdin_data]
+        key = if argv.first.to_s.end_with?('schtasks.exe') then argv[1]
+              elsif argv.first == 'systemctl' then argv.first(3).join(' ')
+              else argv.first(2).join(' ')
+              end
+        stdout, status, stderr = answers.fetch(key, ['', 0, ''])
+        RubyRaider::Schedules::Os::CommandRunner::Result.new(stdout: stdout, stderr: stderr.to_s, exitstatus: status)
+      end
+    end
+  end
+
+  let(:kind) { RubyRaider::Schedules::Kind::TESTS }
+  let(:tmp) { File.realpath(Dir.mktmpdir('schedules-list-ids')) }
+  let(:home) { File.join(tmp, 'home') }
+  let(:runner) { fake_runner_class.new }
+  let(:root) { File.join(tmp, 'project') }
+  let(:prefix) { RubyRaider::Schedules::Schedule.os_id_prefix_for(root) }
+  let(:other_prefix) { RubyRaider::Schedules::Schedule.os_id_prefix_for(File.join(tmp, 'other')) }
+  let(:flow_prefix) { "#{RubyRaider::Schedules::Kind::FLOW_LEGACY.os_id_prefix}.#{prefix.split('.')[3]}." }
+  let(:bad_utf8) { "#{prefix}a\xFF".dup.force_encoding(Encoding::UTF_8) }
+  # What enumeration may see besides our two ids: another project, a flow schedule, a bad name, a longer
+  # name, path tricks and bytes that are not UTF-8
+  let(:noise) do
+    ["#{other_prefix}nightly", "#{flow_prefix}nightly", "#{prefix}Bad", "#{prefix}#{'a' * 61}", "#{prefix}a.b", "#{prefix}..",
+     "#{prefix}a b", prefix, "x#{prefix}nightly", bad_utf8]
+  end
+
+  let(:extra_children) { Hash.new { |hash, key| hash[key] = [] } }
+
+  after { FileUtils.rm_rf(tmp) }
+
+  # APFS refuses a file name that is not UTF-8, so those names are fed through Dir.children instead
+  def touch(dir, *names)
+    FileUtils.mkdir_p(dir)
+    names.each { |name| name.valid_encoding? ? File.write(File.join(dir, name), '') : extra_children[dir] << name }
+  end
+
+  before do
+    allow(Dir).to(receive(:children).and_wrap_original { |original, dir| original.call(dir) + extra_children[dir] })
+  end
+
+  it 'builds the prefix from the kind and the project path hash, ending in a dot' do
+    expect(prefix).to match(/\Adev\.rubyraider\.schedule\.[0-9a-f]{10}\.\z/)
+    expect(RubyRaider::Schedules::Schedule.os_id_for(root, 'nightly')).to eq("#{prefix}nightly")
+  end
+
+  describe RubyRaider::Schedules::Os::Launchd do
+    let(:adapter) { described_class.new(kind: kind, runner: runner, home: home, uid: 501) }
+    let(:agents) { File.join(home, 'Library', 'LaunchAgents') }
+
+    it 'lists the plist basenames of this project and kind, sorted, and runs nothing' do
+      touch(agents, "#{prefix}smoke.plist", "#{prefix}nightly.plist", "#{prefix}nightly.txt", ".#{prefix}x.plist.ab12.tmp",
+            *noise.map { |id| "#{id}.plist" })
+
+      expect(adapter.list_ids(prefix)).to eq(["#{prefix}nightly", "#{prefix}smoke"])
+      expect([runner.calls, extra_children[agents]]).to eq([[], ["#{bad_utf8}.plist"]])
+    end
+
+    it 'is empty when there is no LaunchAgents folder' do
+      expect(adapter.list_ids(prefix)).to eq([])
+    end
+
+    it 'raises an Error when the folder can not be read' do
+      FileUtils.mkdir_p(File.join(home, 'Library'))
+      File.write(agents, '')
+
+      expect { adapter.list_ids(prefix) }.to raise_error(RubyRaider::Schedules::Error, /Could not read .*LaunchAgents/)
+    end
+  end
+
+  describe RubyRaider::Schedules::Os::TaskScheduler do
+    let(:adapter) { described_class.new(kind: kind, runner: runner, schtasks: 'C:\\Windows\\System32\\schtasks.exe') }
+
+    def rows(*names) = names.map { |name| %("#{name}","11/10/2026 8:00:00 AM","Ready"\r\n) }.join
+
+    it 'lists the tasks under \\RubyRaider\\ of this project and kind from one query' do
+      listing = rows("\\RubyRaider\\#{prefix}smoke", "\\RubyRaider\\#{prefix}nightly", "\\Other\\#{prefix}elsewhere",
+                     "\\RubyRaider\\sub\\#{prefix}deeper", "\\#{prefix}rootlevel", "\\RubyRaider\\#{prefix}smoke",
+                     *noise.map { |id| "\\RubyRaider\\#{id}" })
+      listing = "#{listing}garbage line\r\n\"unterminated\r\n"
+      runner.answers['/Query'] = [listing.b, 0]
+
+      expect(adapter.list_ids(prefix)).to eq(["#{prefix}nightly", "#{prefix}smoke"])
+      expect(runner.calls.map(&:first)).to eq([['C:\\Windows\\System32\\schtasks.exe', '/Query', '/FO', 'CSV', '/NH']])
+    end
+
+    it 'raises an Error when the task list can not be read' do
+      runner.answers['/Query'] = ['', 1, "ERROR: \e[2Jdenied"]
+
+      expect { adapter.list_ids(prefix) }.to raise_error(RubyRaider::Schedules::Error, 'Task Scheduler could not list tasks: ERROR: ?[2Jdenied')
+    end
+  end
+
+  describe RubyRaider::Schedules::Os::Systemd do
+    let(:adapter) { described_class.new(kind: kind, runner: runner, home: home, config_home: nil) }
+    let(:units) { File.join(home, '.config', 'systemd', 'user') }
+
+    it 'lists the unit file names of this project and kind, without asking systemctl' do
+      touch(units, "#{prefix}smoke.timer", "#{prefix}smoke.service", "#{prefix}nightly.service", "#{prefix}other.socket",
+            ".#{prefix}x.timer.ab12.tmp", *noise.map { |id| "#{id}.timer" })
+
+      expect(adapter.list_ids(prefix)).to eq(["#{prefix}nightly", "#{prefix}smoke"])
+      expect(runner.calls).to be_empty
+    end
+
+    it 'reads the units folder under XDG_CONFIG_HOME when that is absolute' do
+      config = File.join(tmp, 'xdg')
+      touch(File.join(config, 'systemd', 'user'), "#{prefix}smoke.timer")
+
+      expect(described_class.new(kind: kind, runner: runner, home: home, config_home: config).list_ids(prefix)).to eq(["#{prefix}smoke"])
+    end
+
+    it 'is empty when there is no units folder' do
+      expect(adapter.list_ids(prefix)).to eq([])
+    end
+  end
+
+  describe RubyRaider::Schedules::Os::Cron do
+    let(:adapter) { described_class.new(kind: kind, runner: runner) }
+
+    it 'lists the ids on our tag lines only, keeping the crontab as it is' do
+      table = "MAILTO=x\n# raider-schedule #{prefix}smoke\n0 8 * * * cd /p && run\n# raider-schedule #{prefix}nightly\r\n" \
+              "#  raider-schedule #{prefix}spaced\n# raider-schedule #{prefix}trailing \n" \
+              "0 1 * * * echo '# raider-schedule #{prefix}inline'\n" \
+              "#{noise.map { |id| "# raider-schedule #{id}\n" }.join}# raider-flow #{flow_prefix}legacy\n"
+      runner.answers['crontab -l'] = [table.b, 0]
+
+      expect(adapter.list_ids(prefix)).to eq(["#{prefix}nightly", "#{prefix}smoke"])
+      expect(runner.calls.map(&:first)).to eq([%w[crontab -l]])
+    end
+
+    it 'is empty with no crontab, and raises an Error when crontab -l fails otherwise' do
+      runner.answers['crontab -l'] = ['', 1, 'no crontab for raider']
+      expect(adapter.list_ids(prefix)).to eq([])
+
+      runner.answers['crontab -l'] = ['', 1, 'permission denied']
+      expect { adapter.list_ids(prefix) }.to raise_error(RubyRaider::Schedules::Error, /could not read the crontab/)
+    end
+
+    it 'raises an Error, not an encoding error, when crontab -l fails with bytes that are not UTF-8' do
+      runner.answers['crontab -l'] = ['', 1, "refus\xE9\e[2J".dup.force_encoding(Encoding::UTF_8)]
+
+      expect { adapter.list_ids(prefix) }.to raise_error(RubyRaider::Schedules::Error, 'cron could not read the crontab: refus??[2J')
+    end
+  end
+
+  describe RubyRaider::Schedules::Os::Linux do
+    let(:systemd) { RubyRaider::Schedules::Os::Systemd.new(kind: kind, runner: runner, home: home, config_home: nil) }
+    let(:cron) { RubyRaider::Schedules::Os::Cron.new(kind: kind, runner: runner) }
+    let(:units) { File.join(home, '.config', 'systemd', 'user') }
+
+    before do
+      touch(units, "#{prefix}timer_one.timer")
+      runner.answers['crontab -l'] = ["# raider-schedule #{prefix}cron_one\n", 0]
+    end
+
+    it 'with systemd answering: the unit files plus the cron tags' do
+      adapter = described_class.new(kind: kind, runner: runner, systemd: systemd, cron: cron)
+
+      expect(adapter.list_ids(prefix)).to eq(["#{prefix}cron_one", "#{prefix}timer_one"])
+    end
+
+    it 'with no user bus: the cron tags plus the stranded unit files' do
+      runner.answers['systemctl --user show-environment'] = ['', 1, 'Failed to connect to bus']
+      adapter = described_class.new(kind: kind, runner: runner, systemd: systemd, cron: cron)
+
+      expect(adapter.list_ids(prefix)).to eq(["#{prefix}cron_one", "#{prefix}timer_one"])
+    end
+
+    it 'leaves out the other scheduler when it fails, and raises when the primary one does' do
+      runner.answers['crontab -l'] = ['', 1, 'permission denied']
+      with_systemd = described_class.new(kind: kind, runner: runner, systemd: systemd, cron: cron)
+      expect(with_systemd.list_ids(prefix)).to eq(["#{prefix}timer_one"])
+
+      runner.answers['systemctl --user show-environment'] = ['', 1, 'Failed to connect to bus']
+      with_cron = described_class.new(kind: kind, runner: runner, systemd: systemd, cron: cron)
+      expect { with_cron.list_ids(prefix) }.to raise_error(RubyRaider::Schedules::Error, /could not read the crontab/)
+    end
+  end
+end
+# rubocop:enable RSpec/MultipleMemoizedHelpers

data/spec/utilities/{flows → schedules}/os/systemd_spec.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require 'tmpdir'
-require_relative '../../../../lib/utilities/flows/os/systemd'
+require_relative '../../../../lib/utilities/schedules/os/systemd'
+require_relative '../../../../lib/utilities/schedules/schedule'
 
-# Flow specs live under spec/utilities/flows, next to the code in lib/utilities/flows
 # The fake runner, temp home and project folders sit next to the adapter under test
 # rubocop:disable RSpec/MultipleMemoizedHelpers
-RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePath
+RSpec.describe RubyRaider::Schedules::Os::Systemd do # rubocop:disable RSpec/FilePath
   # Records every command and answers from a table keyed by the systemctl verb; never runs anything
   let(:fake_runner_class) do
     Class.new do
@@ -21,7 +21,7 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
         @calls << argv
         @seen&.call(argv, stdin_data)
         stderr, status = answers.fetch(argv[2], ['', 0])
-        RubyRaider::Flows::Os::CommandRunner::Result.new(stdout: '', stderr: stderr, exitstatus: status)
+        RubyRaider::Schedules::Os::CommandRunner::Result.new(stdout: '', stderr: stderr, exitstatus: status)
       end
 
       def on_call(&block) = @seen = block
@@ -29,18 +29,20 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
   end
 
   let(:hostile) { %q('; rm -rf ~; ' </string> %h $(id) " \\ &) }
-  let(:tmp) { File.realpath(Dir.mktmpdir('flows-systemd')) }
+  let(:tmp) { File.realpath(Dir.mktmpdir('schedules-systemd')) }
   let(:home) { File.join(tmp, 'home') }
   let(:project_dir) { File.join(tmp, 'plain') }
   let(:runner) { fake_runner_class.new }
-  let(:systemd) { described_class.new(runner: runner, home: home, config_home: nil) }
+  let(:systemd) { described_class.new(kind: RubyRaider::Schedules::Kind::TESTS, runner: runner, home: home, config_home: nil) }
   let(:now) { Time.utc(2026, 11, 9, 10, 0, 0) }
   let(:units) { File.join(home, '.config', 'systemd', 'user') }
 
-  def schedule(dir: project_dir, **options)
+  def schedule(dir: project_dir, gem_env: {}, bundle: '/opt/ruby/bin/bundle', **options)
     FileUtils.mkdir_p(dir)
-    project = RubyRaider::Flows::Project.new(File.realpath(dir))
-    RubyRaider::Flows::Schedule.build(project: project, name: 'report', every: 'day', at: '08:00', now: now, **options)
+    # Hermetic: the GEM_HOME/GEM_PATH and bundle this spec runs with never reach the entry; a spec passes its own
+    allow(RubyRaider::Schedules::Schedule).to receive_messages(captured_gem_env: gem_env, bundle_path: bundle)
+    project = RubyRaider::Schedules::Project.new(File.realpath(dir))
+    RubyRaider::Schedules::Schedule.build(project: project, name: 'report', every: 'day', at: '08:00', now: now, **options)
   end
 
   # systemd's specifier rule for a raw value: %% is %, any other % would be a specifier
@@ -110,7 +112,7 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
 
       expect(systemd.service(item)).to eq(<<~UNIT)
         [Unit]
-        Description=raider flow report
+        Description=raider schedule report
 
         [Service]
         Type=oneshot
@@ -123,22 +125,24 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
     end
 
     it 'keeps GEM_HOME and GEM_PATH in the environment when they were captured' do
-      allow(RubyRaider::Flows::Schedule).to receive(:captured_gem_env).and_return('GEM_HOME' => '/g/%h$x', 'GEM_PATH' => '/g/path')
+      item = schedule(gem_env: { 'GEM_HOME' => '/g/%h$x', 'GEM_PATH' => '/g/path' })
 
-      lines = value_of(systemd.service(schedule), 'Environment').flat_map { |value| systemd_words(value, dollars: false) }
+      lines = value_of(systemd.service(item), 'Environment').flat_map { |value| systemd_words(value, dollars: false) }
 
       expect(lines.last(3)).to eq(['LANG=en_US.UTF-8', 'GEM_HOME=/g/%h$x', 'GEM_PATH=/g/path'])
     end
 
-    describe 'with hostile values in an input and in the project path' do
-      let(:item) { schedule(dir: File.join(tmp, "p#{hostile}<", "string> #{hostile}"), inputs: ["note=#{hostile}"]) }
+    describe 'with hostile values in the bundle path, GEM_HOME and the project path' do
+      let(:item) do
+        schedule(dir: File.join(tmp, "p#{hostile}<", "string> #{hostile}"), bundle: "/opt/#{hostile}/bundle", gem_env: { 'GEM_HOME' => "/g/#{hostile}" })
+      end
       let(:text) { systemd.service(item) }
 
       it 'gives back the exact argv from ExecStart' do
         argv = systemd_words(value_of(text, 'ExecStart').first, dollars: true)
 
         expect(argv).to eq(item.argv)
-        expect(argv.last).to eq("note=#{hostile}")
+        expect(argv[1]).to eq("/opt/#{hostile}/bundle")
         expect(item.working_directory).to include('</string>', "'; rm -rf ~; '", '$(id)', '%h', '"', '\\', '&', ' ')
       end
 
@@ -153,7 +157,7 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
       it 'writes them only in escaped form' do
         expect(text).to include('%%h', '$$(id)', '\\" \\\\ &')
         expect(text.scan(/(?<!%)%(?!%)/)).to be_empty
-        expect(text.lines.length).to eq(systemd.service(schedule).lines.length)
+        expect(text.lines.length).to eq(systemd.service(schedule(gem_env: { 'GEM_HOME' => '/g' })).lines.length)
       end
     end
   end
@@ -162,7 +166,7 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
     it 'writes the exact timer for a daily schedule' do
       expect(systemd.timer(schedule)).to eq(<<~UNIT)
         [Unit]
-        Description=raider flow report schedule
+        Description=raider schedule report schedule
 
         [Timer]
         OnCalendar=*-*-* 08:00:00
@@ -196,8 +200,8 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
     it 'uses an absolute XDG_CONFIG_HOME and ignores a relative one' do
       item = schedule
       config = File.join(tmp, 'xdg')
-      described_class.new(runner: runner, home: home, config_home: config).install(item)
-      described_class.new(runner: runner, home: home, config_home: 'relative').install(item)
+      described_class.new(kind: RubyRaider::Schedules::Kind::TESTS, runner: runner, home: home, config_home: config).install(item)
+      described_class.new(kind: RubyRaider::Schedules::Kind::TESTS, runner: runner, home: home, config_home: 'relative').install(item)
 
       expect([File.exist?(File.join(config, 'systemd', 'user', "#{item.os_id}.timer")), File.exist?(timer_path(item))]).to eq([true, true])
     end
@@ -217,7 +221,7 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
       item = schedule
       runner.answers['enable'] = ["Failed to enable unit\e[2J\n", 1]
 
-      expect { systemd.install(item) }.to raise_error(RubyRaider::Flows::Error, /systemd could not enable .*Failed to enable unit\?\[2J/)
+      expect { systemd.install(item) }.to raise_error(RubyRaider::Schedules::Error, /systemd could not enable .*Failed to enable unit\?\[2J/)
       expect(runner.calls.map { |argv| argv[2] }).to eq(%w[daemon-reload enable disable daemon-reload])
       expect(runner.calls[2]).to eq(['systemctl', '--user', 'disable', "#{item.os_id}.timer"])
       expect(Dir.children(units)).to be_empty
@@ -227,7 +231,7 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
       item = schedule
       runner.answers['daemon-reload'] = ['Failed to connect to bus', 1]
 
-      expect { systemd.install(item) }.to raise_error(RubyRaider::Flows::Error, /Failed to connect to bus/)
+      expect { systemd.install(item) }.to raise_error(RubyRaider::Schedules::Error, /Failed to connect to bus/)
       expect(Dir.children(units)).to be_empty
     end
 
@@ -235,7 +239,7 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
       ['trailing ', 'tab\\'].each do |name|
         item = schedule(dir: File.join(tmp, name))
 
-        expect { systemd.install(item) }.to raise_error(RubyRaider::Flows::Error, /systemd can not use the path/)
+        expect { systemd.install(item) }.to raise_error(RubyRaider::Schedules::Error, /systemd can not use the path/)
       end
       expect([runner.calls, File.exist?(units)]).to eq([[], false])
     end
@@ -246,15 +250,15 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
         original.call(path, *rest, **options) { raise Errno::ENOSPC }
       end
 
-      expect { systemd.install(schedule) }.to raise_error(RubyRaider::Flows::Error, /Could not write .*No space left/)
+      expect { systemd.install(schedule) }.to raise_error(RubyRaider::Schedules::Error, /Could not write .*No space left/)
       expect([runner.calls, Dir.children(units)]).to eq([[], []])
     end
 
-    it 'raises a flow error and runs nothing when it can not write the units' do
+    it 'raises a schedule error and runs nothing when it can not write the units' do
       FileUtils.mkdir_p(File.dirname(units))
       File.write(units, 'not a folder')
 
-      expect { systemd.install(schedule) }.to raise_error(RubyRaider::Flows::Error, /Could not write .*systemd/)
+      expect { systemd.install(schedule) }.to raise_error(RubyRaider::Schedules::Error, /Could not write .*systemd/)
       expect([runner.calls, File.read(units)]).to eq([[], 'not a folder'])
     end
   end
@@ -282,17 +286,17 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
       item = schedule
       allow(File).to receive(:unlink).and_raise(Errno::EACCES)
 
-      expect { systemd.remove(item.os_id) }.to raise_error(RubyRaider::Flows::Error, /Could not remove .*Permission denied/)
+      expect { systemd.remove(item.os_id) }.to raise_error(RubyRaider::Schedules::Error, /Could not remove .*Permission denied/)
     end
 
     it 'raises when the reload fails' do
       runner.answers['daemon-reload'] = ['Failed to connect to bus', 1]
 
-      expect { systemd.remove(schedule.os_id) }.to raise_error(RubyRaider::Flows::Error, /Failed to connect to bus/)
+      expect { systemd.remove(schedule.os_id) }.to raise_error(RubyRaider::Schedules::Error, /Failed to connect to bus/)
     end
 
-    it 'refuses an os_id that is not a flow schedule id' do
-      expect { systemd.remove('../../evil') }.to raise_error(RubyRaider::Flows::Error, /Invalid os_id/)
+    it 'refuses an os_id that is not a schedule id' do
+      expect { systemd.remove('../../evil') }.to raise_error(RubyRaider::Schedules::Error, /Invalid os_id/)
       expect(runner.calls).to be_empty
     end
   end
@@ -320,8 +324,8 @@ RSpec.describe RubyRaider::Flows::Os::Systemd do # rubocop:disable RSpec/FilePat
       expect(systemd.present?(schedule.os_id)).to be(false)
     end
 
-    it 'refuses an os_id that is not a flow schedule id and runs nothing' do
-      expect { systemd.present?('x; rm') }.to raise_error(RubyRaider::Flows::Error, /Invalid os_id/)
+    it 'refuses an os_id that is not a schedule id and runs nothing' do
+      expect { systemd.present?('x; rm') }.to raise_error(RubyRaider::Schedules::Error, /Invalid os_id/)
       expect(runner.calls).to be_empty
     end
   end

data/spec/utilities/{flows → schedules}/os/task_scheduler_spec.rb

@@ -2,12 +2,12 @@
 
 require 'tmpdir'
 require 'rexml/document'
-require_relative '../../../../lib/utilities/flows/os/task_scheduler'
+require_relative '../../../../lib/utilities/schedules/os/task_scheduler'
+require_relative '../../../../lib/utilities/schedules/schedule'
 
-# Flow specs live under spec/utilities/flows, next to the code in lib/utilities/flows
 # The fake runner, fixed clock and project folders sit next to the adapter under test
 # rubocop:disable RSpec/MultipleMemoizedHelpers
-RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/FilePath
+RSpec.describe RubyRaider::Schedules::Os::TaskScheduler do # rubocop:disable RSpec/FilePath
   # Records every command and answers from a table keyed by the schtasks verb; never runs anything
   let(:fake_runner_class) do
     Class.new do
@@ -22,7 +22,7 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
         @calls << argv
         @seen&.call(argv, stdin_data)
         stderr, status, stdout = answers.fetch(argv[1], ['', 0])
-        RubyRaider::Flows::Os::CommandRunner::Result.new(stdout: stdout.to_s, stderr: stderr, exitstatus: status)
+        RubyRaider::Schedules::Os::CommandRunner::Result.new(stdout: stdout.to_s, stderr: stderr, exitstatus: status)
       end
 
       def on_call(&block) = @seen = block
@@ -30,18 +30,20 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
   end
 
   let(:hostile) { %q('; rm -rf ~; ' </string> %h $(id) " \\ &) }
-  let(:tmp) { File.realpath(Dir.mktmpdir('flows-schtasks')) }
+  let(:tmp) { File.realpath(Dir.mktmpdir('schedules-schtasks')) }
   let(:project_dir) { File.join(tmp, 'plain') }
   let(:runner) { fake_runner_class.new }
   let(:clock) { Struct.new(:now).new(Time.new(2026, 11, 9, 10, 30, 0)) }
   let(:schtasks) { 'C:\\Windows\\System32\\schtasks.exe' }
-  let(:scheduler) { described_class.new(runner: runner, clock: clock, schtasks: schtasks) }
+  let(:scheduler) { described_class.new(kind: RubyRaider::Schedules::Kind::TESTS, runner: runner, clock: clock, schtasks: schtasks) }
   let(:now) { Time.utc(2026, 11, 9, 10, 0, 0) }
 
-  def schedule(dir: project_dir, **options)
+  def schedule(dir: project_dir, gem_env: {}, bundle: '/opt/ruby/bin/bundle', **options)
     FileUtils.mkdir_p(dir)
-    project = RubyRaider::Flows::Project.new(File.realpath(dir))
-    RubyRaider::Flows::Schedule.build(project: project, name: 'report', every: 'day', at: '08:00', now: now, **options)
+    # Hermetic: the GEM_HOME/GEM_PATH and bundle this spec runs with never reach the entry; a spec passes its own
+    allow(RubyRaider::Schedules::Schedule).to receive_messages(captured_gem_env: gem_env, bundle_path: bundle)
+    project = RubyRaider::Schedules::Project.new(File.realpath(dir))
+    RubyRaider::Schedules::Schedule.build(project: project, name: 'report', every: 'day', at: '08:00', now: now, **options)
   end
 
   def task_name(item) = "\\RubyRaider\\#{item.os_id}"
@@ -193,7 +195,7 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
       <?xml version="1.0" encoding="UTF-16"?>
       <Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
         <RegistrationInfo>
-          <Description>Ruby Raider flow report (every day at 08:00)</Description>
+          <Description>Ruby Raider schedule report (every day at 08:00)</Description>
           <URI>\\RubyRaider\\#{item.os_id}</URI>
         </RegistrationInfo>
         <Triggers>
@@ -279,7 +281,7 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
     end
 
     it "refuses an argument with both ' and a glob character" do
-      expect { described_class.quote("a'*") }.to raise_error(RubyRaider::Flows::Error, /can not pass "a'\*" to ruby\.exe/)
+      expect { described_class.quote("a'*") }.to raise_error(RubyRaider::Schedules::Error, /can not pass "a'\*" to ruby\.exe/)
     end
   end
 
@@ -290,13 +292,14 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
     end
 
     it 'carries no environment and no log file' do
-      text = scheduler.task_xml(schedule)
+      # Without the random temp folder's name, which may hold any of these words
+      text = scheduler.task_xml(schedule).gsub(tmp, '')
 
       expect(text).not_to include('scheduler.log', 'Environment', 'GEM_HOME', 'cmd', 'powershell')
     end
 
-    it 'runs ruby with the bundle path and the flow run arguments' do
-      item = schedule(retries: 2, inputs: %w[env=staging])
+    it 'runs ruby with the bundle path and the schedule run arguments' do
+      item = schedule(retries: 2, selection: RubyRaider::Schedules::Selection.new(kind: 'tag', tag: 'smoke'))
       text = scheduler.task_xml(item)
 
       expect(field(text, 'Task/Actions/Exec/Command')).to eq(item.ruby)
@@ -338,7 +341,7 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
 
     # One at a time: a lone % in both would read as %...% across the joined Arguments and be refused
     {
-      'an input value' => ->(spec) { spec.schedule(inputs: ["note=#{spec.hostile}"]) },
+      'the bundle path' => ->(spec) { spec.schedule(bundle: "/opt/#{spec.hostile}/bundle") },
       'the project path' => ->(spec) { spec.schedule(dir: File.join(spec.tmp, 'p<', "string> #{spec.hostile}")) }
     }.each do |where, build|
       describe "with hostile values in #{where}" do
@@ -363,46 +366,49 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
   end
 
   describe 'with quotes and glob characters but no spaces' do
-    let(:item) { schedule(dir: File.join(tmp, 'Users', "O'Brien", 'proj'), inputs: ["a=x'", "b=y'", 'c=p[1]', 'd=a*b']) }
+    let(:item) { schedule(dir: File.join(tmp, 'Users', "O'Brien", "proj'"), bundle: '/opt/p[1]/a*b/bundle') }
 
     it "quotes them so ruby.exe reads the exact argv back and globs nothing ('...' around a glob)" do
       line = field(scheduler.task_xml(item), 'Task/Actions/Exec/Arguments')
 
       expect(ruby_split_arguments(line)).to eq(item.argv.drop(1))
-      expect(line).to include(%("#{item.project_root}"), %("a=x'"), %("b=y'"), "'c=p[1]'", "'d=a*b'")
+      expect(line).to include(%("#{item.project_root}"), "'/opt/p[1]/a*b/bundle'")
     end
 
-    it "refuses an input with both ' and a glob character before any schtasks call" do
-      expect { scheduler.install(schedule(inputs: ["e=a'*"])) }.to raise_error(RubyRaider::Flows::Error, /ruby\.exe/)
+    it "refuses an argument with both ' and a glob character before any schtasks call" do
+      expect { scheduler.install(schedule(bundle: "/opt/a'*/bundle")) }.to raise_error(RubyRaider::Schedules::Error, /ruby\.exe/)
       expect(runner.calls).to be_empty
     end
   end
 
   describe 'with %NAME% that Task Scheduler would expand' do
-    it 'refuses it in an input value before any schtasks call' do
-      item = schedule(inputs: ['note=%PATH%'])
+    it 'refuses it in the bundle path before any schtasks call' do
+      item = schedule(bundle: '/opt/%PATH%/bundle')
 
-      expect { scheduler.install(item) }.to raise_error(RubyRaider::Flows::Error, /Task Scheduler would expand %PATH% as an environment variable/)
+      expect { scheduler.install(item) }.to raise_error(RubyRaider::Schedules::Error, /Task Scheduler would expand %PATH% as an environment variable/)
       expect(runner.calls).to be_empty
     end
 
     it 'refuses it in the project path before any schtasks call' do
       item = schedule(dir: File.join(tmp, '%PATH%', 'proj'))
 
-      expect { scheduler.install(item) }.to raise_error(RubyRaider::Flows::Error, /would expand %PATH%/)
-      expect { scheduler.task_xml(item) }.to raise_error(RubyRaider::Flows::Error, /would expand %PATH%/)
+      expect { scheduler.install(item) }.to raise_error(RubyRaider::Schedules::Error, /would expand %PATH%/)
+      expect { scheduler.task_xml(item) }.to raise_error(RubyRaider::Schedules::Error, /would expand %PATH%/)
       expect(runner.calls).to be_empty
     end
 
     it 'refuses a %...% formed across two arguments in the joined Arguments' do
-      expect { scheduler.install(schedule(inputs: ['a=%x', 'b=y%'])) }.to raise_error(RubyRaider::Flows::Error, /would expand %x b=y%/)
+      item = schedule(dir: File.join(tmp, 'y%'), bundle: '/opt/%x/bundle')
+
+      expect { scheduler.install(item) }.to raise_error(RubyRaider::Schedules::Error, %r{would expand %x/bundle exec raider schedule run report --project .*/y%})
       expect(runner.calls).to be_empty
     end
 
     it 'keeps a lone %' do
-      item = schedule(inputs: ['note=100% sure'])
+      item = schedule(dir: File.join(tmp, '100% sure'))
 
-      expect(split_arguments(field(scheduler.task_xml(item), 'Task/Actions/Exec/Arguments')).last).to eq('note=100% sure')
+      expect(split_arguments(field(scheduler.task_xml(item), 'Task/Actions/Exec/Arguments'))).to eq(item.argv.drop(1))
+      expect(item.project_root).to end_with('/100% sure')
     end
   end
 
@@ -426,7 +432,7 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
       runner.on_call { |argv, _| path = argv[5] }
       runner.answers['/Create'] = ["ERROR: Access is denied.\e[2J\n", 1]
 
-      expect { scheduler.install(item) }.to raise_error(RubyRaider::Flows::Error, /Task Scheduler.*#{Regexp.escape(item.os_id)}.*Access is denied\.\?\[2J/)
+      expect { scheduler.install(item) }.to raise_error(RubyRaider::Schedules::Error, /Task Scheduler.*#{Regexp.escape(item.os_id)}.*Access is denied\.\?\[2J/)
       expect(File.exist?(path)).to be(false)
     end
   end
@@ -453,18 +459,18 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
       runner.answers['/Delete'] = ["ERROR: Access\e is denied.\n", 1]
       runner.answers['/Query'] = ['', 0, csv_rows('\\Other', task_name(item))]
 
-      expect { scheduler.remove(item.os_id) }.to raise_error(RubyRaider::Flows::Error, /Task Scheduler could not delete .*Access\? is denied\.\z/)
+      expect { scheduler.remove(item.os_id) }.to raise_error(RubyRaider::Schedules::Error, /Task Scheduler could not delete .*Access\? is denied\.\z/)
     end
 
     it 'raises with the delete error when the task list can not be read' do
       runner.answers['/Delete'] = ['ERROR: Access is denied.', 1]
       runner.answers['/Query'] = ['ERROR: list failed', 1]
 
-      expect { scheduler.remove(schedule.os_id) }.to raise_error(RubyRaider::Flows::Error, /could not delete .*Access is denied/)
+      expect { scheduler.remove(schedule.os_id) }.to raise_error(RubyRaider::Schedules::Error, /could not delete .*Access is denied/)
     end
 
-    it 'refuses an os_id that is not a flow schedule id' do
-      expect { scheduler.remove('..\\..\\evil') }.to raise_error(RubyRaider::Flows::Error, /Invalid os_id/)
+    it 'refuses an os_id that is not a schedule id' do
+      expect { scheduler.remove('..\\..\\evil') }.to raise_error(RubyRaider::Schedules::Error, /Invalid os_id/)
       expect(runner.calls).to be_empty
     end
   end
@@ -488,7 +494,7 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
     it 'raises when the task list can not be read' do
       runner.answers['/Query'] = ["ERROR: no\e list", 1]
 
-      expect { scheduler.present?(schedule.os_id) }.to raise_error(RubyRaider::Flows::Error, /could not list tasks: ERROR: no\? list/)
+      expect { scheduler.present?(schedule.os_id) }.to raise_error(RubyRaider::Schedules::Error, /could not list tasks: ERROR: no\? list/)
     end
   end
 
@@ -497,7 +503,7 @@ RSpec.describe RubyRaider::Flows::Os::TaskScheduler do # rubocop:disable RSpec/F
     allow(ENV).to receive(:fetch).with('SystemRoot', anything).and_return('D:\\Win')
     item = schedule
 
-    described_class.new(runner: runner, clock: clock).remove(item.os_id)
+    described_class.new(kind: RubyRaider::Schedules::Kind::TESTS, runner: runner, clock: clock).remove(item.os_id)
 
     expect(runner.calls.first.first).to eq(File.join('D:\\Win', 'System32', 'schtasks.exe'))
   end