ruby_raider 4.1.0 → 4.2.0

data/spec/utilities/schedules/os_entry_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require_relative '../../../lib/utilities/schedules/schedule'
+require_relative '../../../lib/utilities/schedules/os/launchd'
+require_relative '../../../lib/utilities/schedules/os/task_scheduler'
+require_relative '../../../lib/utilities/schedules/os/systemd'
+require_relative '../../../lib/utilities/schedules/os/cron'
+
+# The OS entry of a test schedule holds its name only: the selection, retries, notify and show_browser
+# are read from schedules.yml at run time, so no file name or tag can reach a plist, XML, unit or crontab.
+RSpec.describe 'A test schedule OS entry' do
+  let(:tmp) { File.realpath(Dir.mktmpdir('schedules-entry')) }
+  let(:root) { File.join(tmp, 'project') }
+  let(:runner) { instance_double(RubyRaider::Schedules::Os::CommandRunner) }
+  let(:now) { Time.utc(2026, 11, 9, 10, 0, 0) }
+  let(:hostile) { %q(spec/$(id) & <x> "q" 'p' %PATH% `w`; rm -rf ~_spec.rb) }
+
+  before do
+    FileUtils.mkdir_p(File.join(root, 'spec'))
+    [hostile, 'spec/a_spec.rb'].each { |file| File.write(File.join(root, file), '') }
+  end
+
+  after { FileUtils.rm_rf(tmp) }
+
+  def schedule(**options)
+    project = RubyRaider::Schedules::Project.new(root)
+    RubyRaider::Schedules::Schedule.build(project: project, name: 'nightly', every: 'weekday', at: '07:30', now: now, host_os: 'darwin24', **options)
+  end
+
+  def kind = RubyRaider::Schedules::Kind::TESTS
+
+  def entries(item)
+    clock = Struct.new(:now).new(Time.new(2026, 11, 9, 10, 30, 0))
+    systemd = RubyRaider::Schedules::Os::Systemd.new(kind: kind, runner: runner, home: tmp, config_home: nil)
+    [RubyRaider::Schedules::Os::Launchd.new(kind: kind, runner: runner, home: tmp, uid: 501).plist(item),
+     RubyRaider::Schedules::Os::TaskScheduler.new(kind: kind, runner: runner, clock: clock, schtasks: 'C:\\schtasks.exe').task_xml(item),
+     systemd.service(item), systemd.timer(item), RubyRaider::Schedules::Os::Cron.new(kind: kind, runner: runner).line(item)]
+  end
+
+  it 'is byte-identical for two different selections, retries, notify and show_browser' do
+    files = RubyRaider::Schedules::Selection.parse(files: [hostile, 'spec/a_spec.rb'], tag: nil, root: root, host_os: 'darwin24')
+    all_tests = entries(schedule)
+    picked = entries(schedule(selection: files, retries: 3, notify: true, show_browser: true))
+    tagged = entries(schedule(selection: RubyRaider::Schedules::Selection.parse(files: [], tag: 'zz_tag_sentinel', root: root, host_os: 'darwin24')))
+
+    expect([picked, tagged]).to eq([all_tests, all_tests])
+    expect(all_tests.join).not_to include('rm -rf', '%PATH%', 'a_spec.rb', 'zz_tag_sentinel', '--retries', '--notify', 'show-browser', 'show_browser')
+  end
+
+  it 'names the test schedule kind and the schedule in every entry' do
+    expect(entries(schedule)).to all(include('nightly', 'schedule'))
+  end
+end

