ruby_raider 4.1.0 → 4.2.0

data/spec/utilities/schedules/schedule_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'digest'
+require_relative '../../../lib/utilities/schedules/schedule'
+
+RSpec.describe RubyRaider::Schedules::Schedule do # rubocop:disable RSpec/FilePath
+  let(:dir) { File.realpath(Dir.mktmpdir('schedules-schedule')) }
+  let(:project) { RubyRaider::Schedules::Project.new(dir) }
+  let(:now) { Time.utc(2026, 11, 9, 10, 0, 0) }
+  let(:mac) { 'darwin24' }
+
+  before do
+    FileUtils.mkdir_p(File.join(dir, 'spec'))
+    File.write(File.join(dir, 'spec/a_spec.rb'), '')
+  end
+
+  after { FileUtils.rm_rf(dir) }
+
+  def build(**options)
+    described_class.build(project: project, name: 'nightly', every: 'day', at: '08:00', now: now, host_os: mac, **options)
+  end
+
+  def error_for(**options)
+    build(**options)
+    nil
+  rescue RubyRaider::Schedules::Error => e
+    e.message
+  end
+
+  def files(*names) = RubyRaider::Schedules::Selection.parse(files: names, tag: nil, root: dir, host_os: mac)
+
+  it 'keeps every field of the entry, with all tests by default' do
+    schedule = build(every: 'week', on: 'tue', retries: 2, notify: true, show_browser: true)
+    hash = schedule.to_h
+
+    expect(hash.keys).to eq(%w[name every at on retries notify show_browser selection os_id ruby bundle gem_env created_at])
+    expect(hash.slice('name', 'every', 'at', 'on', 'retries', 'notify', 'show_browser', 'selection', 'created_at'))
+      .to eq({ 'name' => 'nightly', 'every' => 'week', 'at' => '08:00', 'on' => 'tue', 'retries' => 2, 'notify' => true,
+               'show_browser' => true, 'selection' => { 'kind' => 'all' }, 'created_at' => '2026-11-09T10:00:00Z' })
+  end
+
+  it 'names the os_id after the project and the name' do
+    expect(build.os_id).to eq("dev.rubyraider.schedule.#{Digest::SHA256.hexdigest(dir)[0, 10]}.nightly")
+  end
+
+  it 'runs raider schedule run NAME and nothing else from the OS entry' do
+    schedule = build(retries: 3, notify: true, show_browser: true, selection: files('spec/a_spec.rb'))
+
+    expect(schedule.argv).to eq([schedule.ruby, schedule.bundle, 'exec', 'raider', 'schedule', 'run', 'nightly', '--project', dir, '--trigger', 'schedule'])
+  end
+
+  it 'logs the scheduler output under .raider/schedules and keeps the 4.1 env' do
+    schedule = build
+
+    expect([schedule.log_path, schedule.env.keys.first(2), schedule.working_directory])
+      .to eq([File.join(dir, '.raider/schedules/nightly/scheduler.log'), %w[PATH LANG], dir])
+  end
+
+  it 'refuses show_browser on Linux and nowhere else' do
+    expect([error_for(show_browser: true, host_os: 'x86_64-linux-gnu'), error_for(show_browser: false, host_os: 'x86_64-linux-gnu'),
+            error_for(show_browser: true, host_os: 'mingw32')])
+      .to eq(["Show the browser isn't available for scheduled runs on Linux", nil, nil])
+  end
+
+  it 'refuses a bad name, show_browser or selection' do
+    errors = [error_for(name: 'Nightly'), error_for(name: 'a' * 61), error_for(show_browser: 'yes'), error_for(selection: { 'kind' => 'all' })]
+
+    expect(errors).to eq(['Invalid schedule name "Nightly": use 1 to 60 of a-z, 0-9 and _', "Invalid schedule name \"#{'a' * 61}\": use 1 to 60 of a-z, 0-9 and _",
+                          'Invalid show_browser "yes": use true or false', 'Invalid selection: use a Selection'])
+  end
+
+  it 'shares the rule checks with flow schedules' do
+    expect([error_for(every: 'month'), error_for(at: '8:00'), error_for(retries: 4), error_for(notify: 'yes')])
+      .to eq(['Invalid every "month": use hour, day, weekday or week', 'Invalid at "8:00": use HH:MM (24h)',
+              'Invalid retries 4: use 0 to 3', 'Invalid notify "yes": use true or false'])
+  end
+
+  describe '.from_h' do
+    it 'reads back what to_h wrote' do
+      schedule = build(selection: files('spec/a_spec.rb'), show_browser: true)
+
+      expect(described_class.from_h(schedule.to_h, dir, host_os: mac).to_h).to eq(schedule.to_h)
+    end
+
+    it 'loads an entry whose spec file is gone' do
+      hash = build(selection: files('spec/a_spec.rb')).to_h
+      File.delete(File.join(dir, 'spec/a_spec.rb'))
+
+      expect(described_class.from_h(hash, dir, host_os: mac).selection.missing_file(dir)).to eq('spec/a_spec.rb')
+    end
+
+    it 'treats an entry without show_browser as off' do
+      expect(described_class.from_h(build.to_h.except('show_browser'), dir, host_os: mac).show_browser).to be(false)
+    end
+
+    it 'refuses an entry from another project, a flow entry, a broken selection or a non-mapping' do
+      other = File.realpath(Dir.mktmpdir('schedules-other'))
+      flow = build.to_h.merge('os_id' => build.os_id.sub('.schedule.', '.flow.'))
+      entries = [[build.to_h, other], [flow, dir], [build.to_h.merge('selection' => { 'kind' => 'tag', 'tag' => 'a;b' }), dir],
+                 [build.to_h.except('selection'), dir], ['nightly', dir]]
+      errors = entries.map do |hash, root|
+        described_class.from_h(hash, root, host_os: mac)
+        nil
+      rescue RubyRaider::Schedules::Error => e
+        e.message
+      end
+
+      expect(errors).to all(be_a(String))
+    ensure
+      FileUtils.rm_rf(other)
+    end
+  end
+
+  it 'is frozen' do
+    schedule = build(selection: files('spec/a_spec.rb'))
+
+    expect([schedule, schedule.selection, schedule.name]).to all(be_frozen)
+  end
+end