data/spec/utilities/schedules/os_enumerator_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require_relative '../../../lib/utilities/schedules/os_enumerator'
+require_relative '../../../lib/utilities/schedules/schedule'
+
+RSpec.describe RubyRaider::Schedules::OsEnumerator do # rubocop:disable RSpec/FilePath
+  # Answers list_ids with what it was given, recording the prefix asked for
+  let(:fake_adapter) do
+    Class.new do
+      attr_reader :asked
+
+      def initialize(ids = [], error: nil)
+        @ids = ids
+        @error = error
+      end
+
+      def list_ids(prefix)
+        @asked = prefix
+        raise @error if @error
+
+        @ids
+      end
+    end
+  end
+
+  let(:root) { '/projects/shop' }
+  let(:prefix) { RubyRaider::Schedules::Schedule.os_id_prefix_for(root) }
+  let(:other) { RubyRaider::Schedules::Schedule.os_id_prefix_for('/projects/other') }
+  let(:legacy) { Class.new(RubyRaider::Schedules::Rule) { def self.kind = RubyRaider::Schedules::Kind::FLOW_LEGACY }.os_id_prefix_for(root) }
+
+  def enumerator(adapter) = described_class.new(adapter, schedule_class: RubyRaider::Schedules::Schedule, root: root)
+
+  it "asks for this project's prefix and returns the schedule names, sorted and once each" do
+    adapter = fake_adapter.new(["#{prefix}smoke", "#{prefix}nightly", "#{prefix}smoke"])
+
+    expect(enumerator(adapter).names).to eq(%w[nightly smoke])
+    expect(adapter.asked).to eq(prefix)
+  end
+
+  it "ignores what an adapter should not have returned: another project's, a flow's and hostile ids" do
+    hostile = ["#{other}nightly", "#{legacy}nightly", "#{prefix}../../x", "#{prefix}a;rm -rf ~", "#{prefix}Bad", nil, 42,
+               "#{prefix}ok\nx", "#{prefix}a\xFF".dup.force_encoding(Encoding::UTF_8), "#{prefix}#{'a' * 61}"]
+
+    expect(enumerator(fake_adapter.new(hostile + ["#{prefix}ok"])).names).to eq(%w[ok])
+  end
+
+  it 'is empty when the OS scheduler can not be read, or the adapter can not enumerate' do
+    failing = fake_adapter.new(error: RubyRaider::Schedules::Error.new('task list unreadable'))
+
+    expect([enumerator(failing).names, enumerator(Object.new).names, enumerator(fake_adapter.new(nil)).names]).to eq([[], [], []])
+  end
+
+  it 'lets an unexpected error through' do
+    expect { enumerator(fake_adapter.new(error: ArgumentError.new('bug'))).names }.to raise_error(ArgumentError, 'bug')
+  end
+end

data/spec/utilities/schedules/project_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+require_relative '../../../lib/utilities/schedules/project'
+
+RSpec.describe RubyRaider::Schedules::Project do # rubocop:disable RSpec/FilePath
+  let(:dir) { File.realpath(Dir.mktmpdir('raider-project')) }
+  let(:outside) { File.realpath(Dir.mktmpdir('raider-outside')) }
+  let(:project) { described_class.new(dir) }
+  let(:helper) { File.join(dir, 'helpers', 'driver_helper.rb') }
+  let(:runtime_helper) { "# frozen_string_literal: true\n\nrequire 'yaml'\nrequire 'ruby_raider/runtime'\n" }
+
+  before { FileUtils.mkdir_p(File.dirname(helper)) }
+
+  after { FileUtils.rm_rf([dir, outside]) }
+
+  describe '#runtime_driver?' do
+    it 'is true when helpers/driver_helper.rb requires the runtime' do
+      File.write(helper, runtime_helper)
+      expect(project.runtime_driver?).to be(true)
+    end
+
+    it 'is true for a helper with bytes that are not UTF-8' do
+      File.binwrite(helper, "# \xFF\xFE\n#{runtime_helper}")
+      expect(project.runtime_driver?).to be(true)
+    end
+
+    it 'is true when the helper links to a file inside the project' do
+      File.write(File.join(dir, 'real_helper.rb'), runtime_helper)
+      File.symlink(File.join(dir, 'real_helper.rb'), helper)
+      expect(project.runtime_driver?).to be(true)
+    end
+
+    it 'is false when the helper is missing, made before 4.0, or only mentions the runtime in a comment' do
+      results = [project.runtime_driver?]
+      File.write(helper, "require 'selenium-webdriver'\nrequire 'yaml'\n")
+      results << project.runtime_driver?
+      File.write(helper, "# require 'ruby_raider/runtime'\n")
+      results << project.runtime_driver?
+      expect(results).to eq([false, false, false])
+    end
+
+    it 'is false when the helper links out of the project' do
+      File.write(File.join(outside, 'driver_helper.rb'), runtime_helper)
+      File.symlink(File.join(outside, 'driver_helper.rb'), helper)
+      expect(project.runtime_driver?).to be(false)
+    end
+
+    it 'is false when helpers/ links out of the project' do
+      FileUtils.mkdir_p(File.join(outside, 'helpers'))
+      File.write(File.join(outside, 'helpers', 'driver_helper.rb'), runtime_helper)
+      FileUtils.rm_rf(File.dirname(helper))
+      File.symlink(File.join(outside, 'helpers'), File.dirname(helper))
+      expect(project.runtime_driver?).to be(false)
+    end
+
+    it 'is false when the helper is not a regular file' do
+      File.mkfifo(helper)
+      expect(project.runtime_driver?).to be(false)
+    end
+  end
+
+  describe '#check_show_browser!' do
+    it 'refuses a project made before Ruby Raider 4.0' do
+      File.write(helper, "require 'selenium-webdriver'\n")
+      expect { project.check_show_browser! }
+        .to raise_error(RubyRaider::Schedules::Error, 'Show the browser needs a project made with Ruby Raider 4.0 or later')
+    end
+
+    it 'accepts a project whose driver_helper requires the runtime' do
+      File.write(helper, runtime_helper)
+      expect { project.check_show_browser! }.not_to raise_error
+    end
+  end
+
+  describe '#check_raider_version!' do
+    own = RubyRaider::Schedules::Project::OWN_VERSION
+    needs = "Scheduling needs ruby_raider #{own} or later in this project"
+
+    def lock(*spec_lines)
+      File.write(File.join(dir, 'Gemfile'), "gem 'ruby_raider'\n")
+      File.write(File.join(dir, 'Gemfile.lock'), "GEM\n  remote: https://rubygems.org/\n  specs:\n#{spec_lines.join("\n")}\n\nDEPENDENCIES\n  ruby_raider\n")
+    end
+
+    it 'reads this gem\'s version from lib/version' do
+      expect(own).to eq(File.read(File.expand_path('../../../lib/version', __dir__)).strip)
+    end
+
+    it 'accepts a lock at this version or later, from rubygems, a path or git' do
+      ['    ruby_raider (%s)', '    ruby_raider (99.0.0)'].each do |line|
+        lock(format(line, own), '    selenium-webdriver (4.52.0)')
+        expect { project.check_raider_version! }.not_to raise_error
+      end
+      File.write(File.join(dir, 'Gemfile.lock'), "PATH\n  remote: ../ruby_raider\n  specs:\n    ruby_raider (#{own})\n      thor\n")
+      expect { project.check_raider_version! }.not_to raise_error
+      File.write(File.join(dir, 'Gemfile.lock'), "GIT\n  remote: https://github.com/RaiderHQ/ruby_raider\n  specs:\n    ruby_raider (#{own})\n")
+      expect { project.check_raider_version! }.not_to raise_error
+    end
+
+    it 'reads a lock with Windows line endings' do
+      lock("    ruby_raider (#{own})")
+      File.write(File.join(dir, 'Gemfile.lock'), File.read(File.join(dir, 'Gemfile.lock')).gsub("\n", "\r\n"))
+      expect { project.check_raider_version! }.not_to raise_error
+    end
+
+    it 'refuses a lock that resolves an older ruby_raider, or none' do
+      lock('    ruby_raider (4.0.1)')
+      expect { project.check_raider_version!('4.2.0') }.to raise_error(RubyRaider::Schedules::Error, 'Scheduling needs ruby_raider 4.2.0 or later in this project: bundle update ruby_raider')
+      lock('    rspec (3.13.0)', '      ruby_raider (= 9.0.0)')
+      expect { project.check_raider_version! }.to raise_error(RubyRaider::Schedules::Error, "#{needs}: bundle update ruby_raider")
+    end
+
+    it 'refuses a project with no Gemfile, or no Gemfile.lock yet' do
+      expect { project.check_raider_version! }.to raise_error(RubyRaider::Schedules::Error, "#{needs}: no Gemfile found")
+      File.write(File.join(dir, 'Gemfile'), "gem 'ruby_raider'\n")
+      expect { project.check_raider_version! }.to raise_error(RubyRaider::Schedules::Error, "#{needs}: run bundle install first")
+    end
+
+    it 'never evaluates the lock' do
+      lock("    ruby_raider (\#{`id`})", "    ruby_raider (\#{exit!})")
+      expect { project.check_raider_version! }.to raise_error(RubyRaider::Schedules::Error, "#{needs}: bundle update ruby_raider")
+    end
+  end
+end