data/spec/utilities/schedules/schedule_store_spec.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require_relative '../../../lib/utilities/schedules/schedule_store'
+
+RSpec.describe RubyRaider::Schedules::ScheduleStore do # rubocop:disable RSpec/FilePath
+  let(:dir) { File.realpath(Dir.mktmpdir('schedules-store')) }
+  let(:project) { RubyRaider::Schedules::Project.new(dir) }
+  let(:store) { described_class.new(project) }
+  let(:file) { File.join(dir, '.raider/schedules/schedules.yml') }
+  let(:gitignore) { File.join(dir, '.gitignore') }
+
+  before do
+    FileUtils.mkdir_p(File.join(dir, 'spec'))
+    File.write(File.join(dir, 'spec/a_spec.rb'), '')
+  end
+
+  after { FileUtils.rm_rf(dir) }
+
+  def schedule(name, **options)
+    RubyRaider::Schedules::Schedule.build(project: project, name: name, every: 'day', at: '08:00', host_os: 'darwin24', **options)
+  end
+
+  def files(*names) = RubyRaider::Schedules::Selection.parse(files: names, tag: nil, root: dir, host_os: 'darwin24')
+
+  it 'saves to .raider/schedules/schedules.yml, 0600 in a 0700 folder, sorted, and reads it back' do
+    store.save(schedule('zeta', selection: files('spec/a_spec.rb'), show_browser: true))
+    store.save(schedule('alpha'))
+
+    expect([store.all.map(&:name), store.find('zeta').selection.files, store.find('zeta').show_browser]).to eq([%w[alpha zeta], %w[spec/a_spec.rb], true])
+    expect([File.stat(file).mode & 0o777, File.stat(File.dirname(file)).mode & 0o777]).to eq([0o600, 0o700])
+    expect(YAML.safe_load_file(file)['schedules'].last['selection']).to eq({ 'kind' => 'files', 'files' => %w[spec/a_spec.rb] })
+  end
+
+  it 'still lists a schedule whose spec file is gone' do
+    store.save(schedule('nightly', selection: files('spec/a_spec.rb')))
+    File.delete(File.join(dir, 'spec/a_spec.rb'))
+
+    expect(store.find('nightly').selection.missing_file(dir)).to eq('spec/a_spec.rb')
+  end
+
+  it 'skips an entry that fails re-validation and keeps it when it writes' do
+    FileUtils.mkdir_p(File.dirname(file))
+    hostile = schedule('bad').to_h.merge('selection' => { 'kind' => 'files', 'files' => ['../x_spec.rb'] })
+    File.write(file, { 'schedules' => [hostile, 'junk'] }.to_yaml)
+    store.save(schedule('nightly'))
+
+    expect([store.all.map(&:name), YAML.safe_load_file(file)['schedules'].size]).to eq([%w[nightly], 3])
+  end
+
+  it 'refuses to overwrite a file that is not a schedules file' do
+    FileUtils.mkdir_p(File.dirname(file))
+    File.write(file, "schedules: [\n")
+
+    expect { store.save(schedule('nightly')) }
+      .to raise_error(RubyRaider::Schedules::Error, '.raider/schedules/schedules.yml is not a schedules file: fix or remove it, then try again')
+    expect(File.read(file)).to eq("schedules: [\n")
+  end
+
+  it 'refuses a linked schedules folder' do
+    FileUtils.mkdir_p(File.join(dir, 'elsewhere'))
+    FileUtils.mkdir_p(File.join(dir, '.raider'))
+    File.symlink(File.join(dir, 'elsewhere'), File.join(dir, '.raider/schedules'))
+
+    expect { store.save(schedule('nightly')) }.to raise_error(RubyRaider::Schedules::Error, '.raider/schedules must be a folder, not a link')
+  end
+
+  it 'does not load Ruby objects' do
+    FileUtils.mkdir_p(File.dirname(file))
+    File.write(file, "--- !ruby/object:OpenStruct\ntable: {}\n")
+
+    expect(store.all).to eq([])
+  end
+
+  it 'returns the name and test os_id of an entry it removed but could not read' do
+    FileUtils.mkdir_p(File.dirname(file))
+    File.write(file, { 'schedules' => [{ 'name' => 'nightly' }] }.to_yaml)
+    removed = store.delete('nightly')
+
+    expect([removed.name, removed.os_id]).to eq(['nightly', RubyRaider::Schedules::Schedule.os_id_for(dir, 'nightly')])
+  end
+
+  describe '#ignore_in_git' do
+    it 'creates .gitignore with the line when there is none' do
+      expect([store.ignore_in_git, File.read(gitignore)]).to eq([true, ".raider/schedules/\n"])
+    end
+
+    it 'appends the line, keeping every byte and adding a newline first when the file lacks one' do
+      File.binwrite(gitignore, "node_modules/\r\n\xFFraw")
+
+      expect([store.ignore_in_git, File.binread(gitignore)]).to eq([true, "node_modules/\r\n\xFFraw\n.raider/schedules/\n".b])
+    end
+
+    it 'leaves the file alone when the exact line is there, and only adds it once' do
+      File.write(gitignore, "a/\n.raider/schedules/\r\nb/")
+      before = File.binread(gitignore)
+
+      expect([store.ignore_in_git, File.binread(gitignore)]).to eq([false, before])
+    end
+
+    it 'adds the line when only a comment, a longer line or a prefix mentions it' do
+      File.write(gitignore, "# .raider/schedules/\n.raider/schedules/x\n.raider/\n")
+      first = store.ignore_in_git
+
+      expect([first, store.ignore_in_git, File.read(gitignore).lines.last]).to eq([true, false, ".raider/schedules/\n"])
+    end
+
+    it 'refuses a .gitignore that is not a file' do
+      FileUtils.mkdir_p(gitignore)
+
+      expect { store.ignore_in_git }.to raise_error(RubyRaider::Schedules::Error, '.gitignore must be a file')
+    end
+
+    it 'refuses a linked .gitignore and never writes through it' do
+      target = File.join(File.realpath(Dir.mktmpdir('outside')), 'ignored')
+      File.write(target, "keep\n")
+      File.symlink(target, gitignore)
+
+      expect { store.ignore_in_git }.to raise_error(RubyRaider::Schedules::Error, '.gitignore is a link: add .raider/schedules/ to it yourself')
+      expect([File.read(target), File.symlink?(gitignore)]).to eq(["keep\n", true])
+    ensure
+      FileUtils.rm_rf(File.dirname(target))
+    end
+
+    it 'refuses a dangling .gitignore link without making its target' do
+      target = File.join(dir, 'made_by_the_link')
+      File.symlink(target, gitignore)
+
+      expect { store.ignore_in_git }.to raise_error(RubyRaider::Schedules::Error, /is a link/)
+      expect(File.exist?(target)).to be(false)
+    end
+
+    it 'leaves a read-only .gitignore that has the line alone, and says so when it lacks it' do
+      File.write(gitignore, ".raider/schedules/\n")
+      File.chmod(0o444, gitignore)
+      expect(store.ignore_in_git).to be(false)
+
+      File.chmod(0o644, gitignore)
+      File.write(gitignore, "a/\n")
+      File.chmod(0o444, gitignore)
+      expect { store.ignore_in_git }.to raise_error(Errno::EACCES)
+      expect(File.read(gitignore)).to eq("a/\n")
+    end
+
+    it 'refuses a .gitignore that is a FIFO without blocking' do
+      File.mkfifo(gitignore)
+
+      expect { store.ignore_in_git }.to raise_error(RubyRaider::Schedules::Error, '.gitignore must be a file')
+    end
+  end
+end