data/spec/utilities/schedules/run_lock_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tmpdir'
+require_relative '../../../lib/utilities/schedules/run_lock'
+require_relative '../../../lib/utilities/schedules/project'
+
+# The lock, its folder and running.json sit next to the project they belong to
+# rubocop:disable RSpec/MultipleMemoizedHelpers
+RSpec.describe RubyRaider::Schedules::RunLock do # rubocop:disable RSpec/FilePath
+  let(:dir) { File.realpath(Dir.mktmpdir('schedules-lock')) }
+  let(:project) { RubyRaider::Schedules::Project.new(dir) }
+  let(:lock) { described_class.new(project) }
+  let(:folder) { File.join(dir, '.raider/schedules') }
+  let(:running) { File.join(folder, 'running.json') }
+  let(:lock_file) { File.join(folder, 'run.lock') }
+  let(:started_at) { '2026-11-11T08:00:00.000Z' }
+
+  after do
+    lock.release
+    FileUtils.rm_rf(dir)
+  end
+
+  def acquire = lock.acquire(name: 'nightly', run_id: 'r1', started_at: started_at)
+
+  def dead_pid
+    pid = Process.spawn(RbConfig.ruby, '-e', 'exit 0')
+    Process.wait(pid)
+    pid
+  end
+
+  def write_running(pid)
+    FileUtils.mkdir_p(folder)
+    File.write(running, JSON.generate('pid' => pid, 'name' => 'other', 'run_id' => 'x', 'started_at' => started_at))
+  end
+
+  it 'takes the lock and writes running.json for the desktop, private' do
+    expect(acquire).to be(true)
+    expect(JSON.parse(File.read(running))).to eq('pid' => Process.pid, 'name' => 'nightly', 'run_id' => 'r1', 'started_at' => started_at)
+    expect([File.stat(running).mode & 0o777, File.stat(lock_file).mode & 0o777, File.stat(folder).mode & 0o777]).to eq([0o600, 0o600, 0o700])
+  end
+
+  it 'removes running.json and frees the lock on release, keeping run.lock' do
+    acquire
+    lock.release
+
+    expect([File.exist?(running), File.exist?(lock_file)]).to eq([false, true])
+    expect(described_class.new(project).acquire(name: 'nightly', run_id: 'r2', started_at: started_at)).to be(true)
+  end
+
+  it 'is busy while another run holds the lock, and writes nothing' do
+    FileUtils.mkdir_p(folder)
+    File.open(lock_file, File::RDWR | File::CREAT, 0o600) do |held|
+      held.flock(File::LOCK_EX)
+
+      expect(acquire).to be(false)
+      expect(File.exist?(running)).to be(false)
+    end
+  end
+
+  it 'is busy while running.json names a live process, and leaves that file alone' do
+    write_running(Process.ppid)
+    before = File.read(running)
+
+    expect(acquire).to be(false)
+    lock.release
+    expect(File.read(running)).to eq(before)
+  end
+
+  it 'replaces a running.json whose process is gone' do
+    write_running(dead_pid)
+
+    expect(acquire).to be(true)
+    expect(JSON.parse(File.read(running))['run_id']).to eq('r1')
+  end
+
+  [0, -1, 'abc', nil, Process.pid].each do |pid|
+    it "treats a running.json with pid #{pid.inspect} as stale" do
+      write_running(pid)
+
+      expect(acquire).to be(true)
+    end
+  end
+
+  it 'treats a running.json that is not JSON as stale' do
+    FileUtils.mkdir_p(folder)
+    File.write(running, 'not json')
+
+    expect(acquire).to be(true)
+  end
+
+  it 'never follows a linked running.json' do
+    FileUtils.mkdir_p(folder)
+    target = File.join(dir, 'target.json')
+    File.write(target, JSON.generate('pid' => Process.ppid))
+    File.symlink(target, running)
+
+    expect(acquire).to be(true)
+    expect([File.symlink?(running), File.read(target)]).to eq([false, JSON.generate('pid' => Process.ppid)])
+  end
+
+  it 'closes run.lock when it is not a regular file' do
+    FileUtils.mkdir_p(folder)
+    File.mkfifo(lock_file)
+    open_before = Dir.children('/dev/fd').size
+
+    expect { acquire }.to raise_error(RubyRaider::Schedules::Error, /run.lock must be a file/)
+    expect(Dir.children('/dev/fd').size).to eq(open_before)
+  end
+
+  it 'is busy, and keeps the new file, when running.json is replaced between the check and the removal' do
+    write_running(dead_pid)
+    real_rename = File.method(:rename)
+    allow(File).to receive(:rename) do |from, to|
+      real_rename.call(from, to)
+      # The desktop writes its own running.json right after ours moved the stale one aside
+      File.write(running, JSON.generate('pid' => Process.ppid, 'run_id' => 'desktop')) if to.end_with?('.stale') && !File.exist?(running)
+    end
+    seen = File.lstat(running)
+    allow(File).to receive(:lstat).and_call_original
+    allow(File).to receive(:lstat).with(a_string_ending_with('.stale')).and_return(instance_double(File::Stat, dev: seen.dev, ino: seen.ino + 1))
+
+    expect(acquire).to be(false)
+    expect([JSON.parse(File.read(running))['run_id'], Dir.children(folder).grep(/stale/)]).to eq(['desktop', []])
+  end
+
+  it 'refuses a linked run.lock' do
+    FileUtils.mkdir_p(folder)
+    File.write(File.join(dir, 'target.lock'), '')
+    File.symlink(File.join(dir, 'target.lock'), lock_file)
+
+    expect { acquire }.to raise_error(RubyRaider::Schedules::Error, /run.lock/)
+  end
+
+  it 'leaves a running.json that another run wrote after ours' do
+    acquire
+    File.write(running, JSON.generate('pid' => Process.ppid, 'run_id' => 'theirs'))
+    lock.release
+
+    expect(JSON.parse(File.read(running))['run_id']).to eq('theirs')
+  end
+end
+# rubocop:enable RSpec/MultipleMemoizedHelpers

data/spec/utilities/schedules/run_log_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tmpdir'
+require_relative '../../../lib/utilities/schedules/run_log'
+require_relative '../../../lib/utilities/schedules/project'
+
+RSpec.describe RubyRaider::Schedules::RunLog do # rubocop:disable RSpec/FilePath
+  let(:dir) { File.realpath(Dir.mktmpdir('schedules-log')) }
+  let(:log) { described_class.new(RubyRaider::Schedules::Project.new(dir), 'nightly') }
+  let(:folder) { File.join(dir, '.raider/schedules/nightly') }
+  let(:file) { File.join(folder, 'runs.jsonl') }
+
+  after { FileUtils.rm_rf(dir) }
+
+  it 'appends one JSON line per run in a private folder' do
+    log.append({ 'run_id' => 'a', 'status' => 'passed' })
+    log.append({ 'run_id' => 'b', 'status' => 'failed' })
+
+    expect(File.readlines(file).map { |line| JSON.parse(line)['run_id'] }).to eq(%w[a b])
+    expect([File.stat(folder).mode & 0o777, File.stat(file).mode & 0o777]).to eq([0o700, 0o600])
+    expect(log.find('a')['status']).to eq('passed')
+  end
+
+  it 'keeps the last 50 lines' do
+    52.times { |n| log.append({ 'run_id' => n.to_s }) }
+
+    ids = log.lines.map { |line| line['run_id'] }
+    expect([ids.size, ids.first, ids.last]).to eq([50, '2', '51'])
+    # No temp file left behind: only the log and its lock
+    expect(Dir.children(folder).sort).to eq(%w[runs.jsonl runs.jsonl.lock])
+  end
+
+  it 'waits for runs.jsonl.lock, so a busy line never overwrites a trim in progress' do
+    50.times { |n| log.append({ 'run_id' => n.to_s }) }
+    File.open(File.join(folder, 'runs.jsonl.lock'), File::RDWR) do |held|
+      held.flock(File::LOCK_EX)
+      busy = Thread.new { log.append({ 'run_id' => 'busy' }) }
+
+      expect([busy.join(0.3), log.lines.size]).to eq([nil, 50])
+      held.flock(File::LOCK_UN)
+      busy.join
+    end
+
+    expect(log.lines.map { |line| line['run_id'] }.values_at(0, -1)).to eq(%w[1 busy])
+  end
+
+  it 'refuses a linked lock and leaves its target alone' do
+    FileUtils.mkdir_p(folder)
+    target = File.join(dir, 'elsewhere.lock')
+    File.symlink(target, File.join(folder, 'runs.jsonl.lock'))
+
+    expect { log.append({ 'run_id' => 'a' }) }.to raise_error(RubyRaider::Schedules::Error, /runs.jsonl.lock must be a file, not a link/)
+    expect([File.exist?(target), File.exist?(file)]).to eq([false, false])
+  end
+
+  it 'refuses a linked log and leaves its target alone' do
+    FileUtils.mkdir_p(folder)
+    target = File.join(dir, 'target.jsonl')
+    File.write(target, "keep\n")
+    File.symlink(target, file)
+
+    expect { log.append({ 'run_id' => 'a' }) }.to raise_error(RubyRaider::Schedules::Error, /runs.jsonl/)
+    expect(File.read(target)).to eq("keep\n")
+  end
+
+  it 'refuses a linked schedule folder' do
+    other = File.join(dir, 'elsewhere')
+    FileUtils.mkdir_p([other, File.join(dir, '.raider/schedules')])
+    File.symlink(other, folder)
+
+    expect { log.append({ 'run_id' => 'a' }) }.to raise_error(RubyRaider::Schedules::Error, /not a link/)
+    expect(Dir.children(other)).to eq([])
+  end
+
+  it 'reads a log of another kind from its own folder' do
+    flow_log = File.join(dir, '.raider/flows/report/runs.jsonl')
+    FileUtils.mkdir_p(File.dirname(flow_log))
+    File.write(flow_log, %({"status":"completed"}\n))
+
+    expect(described_class.new(RubyRaider::Schedules::Project.new(dir), 'report', dir: '.raider/flows').last['status']).to eq('completed')
+  end
+end