data/spec/utilities/schedules/scheduler_launchd_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'tmpdir'
+require_relative '../../../lib/utilities/schedules/scheduler'
+
+# The scheduler with the real launchd adapter: plists in a temp home, launchctl and plutil played by a fake
+# runner. Nothing real is run and the real ~/Library/LaunchAgents is never read.
+# rubocop:disable RSpec/MultipleMemoizedHelpers
+RSpec.describe RubyRaider::Schedules::Scheduler do # rubocop:disable RSpec/FilePath
+  # Records every command and answers success; launchctl print succeeds only for a loaded service
+  let(:runner_class) do
+    Class.new do
+      attr_reader :calls, :loaded
+
+      def initialize
+        @calls = []
+        @loaded = []
+      end
+
+      def call(*argv, **)
+        @calls << argv
+        verb = argv[1]
+        target = argv.last
+        status = 0
+        case verb
+        when 'bootstrap' then @loaded << File.basename(target, '.plist')
+        when 'bootout' then status = @loaded.delete(target.split('/').last) ? 0 : 3
+        when 'print' then status = @loaded.include?(target.split('/').last) ? 0 : 113
+        end
+        RubyRaider::Schedules::Os::CommandRunner::Result.new(stdout: '', stderr: '', exitstatus: status)
+      end
+    end
+  end
+
+  let(:tmp) { File.realpath(Dir.mktmpdir('schedules-launchd-wiring')) }
+  let(:home) { File.join(tmp, 'home') }
+  let(:root) do
+    File.join(tmp, 'project').tap do |dir|
+      FileUtils.mkdir_p(dir)
+      # add checks the project's bundle has `raider schedule`
+      File.write(File.join(dir, 'Gemfile'), "gem 'ruby_raider'\n")
+      File.write(File.join(dir, 'Gemfile.lock'), "GEM\n  specs:\n    ruby_raider (#{RubyRaider::Schedules::Project::OWN_VERSION})\n")
+    end
+  end
+  let(:project) { RubyRaider::Schedules::Project.new(root) }
+  let(:runner) { runner_class.new }
+  let(:launchd) { RubyRaider::Schedules::Os::Launchd.new(kind: RubyRaider::Schedules::Kind::TESTS, runner: runner, home: home, uid: 501) }
+  let(:out) { StringIO.new }
+  let(:scheduler) do
+    described_class.new(project, adapter: launchd, out: out, err: StringIO.new, now: -> { Time.local(2026, 11, 8, 12) }, host_os: 'darwin25')
+  end
+  let(:os_id) { RubyRaider::Schedules::Schedule.os_id_for(project.root, 'nightly') }
+  let(:plist) { File.join(home, 'Library', 'LaunchAgents', "#{os_id}.plist") }
+
+  after { FileUtils.rm_rf(tmp) }
+
+  def states
+    out.truncate(0)
+    out.rewind
+    scheduler.list(json: true)
+    JSON.parse(out.string)['schedules'].map { |row| [row['name'], row['os_state']] }
+  end
+
+  it 'adds, lists an entry schedules.yml lost, and removes it, touching only the temp home' do
+    scheduler.add('nightly', every: 'day', at: '08:00')
+    expect([File.file?(plist), states]).to eq([true, [%w[nightly ok]]])
+
+    File.write(File.join(project.root, '.raider/schedules/schedules.yml'), "schedules: []\n")
+    expect(states).to eq([['nightly', 'missing from schedules.yml']])
+
+    scheduler.remove('nightly')
+    expect([File.exist?(plist), states, out.string]).to eq([false, [], %({"notice":null,"schedules":[]}\n)])
+    expect(runner.calls.flatten.select { |arg| arg.start_with?('/') && !arg.start_with?('/bin/', '/usr/bin/') }).to all(start_with(tmp))
+  end
+end
+# rubocop:enable RSpec/MultipleMemoizedHelpers