data/spec/utilities/schedules/run_report_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tmpdir'
+require_relative '../../../lib/utilities/schedules/run_report'
+require_relative '../../../lib/utilities/schedules/project'
+
+RSpec.describe RubyRaider::Schedules::RunReport do # rubocop:disable RSpec/FilePath
+  let(:dir) { File.realpath(Dir.mktmpdir('schedules-report')) }
+  let(:project) { RubyRaider::Schedules::Project.new(dir) }
+  let(:results) { File.join(dir, 'raider-results') }
+  let(:spawned_at) { Time.utc(2026, 11, 11, 8, 0, 0) }
+  let(:last) { File.join(dir, '.raider/schedules/nightly/last') }
+
+  before { FileUtils.mkdir_p(File.join(dir, '.raider/schedules/nightly')) }
+
+  after { FileUtils.rm_rf(dir) }
+
+  def write_run(statuses, started_at: '2026-11-11T08:00:01.000Z')
+    FileUtils.mkdir_p(results)
+    run = started_at ? { 'started_at' => started_at } : {}
+    File.write(File.join(results, 'run.json'), JSON.generate('run' => run, 'results' => statuses.map { |status| { 'status' => status } }))
+  end
+
+  def load = described_class.load(project, since: spawned_at)
+
+  it 'counts results: quarantined as failed, pending as skipped' do
+    write_run(%w[passed failed quarantined pending skipped passed])
+
+    expect(load.counts).to eq('total' => 6, 'passed' => 2, 'failed' => 2, 'skipped' => 2)
+  end
+
+  it 'is nil without a run.json' do
+    expect(load).to be_nil
+  end
+
+  it 'ignores a run.json left by an earlier run' do
+    write_run(%w[passed], started_at: '2026-11-11T07:00:00.000Z')
+
+    expect(load).to be_nil
+  end
+
+  it 'accepts a run that started up to 2 s before the spawn' do
+    write_run(%w[passed], started_at: '2026-11-11T07:59:58.500Z')
+
+    expect(load.counts['total']).to eq(1)
+  end
+
+  it 'falls back to the file time when run.json has no start time' do
+    write_run(%w[passed], started_at: nil)
+    file = File.join(results, 'run.json')
+    File.utime(spawned_at + 5, spawned_at + 5, file)
+    fresh = load
+
+    File.utime(spawned_at - 1, spawned_at - 1, file)
+    slack = load
+    File.utime(spawned_at - 60, spawned_at - 60, file)
+
+    expect([fresh&.counts&.fetch('total'), slack&.counts&.fetch('total'), load]).to eq([1, 1, nil])
+  end
+
+  it 'is nil for a run.json that is not a report' do
+    FileUtils.mkdir_p(results)
+    ['not json', '[1]', '{"results":"x"}'].each do |text|
+      File.write(File.join(results, 'run.json'), text)
+      expect(load).to be_nil
+    end
+  end
+
+  it 'never follows a linked run.json or results folder' do
+    other = File.join(dir, 'other')
+    FileUtils.mkdir_p(other)
+    File.write(File.join(other, 'run.json'), JSON.generate('run' => { 'started_at' => '2026-11-11T08:00:01Z' }, 'results' => []))
+    File.symlink(other, results)
+    linked_folder = load
+    FileUtils.rm(results)
+    FileUtils.mkdir_p(results)
+    File.symlink(File.join(other, 'run.json'), File.join(results, 'run.json'))
+
+    expect([linked_folder, load]).to eq([nil, nil])
+  end
+
+  describe '#copy_to' do
+    before do
+      write_run(%w[passed])
+      File.write(File.join(results, 'index.html'), '<html>')
+      FileUtils.mkdir_p(File.join(results, 'attachments/sub'))
+      File.write(File.join(results, 'attachments/0-shot.png'), 'png')
+      File.write(File.join(results, 'attachments/sub/trace.zip'), 'zip')
+    end
+
+    it 'copies run.json, index.html and the attachments, replacing the last copy' do
+      FileUtils.mkdir_p(last)
+      File.write(File.join(last, 'old.txt'), 'old')
+
+      expect(load.copy_to(last)).to be(true)
+      expect(Dir.glob('**/*', base: last).sort).to eq(%w[attachments attachments/0-shot.png attachments/sub attachments/sub/trace.zip index.html run.json])
+      expect(File.read(File.join(last, 'attachments/sub/trace.zip'))).to eq('zip')
+      expect(Dir.children(File.dirname(last))).to eq(['last'])
+      expect(File.stat(last).mode & 0o777).to eq(0o700)
+    end
+
+    it 'leaves out the attachments when there are too many files or folders too deep' do
+      stub_const("#{described_class}::MAX_ATTACHMENT_FILES", 1)
+      load.copy_to(last)
+      many = Dir.children(last).sort
+      FileUtils.rm_rf(last)
+      stub_const("#{described_class}::MAX_ATTACHMENT_FILES", 1000)
+      stub_const("#{described_class}::MAX_ATTACHMENT_DEPTH", 0)
+      load.copy_to(last)
+
+      expect([many, Dir.children(last).sort]).to eq([%w[index.html run.json], %w[index.html run.json]])
+    end
+
+    it 'copies no more of a file than was counted for it' do
+      target = File.join(dir, 'copy.png')
+      load.send(:copy_file, File.join(results, 'attachments/0-shot.png'), target, 2)
+
+      expect(File.read(target)).to eq('pn')
+    end
+
+    it 'leaves out the attachments when they are over the cap' do
+      stub_const("#{described_class}::MAX_ATTACHMENT_BYTES", 5)
+
+      load.copy_to(last)
+
+      expect(Dir.children(last).sort).to eq(%w[index.html run.json])
+    end
+
+    it 'copies regular files only, never what a link points at' do
+      secret = File.join(dir, 'secret.txt')
+      File.write(secret, 'secret')
+      File.symlink(secret, File.join(results, 'attachments/leak.txt'))
+      File.symlink(File.dirname(secret), File.join(results, 'attachments/leakdir'))
+      FileUtils.rm(File.join(results, 'index.html'))
+      File.symlink(secret, File.join(results, 'index.html'))
+
+      load.copy_to(last)
+
+      expect(Dir.glob('**/*', base: last).sort).to eq(%w[attachments attachments/0-shot.png attachments/sub attachments/sub/trace.zip run.json])
+    end
+
+    it 'leaves raider-results as it was' do
+      before = Dir.glob('**/*', base: results).sort.to_h { |path| [path, File.file?(File.join(results, path)) && File.read(File.join(results, path))] }
+      load.copy_to(last)
+
+      expect(Dir.glob('**/*', base: results).sort.to_h { |path| [path, File.file?(File.join(results, path)) && File.read(File.join(results, path))] }).to eq(before)
+    end
+  end
+end